Instruction:
Task: code
Topic: Extended context and repo-scale understanding
Difficulty: foundation
Target language: Python
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Reference scaffold:
```python
def agent_loop(plan, edit, test, issue, max_iters=3):
    history = []
    p = plan(issue)
    for _ in range(max_iters):
        patch = edit(issue, p)
        ok, report = test(patch)
        history.append({"plan": p, "passed": ok, "report": report[:200]})
        if ok:
            return patch, history
        p = p + " | refine from failures"
    return patch, history

```
Operational notes: sandbox, pinned deps, human gate.


Instruction:
Task: explain
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: Rust
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: eval
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: Rust
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: review
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
Target language: Python
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: code
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: Python
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Reference scaffold:
```python
def agent_loop(plan, edit, test, issue, max_iters=3):
    history = []
    p = plan(issue)
    for _ in range(max_iters):
        patch = edit(issue, p)
        ok, report = test(patch)
        history.append({"plan": p, "passed": ok, "report": report[:200]})
        if ok:
            return patch, history
        p = p + " | refine from failures"
    return patch, history

```
Operational notes: sandbox, pinned deps, human gate.


Instruction:
Task: design
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: TypeScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: TypeScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: code
Topic: Secure code generation and policy gates
Difficulty: foundation
Target language: Go
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: SQL
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: code
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: Java
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
Target language: Rust
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: eval
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: foundation
Target language: Rust
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: compare
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: C#
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: review
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: Java
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: review
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
Target language: TypeScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: agent_loop
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
Target language: Bash
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: agent_loop
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: design
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: SQL
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: eval
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: expert
Target language: Go
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: explain
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Go
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: foundation
Target language: C#
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: review
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: Go
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: compare
Topic: Extended context and repo-scale understanding
Difficulty: foundation
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: foundation
Target language: Java
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: design
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: expert
Target language: C#
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: foundation
Target language: Go
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: compare
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: Rust
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: code
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: Go
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: TypeScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: design
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: foundation
Target language: SQL
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: eval
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: JavaScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: design
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: JavaScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: explain
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: Go
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: design
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: Java
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: foundation
Target language: Go
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: data_pipeline
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: Java
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: compare
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: JavaScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: design
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: C#
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: design
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: C#
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: compare
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: Bash
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: compare
Topic: SWE-bench style real-repo evaluation
Difficulty: foundation
Target language: Bash
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: review
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: Go
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: compare
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: code
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: foundation
Target language: Python
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Reference scaffold:
```python
def agent_loop(plan, edit, test, issue, max_iters=3):
    history = []
    p = plan(issue)
    for _ in range(max_iters):
        patch = edit(issue, p)
        ok, report = test(patch)
        history.append({"plan": p, "passed": ok, "report": report[:200]})
        if ok:
            return patch, history
        p = p + " | refine from failures"
    return patch, history

```
Operational notes: sandbox, pinned deps, human gate.


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: foundation
Target language: SQL
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: design
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: JavaScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: design
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: C#
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: Secure code generation and policy gates
Difficulty: foundation
Target language: Python
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Reference scaffold:
```python
def agent_loop(plan, edit, test, issue, max_iters=3):
    history = []
    p = plan(issue)
    for _ in range(max_iters):
        patch = edit(issue, p)
        ok, report = test(patch)
        history.append({"plan": p, "passed": ok, "report": report[:200]})
        if ok:
            return patch, history
        p = p + " | refine from failures"
    return patch, history

```
Operational notes: sandbox, pinned deps, human gate.


Instruction:
Task: review
Topic: Governance, provenance, and licensing for code data
Difficulty: foundation
Target language: C#
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: eval
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
Target language: TypeScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: eval
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: Go
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: review
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: Java
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: compare
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: Bash
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: data_pipeline
Topic: Secure code generation and policy gates
Difficulty: foundation
Target language: Rust
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: explain
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: TypeScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Secure code generation and policy gates
Difficulty: foundation
Target language: Go
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: eval
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: SQL
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: eval
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: C#
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: review
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: compare
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: Java
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: eval
Topic: Model merging, distillation, and continued pretraining
Difficulty: intermediate
Target language: Python
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: code
Topic: Secure code generation and policy gates
Difficulty: foundation
Target language: Python
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Reference scaffold:
```python
def agent_loop(plan, edit, test, issue, max_iters=3):
    history = []
    p = plan(issue)
    for _ in range(max_iters):
        patch = edit(issue, p)
        ok, report = test(patch)
        history.append({"plan": p, "passed": ok, "report": report[:200]})
        if ok:
            return patch, history
        p = p + " | refine from failures"
    return patch, history

```
Operational notes: sandbox, pinned deps, human gate.


