Instruction:
Task: review
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Bash
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: review
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: review
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

reproducibility governance documentation repo_scale_reasoning


Instruction:
Task: eval
Topic: Latency, cost, and reliability optimization
Difficulty: intermediate
Target language: Bash
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

ci_integration tooling reproducibility auditability


Instruction:
Task: patch_diff
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: Rust
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: failure_analysis
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: Java
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

auditability evaluation_metrics documentation tooling


Instruction:
Task: eval
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: Python
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size


Instruction:
Task: design
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: TypeScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: explain
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: JavaScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

tests_are_truth documentation reproducibility governance


Instruction:
Task: code
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: SQL
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: failure_analysis
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: JavaScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: eval
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: Java
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: review
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: SQL
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: Go
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

auditability security_gates tooling governance


Instruction:
Task: failure_analysis
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: Go
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: explain
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: Java
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

documentation governance auditability ci_integration


Instruction:
Task: review
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: Python
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance


Instruction:
Task: design
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: Java
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: failure_analysis
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: Java
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: patch_diff
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: Python
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: review
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance


Instruction:
Task: failure_analysis
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: Rust
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: failure_analysis
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

reproducibility documentation auditability cost_latency_tradeoffs


Instruction:
Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: SQL
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: data_pipeline
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: JavaScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: data_pipeline
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: Go
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

security_gates auditability governance tooling


Instruction:
Task: explain
Topic: Latency, cost, and reliability optimization
Difficulty: advanced
Target language: Go
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: failure_analysis
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: Go
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

tooling documentation auditability security_gates


Instruction:
Task: failure_analysis
Topic: SWE-bench style real-repo evaluation
Difficulty: expert
Target language: SQL
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: explain
Topic: Governance, provenance, and licensing for code data
Difficulty: expert
Target language: Go
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: data_pipeline
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: C#
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit


Instruction:
Task: code
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

auditability security_gates governance tooling


Instruction:
Task: design
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: Python
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: data_pipeline
Topic: Latency, cost, and reliability optimization
Difficulty: expert
Target language: Bash
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit


Instruction:
Task: compare
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: advanced
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

tooling governance reproducibility auditability


Instruction:
Task: patch_diff
Topic: Latency, cost, and reliability optimization
Difficulty: intermediate
Target language: SQL
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: design
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: Java
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: Bash
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability


Instruction:
Task: explain
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: Rust
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: Go
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability


Instruction:
Task: code
Topic: SWE-bench style real-repo evaluation
Difficulty: expert
Target language: C#
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

auditability documentation tooling security_gates


Instruction:
Task: design
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: C#
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: code
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: TypeScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

governance documentation auditability security_gates


Instruction:
Task: eval
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
Target language: Bash
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size


Instruction:
Task: agent_loop
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: explain
Topic: Latency, cost, and reliability optimization
Difficulty: expert
Target language: JavaScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: Rust
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

reproducibility ci_integration governance tooling


Instruction:
Task: compare
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: Java
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability


Instruction:
Task: eval
Topic: Model merging, distillation, and continued pretraining
Difficulty: intermediate
Target language: JavaScript
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: explain
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: SQL
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

tooling governance cost_latency_tradeoffs documentation


Instruction:
Task: explain
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: patch_diff
Topic: Self-improving agents and feedback loops
Difficulty: intermediate
Target language: Python
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: TypeScript
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: eval
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: Java
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: data_pipeline
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: JavaScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: eval
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
Target language: Go
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size


Instruction:
Task: compare
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: JavaScript
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: Java
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: Rust
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: Go
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability


Instruction:
Task: code
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: Go
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: patch_diff
Topic: Latency, cost, and reliability optimization
Difficulty: advanced
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: code
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: eval
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: JavaScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: Go
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: Bash
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance


Instruction:
Task: patch_diff
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: JavaScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: code
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: C#
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

reproducibility security_gates documentation governance


Instruction:
Task: explain
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: Python
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: SWE-bench style real-repo evaluation
Difficulty: expert
Target language: Bash
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance


Instruction:
Task: code
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Java
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: Python
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: failure_analysis
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: JavaScript
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

governance tooling cost_latency_tradeoffs documentation


Instruction:
Task: failure_analysis
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: C#
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: eval
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: SQL
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size


Instruction:
Task: agent_loop
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: Java
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: failure_analysis
Topic: Self-improving agents and feedback loops
Difficulty: intermediate
Target language: Rust
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: failure_analysis
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: SQL
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: eval
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: C#
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

security_gates tooling auditability governance


Instruction:
Task: design
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: expert
Target language: C#
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: patch_diff
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: Rust
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: Bash
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: review
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: Bash
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance


Instruction:
Task: design
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: Bash
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

documentation auditability governance tests_are_truth


Instruction:
Task: compare
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: JavaScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: Java
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: data_pipeline
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Self-improving agents and feedback loops
Difficulty: advanced
Target language: C#
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: code
Topic: Latency, cost, and reliability optimization
Difficulty: advanced
Target language: JavaScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: Java
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: SQL
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

evaluation_metrics governance auditability reproducibility


Instruction:
Task: explain
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: Java
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: code
Topic: Latency, cost, and reliability optimization
Difficulty: expert
Target language: Python
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Scaffold:
```python
def agent_loop(plan, edit, test, issue, max_iters=4):
    history = []
    p = plan(issue)
    for _ in range(max_iters):
        patch = edit(issue, p)
        ok, report = test(patch)
        history.append({"plan": p, "ok": ok})
        if ok:
            return patch, history
        p = p + " | refine"
    return patch, history

```

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

reproducibility auditability tooling ci_integration


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: TypeScript
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: Rust
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: eval
Topic: Latency, cost, and reliability optimization
Difficulty: intermediate
Target language: Bash
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size


Instruction:
Task: failure_analysis
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: Go
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: patch_diff
Topic: Latency, cost, and reliability optimization
Difficulty: expert
Target language: Go
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

auditability reproducibility governance cost_latency_tradeoffs


Instruction:
Task: agent_loop
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: Python
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate


Instruction:
Task: failure_analysis
Topic: Latency, cost, and reliability optimization
Difficulty: intermediate
Target language: C#
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

tests_are_truth auditability reproducibility governance


Instruction:
Task: eval
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: TypeScript
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size


Instruction:
Task: patch_diff
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: Bash
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

tooling cost_latency_tradeoffs reproducibility governance


Instruction:
Task: failure_analysis
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: C#
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: design
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: expert
Target language: TypeScript
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: compare
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: JavaScript
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: design
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: Rust
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: TypeScript
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: failure_analysis
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: Rust
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

tooling governance auditability tests_are_truth


Instruction:
Task: patch_diff
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: Java
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: review
Topic: Self-improving agents and feedback loops
Difficulty: intermediate
Target language: C#
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: patch_diff
Topic: SWE-bench style real-repo evaluation
Difficulty: expert
Target language: Python
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

governance reproducibility evaluation_metrics auditability


Instruction:
Task: failure_analysis
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: Rust
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: eval
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: Go
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: code
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
Target language: Bash
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

governance documentation cost_latency_tradeoffs tooling


Instruction:
Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: Bash
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: data_pipeline
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: JavaScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

reproducibility repo_scale_reasoning documentation auditability


Instruction:
Task: review
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: Go
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: code
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: Python
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Scaffold:
```python
def agent_loop(plan, edit, test, issue, max_iters=4):
    history = []
    p = plan(issue)
    for _ in range(max_iters):
        patch = edit(issue, p)
        ok, report = test(patch)
        history.append({"plan": p, "ok": ok})
        if ok:
            return patch, history
        p = p + " | refine"
    return patch, history

```


Instruction:
Task: code
Topic: Latency, cost, and reliability optimization
Difficulty: intermediate
Target language: SQL
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: code
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: Java
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: patch_diff
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: Bash
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: eval
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Python
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size


Instruction:
Task: agent_loop
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: JavaScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate


Instruction:
Task: patch_diff
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: Go
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: code
Topic: SWE-bench style real-repo evaluation
Difficulty: expert
Target language: Go
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: eval
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: JavaScript
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: code
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: TypeScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

auditability governance reproducibility documentation


Instruction:
Task: compare
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: JavaScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability


Instruction:
Task: failure_analysis
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: Go
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

reproducibility evaluation_metrics documentation tooling


Instruction:
Task: failure_analysis
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: TypeScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: data_pipeline
Topic: Self-improving agents and feedback loops
Difficulty: advanced
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit


Instruction:
Task: design
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: Go
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: failure_analysis
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: patch_diff
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: TypeScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: eval
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: C#
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: explain
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: data_pipeline
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit


Instruction:
Task: patch_diff
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: compare
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Bash
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: patch_diff
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: JavaScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: data_pipeline
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: Go
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit


Instruction:
Task: agent_loop
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: Java
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate


Instruction:
Task: failure_analysis
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Rust
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: agent_loop
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: Java
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

reproducibility auditability governance tests_are_truth


Instruction:
Task: code
Topic: Latency, cost, and reliability optimization
Difficulty: expert
Target language: Rust
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: review
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: Go
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance


Instruction:
Task: design
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: Bash
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: design
Topic: Governance, provenance, and licensing for code data
Difficulty: expert
Target language: Rust
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: explain
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Go
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: eval
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: Python
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

governance auditability security_gates tooling


Instruction:
Task: design
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: JavaScript
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: failure_analysis
Topic: Latency, cost, and reliability optimization
Difficulty: expert
Target language: Java
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: failure_analysis
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: Rust
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: patch_diff
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: C#
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: advanced
Target language: Rust
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability


Instruction:
Task: data_pipeline
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: advanced
Target language: Go
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit


Instruction:
Task: code
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: Go
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: failure_analysis
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Go
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: patch_diff
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: C#
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

auditability governance cost_latency_tradeoffs tooling


Instruction:
Task: patch_diff
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: JavaScript
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: code
Topic: Latency, cost, and reliability optimization
Difficulty: expert
Target language: Rust
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: explain
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: TypeScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria


Instruction:
Task: agent_loop
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: JavaScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: explain
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: Java
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

auditability documentation reproducibility governance


Instruction:
Task: failure_analysis
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: C#
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: patch_diff
Topic: SWE-bench style real-repo evaluation
Difficulty: expert
Target language: Go
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: eval
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: Go
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability


Instruction:
Task: review
Topic: Latency, cost, and reliability optimization
Difficulty: intermediate
Target language: Java
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance


Instruction:
Task: eval
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: expert
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: explain
Topic: Self-improving agents and feedback loops
Difficulty: intermediate
Target language: Java
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Design with risks, metrics, acceptance criteria

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: compare
Topic: Latency, cost, and reliability optimization
Difficulty: intermediate
Target language: Bash
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Compare: capability, cost, latency, reliability

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: patch_diff
Topic: Governance, provenance, and licensing for code data
Difficulty: expert
Target language: Rust
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: agent_loop
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Java
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate


Instruction:
Task: review
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: Python
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: review
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: Rust
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Review: correctness, security, performance, governance


Instruction:
Task: data_pipeline
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: Java
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit


Instruction:
Task: agent_loop
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Java
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate


Instruction:
Task: failure_analysis
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: C#
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: failure_analysis
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: JavaScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test


Instruction:
Task: eval
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Go
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Eval:
pass@k, time-to-green, regressions, diff size

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

auditability cost_latency_tradeoffs documentation governance


Instruction:
Task: patch_diff
Topic: Latency, cost, and reliability optimization
Difficulty: expert
Target language: TypeScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions


Instruction:
Task: patch_diff
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: JavaScript
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Patch (diff-style):
```diff
- if x == 0:
-     return 1/x
+ if x == 0:
+     raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions


Instruction:
Task: agent_loop
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: Python
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate

Identify failing behavior via tests
Minimize change surface
Apply patch
Run targeted + full suite
Verify no regressions

governance auditability tests_are_truth documentation


Instruction:
Task: agent_loop
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate


Instruction:
Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: C#
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.

Output:
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.

Loop: Plan → Edit → Test → Reflect → Human gate