Instruction:
Task: data_pipeline
Topic: Governance, provenance, and licensing for code data
Difficulty: foundation
Target language: JavaScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: review
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: C#
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: Java
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: explain
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: SQL
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Python
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: design
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: C#
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: SQL
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: Rust
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: code
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: Bash
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: TypeScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: agent_loop
Topic: Model merging, distillation, and continued pretraining
Difficulty: foundation
Target language: Go
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: compare
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: Python
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: Java
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: design
Topic: Model merging, distillation, and continued pretraining
Difficulty: intermediate
Target language: SQL
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: explain
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: JavaScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: Go
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: code
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: design
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: Rust
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: TypeScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: C#
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: eval
Topic: Secure code generation and policy gates
Difficulty: foundation
Target language: Rust
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: compare
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: Python
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: data_pipeline
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: foundation
Target language: C#
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: agent_loop
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: C#
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: explain
Topic: Extended context and repo-scale understanding
Difficulty: foundation
Target language: Go
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: Python
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: data_pipeline
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: expert
Target language: Bash
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: eval
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
Target language: Python
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: compare
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Rust
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: compare
Topic: SWE-bench style real-repo evaluation
Difficulty: foundation
Target language: C#
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: compare
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: foundation
Target language: Rust
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: review
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: foundation
Target language: TypeScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: compare
Topic: SWE-bench style real-repo evaluation
Difficulty: foundation
Target language: SQL
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: explain
Topic: Extended context and repo-scale understanding
Difficulty: foundation
Target language: Java
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: design
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: Java
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: design
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: advanced
Target language: JavaScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: compare
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: Python
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: compare
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: JavaScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: code
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: C#
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: Rust
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: review
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: JavaScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: TypeScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: review
Topic: SWE-bench style real-repo evaluation
Difficulty: foundation
Target language: TypeScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: code
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: JavaScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: SQL
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: JavaScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: explain
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Bash
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: explain
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: Go
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: compare
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: JavaScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: code
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: C#
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: compare
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: TypeScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: eval
Topic: Governance, provenance, and licensing for code data
Difficulty: foundation
Target language: Go
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: data_pipeline
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: SQL
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: agent_loop
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: Python
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: eval
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: code
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: Bash
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: Rust
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: review
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: Python
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: compare
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: TypeScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: design
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
Target language: Bash
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: explain
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: SQL
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: Go
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: agent_loop
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: foundation
Target language: C#
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: code
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: design
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: Bash
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: Java
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: eval
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: Java
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: agent_loop
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: foundation
Target language: Java
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: expert
Target language: TypeScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: review
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: expert
Target language: Bash
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: code
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: JavaScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: Python
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: compare
Topic: Model merging, distillation, and continued pretraining
Difficulty: intermediate
Target language: Java
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: explain
Topic: Model merging, distillation, and continued pretraining
Difficulty: foundation
Target language: Rust
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: foundation
Target language: TypeScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Model merging, distillation, and continued pretraining
Difficulty: intermediate
Target language: TypeScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: code
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: expert
Target language: C#
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: eval
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: C#
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: review
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Python
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: agent_loop
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: Rust
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: data_pipeline
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: Python
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: Java
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: data_pipeline
Topic: Model merging, distillation, and continued pretraining
Difficulty: foundation
Target language: Go
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: code
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: JavaScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: C#
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: compare
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: expert
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: review
Topic: Model merging, distillation, and continued pretraining
Difficulty: foundation
Target language: Rust
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: agent_loop
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
Target language: Bash
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: agent_loop
Topic: Mixture-of-Experts (MoE) for code
Difficulty: foundation
Target language: Python
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: eval
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: TypeScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: Rust
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: compare
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: C#
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: eval
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: C#
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security


Instruction:
Task: agent_loop
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: Rust
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: data_pipeline
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: foundation
Target language: Bash
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: compare
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: Java
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: compare
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: foundation
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: JavaScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: code
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: C#
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: SQL
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: data_pipeline
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: Python
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: review
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: Python
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: agent_loop
Topic: Governance, provenance, and licensing for code data
Difficulty: expert
Target language: TypeScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: code
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: Bash
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: C#
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: design
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: foundation
Target language: Rust
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: design
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: Go
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: explain
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: Python
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: compare
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: TypeScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Compare: capability, cost, latency, reliability, governance


Instruction:
Task: code
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: C#
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: foundation
Target language: Rust
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Review: correctness, security, performance, governance


Instruction:
Task: data_pipeline
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: C#
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit


Instruction:
Task: agent_loop
Topic: Governance, provenance, and licensing for code data
Difficulty: expert
Target language: Python
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: agent_loop
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: Python
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate


Instruction:
Task: code
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: JavaScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: C#
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: Model merging, distillation, and continued pretraining
Difficulty: intermediate
Target language: JavaScript
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Design guidance with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: Rust
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.

Output:
Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.

Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate