id stringlengths 11 11 | created timestamp[s]date 2026-01-01 00:00:00 2026-01-01 00:00:00 | topic stringclasses 12 values | task_type stringclasses 8 values | difficulty stringclasses 4 values | instruction stringlengths 201 264 | input stringclasses 1 value | output stringclasses 7 values | metadata dict |
|---|---|---|---|---|---|---|---|---|
train_01500 | 2026-01-01T00:00:00 | Model merging, distillation, and continued pretraining | agent_loop | foundation | Task: agent_loop
Topic: Model merging, distillation, and continued pretraining
Difficulty: foundation
Target language: Go
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "Go",
"developer_needs": [
"evaluation_metrics",
"security_gates",
"cost_latency_tradeoffs"
]
} | |
train_01501 | 2026-01-01T00:00:00 | Secure code generation and policy gates | code | expert | Task: code
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: SQL
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "SQL",
"developer_needs": [
"governance",
"tooling",
"reproducibility"
]
} | |
train_01502 | 2026-01-01T00:00:00 | Model merging, distillation, and continued pretraining | code | expert | Task: code
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Bash",
"developer_needs": [
"ci_integration",
"documentation",
"security_gates"
]
} | |
train_01503 | 2026-01-01T00:00:00 | Mixture-of-Experts (MoE) for code | review | advanced | Task: review
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: Rust
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "Rust",
"developer_needs": [
"tooling",
"governance",
"documentation"
]
} | |
train_01504 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | data_pipeline | expert | Task: data_pipeline
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: expert
Target language: Rust
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "Rust",
"developer_needs": [
"documentation",
"security_gates",
"ci_integration"
]
} | |
train_01505 | 2026-01-01T00:00:00 | Agentic coding systems (plan→edit→test→reflect) | compare | foundation | Task: compare
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: foundation
Target language: Java
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Compare: capability, cost, latency, reliability, governance
| {
"target_language": "Java",
"developer_needs": [
"governance",
"cost_latency_tradeoffs",
"ci_integration"
]
} | |
train_01506 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | review | intermediate | Task: review
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Rust
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "Rust",
"developer_needs": [
"cost_latency_tradeoffs",
"evaluation_metrics",
"documentation"
]
} | |
train_01507 | 2026-01-01T00:00:00 | Extended context and repo-scale understanding | agent_loop | expert | Task: agent_loop
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: Java
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "Java",
"developer_needs": [
"tooling",
"governance",
"tests_are_truth"
]
} | |
train_01508 | 2026-01-01T00:00:00 | Tool calling, sandboxes, and CI integration | compare | foundation | Task: compare
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
Target language: C#
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Compare: capability, cost, latency, reliability, governance
| {
"target_language": "C#",
"developer_needs": [
"repo_scale_reasoning",
"cost_latency_tradeoffs",
"documentation"
]
} | |
train_01509 | 2026-01-01T00:00:00 | Extended context and repo-scale understanding | review | expert | Task: review
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: JavaScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "JavaScript",
"developer_needs": [
"documentation",
"tests_are_truth",
"ci_integration"
]
} | |
train_01510 | 2026-01-01T00:00:00 | Extended context and repo-scale understanding | design | intermediate | Task: design
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: Go
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Go",
"developer_needs": [
"security_gates",
"tooling",
"reproducibility"
]
} | |
train_01511 | 2026-01-01T00:00:00 | Secure code generation and policy gates | compare | expert | Task: compare
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: SQL
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Compare: capability, cost, latency, reliability, governance
| {
"target_language": "SQL",
"developer_needs": [
"security_gates",
"tooling",
"cost_latency_tradeoffs"
]
} | |
train_01512 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | eval | foundation | Task: eval
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: foundation
Target language: Java
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "Java",
"developer_needs": [
"governance",
"tests_are_truth",
"tooling"
]
} | |
train_01513 | 2026-01-01T00:00:00 | Extended context and repo-scale understanding | code | advanced | Task: code
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "JavaScript",
"developer_needs": [
"evaluation_metrics",
"security_gates",
"ci_integration"
]
} | |
train_01514 | 2026-01-01T00:00:00 | Mixture-of-Experts (MoE) for code | explain | expert | Task: explain
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: Java
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Java",
"developer_needs": [
"cost_latency_tradeoffs",
"repo_scale_reasoning",
"reproducibility"
]
} | |
train_01515 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | eval | advanced | Task: eval
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: Java
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "Java",
"developer_needs": [
"security_gates",
"ci_integration",
"governance"
]
} | |
train_01516 | 2026-01-01T00:00:00 | Mixture-of-Experts (MoE) for code | eval | advanced | Task: eval
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: Go
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "Go",
"developer_needs": [
"governance",
"tooling",
"cost_latency_tradeoffs"
]
} | |
train_01517 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | review | advanced | Task: review
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: C#
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "C#",
"developer_needs": [
"evaluation_metrics",
"repo_scale_reasoning",
"security_gates"
]
} | |
train_01518 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | agent_loop | intermediate | Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: Python
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "Python",
"developer_needs": [
"cost_latency_tradeoffs",
"governance",
"tests_are_truth"
]
} | |
train_01519 | 2026-01-01T00:00:00 | Reasoning-first coding models and tunable deliberation | design | advanced | Task: design
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: Rust
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Rust",
"developer_needs": [
"governance",
"security_gates",
"documentation"
]
} | |
train_01520 | 2026-01-01T00:00:00 | Secure code generation and policy gates | eval | expert | Task: eval
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: Java
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "Java",
"developer_needs": [
"security_gates",
"reproducibility",
"documentation"
]
} | |
train_01521 | 2026-01-01T00:00:00 | Agentic coding systems (plan→edit→test→reflect) | eval | intermediate | Task: eval
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: JavaScript
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "JavaScript",
"developer_needs": [
"security_gates",
"tests_are_truth",
"reproducibility"
]
} | |
train_01522 | 2026-01-01T00:00:00 | Secure code generation and policy gates | explain | expert | Task: explain
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: SQL
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "SQL",
"developer_needs": [
"governance",
"documentation",
"security_gates"
]
} | |
train_01523 | 2026-01-01T00:00:00 | Reasoning-first coding models and tunable deliberation | data_pipeline | expert | Task: data_pipeline
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: Go
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "Go",
"developer_needs": [
"tooling",
"cost_latency_tradeoffs",
"ci_integration"
]
} | |
train_01524 | 2026-01-01T00:00:00 | Secure code generation and policy gates | review | advanced | Task: review
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: Java
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "Java",
"developer_needs": [
"evaluation_metrics",
"documentation",
"governance"
]
} | |
train_01525 | 2026-01-01T00:00:00 | Multimodal dev workflows (docs, diagrams, traces) | review | foundation | Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: foundation
Target language: JavaScript
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "JavaScript",
"developer_needs": [
"tooling",
"repo_scale_reasoning",
"cost_latency_tradeoffs"
]
} | |
train_01526 | 2026-01-01T00:00:00 | Mixture-of-Experts (MoE) for code | explain | advanced | Task: explain
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: C#
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "C#",
"developer_needs": [
"ci_integration",
"reproducibility",
"security_gates"
]
} | |
train_01527 | 2026-01-01T00:00:00 | Multimodal dev workflows (docs, diagrams, traces) | code | foundation | Task: code
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: foundation
Target language: TypeScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "TypeScript",
"developer_needs": [
"documentation",
"ci_integration",
"tests_are_truth"
]
} | |
train_01528 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | agent_loop | foundation | Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: foundation
Target language: SQL
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "SQL",
"developer_needs": [
"tests_are_truth",
"ci_integration",
"evaluation_metrics"
]
} | |
train_01529 | 2026-01-01T00:00:00 | Secure code generation and policy gates | agent_loop | intermediate | Task: agent_loop
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "JavaScript",
"developer_needs": [
"documentation",
"repo_scale_reasoning",
"ci_integration"
]
} | |
train_01530 | 2026-01-01T00:00:00 | Extended context and repo-scale understanding | code | advanced | Task: code
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: Rust
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Rust",
"developer_needs": [
"documentation",
"reproducibility",
"governance"
]
} | |
train_01531 | 2026-01-01T00:00:00 | SWE-bench style real-repo evaluation | review | advanced | Task: review
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: Java
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "Java",
"developer_needs": [
"ci_integration",
"tests_are_truth",
"security_gates"
]
} | |
train_01532 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | agent_loop | intermediate | Task: agent_loop
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: JavaScript
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "JavaScript",
"developer_needs": [
"repo_scale_reasoning",
"reproducibility",
"evaluation_metrics"
]
} | |
train_01533 | 2026-01-01T00:00:00 | Governance, provenance, and licensing for code data | explain | advanced | Task: explain
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
Target language: Java
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Java",
"developer_needs": [
"repo_scale_reasoning",
"tooling",
"cost_latency_tradeoffs"
]
} | |
train_01534 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | explain | intermediate | Task: explain
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: Go
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Go",
"developer_needs": [
"tooling",
"governance",
"documentation"
]
} | |
train_01535 | 2026-01-01T00:00:00 | Multimodal dev workflows (docs, diagrams, traces) | review | advanced | Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
Target language: JavaScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "JavaScript",
"developer_needs": [
"tooling",
"tests_are_truth",
"security_gates"
]
} | |
train_01536 | 2026-01-01T00:00:00 | Mixture-of-Experts (MoE) for code | compare | intermediate | Task: compare
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Python
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Compare: capability, cost, latency, reliability, governance
| {
"target_language": "Python",
"developer_needs": [
"tests_are_truth",
"cost_latency_tradeoffs",
"reproducibility"
]
} | |
train_01537 | 2026-01-01T00:00:00 | Governance, provenance, and licensing for code data | data_pipeline | intermediate | Task: data_pipeline
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: SQL
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "SQL",
"developer_needs": [
"governance",
"ci_integration",
"documentation"
]
} | |
train_01538 | 2026-01-01T00:00:00 | Governance, provenance, and licensing for code data | data_pipeline | expert | Task: data_pipeline
Topic: Governance, provenance, and licensing for code data
Difficulty: expert
Target language: JavaScript
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "JavaScript",
"developer_needs": [
"tooling",
"reproducibility",
"evaluation_metrics"
]
} | |
train_01539 | 2026-01-01T00:00:00 | SWE-bench style real-repo evaluation | review | advanced | Task: review
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: C#
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "C#",
"developer_needs": [
"ci_integration",
"evaluation_metrics",
"tests_are_truth"
]
} | |
train_01540 | 2026-01-01T00:00:00 | Agentic coding systems (plan→edit→test→reflect) | review | foundation | Task: review
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: foundation
Target language: Python
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "Python",
"developer_needs": [
"documentation",
"cost_latency_tradeoffs",
"security_gates"
]
} | |
train_01541 | 2026-01-01T00:00:00 | Governance, provenance, and licensing for code data | design | intermediate | Task: design
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: C#
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "C#",
"developer_needs": [
"evaluation_metrics",
"ci_integration",
"documentation"
]
} | |
train_01542 | 2026-01-01T00:00:00 | Reasoning-first coding models and tunable deliberation | code | intermediate | Task: code
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: Python
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Reference scaffold:
```python
def agent_loop(plan, edit, test, issue, max_iters=3):
history = []
p = plan(issue)
for _ in range(max_iters):
patch = edit(issue, p)
ok, report = test(patch)
history.append({"plan": p, "passed": ok, "report": report[:200]})
if ok:
return patch, history
p = p + " | refine from failures"
return patch, history
```
Operational notes: sandbox, pinned deps, human gate. | {
"target_language": "Python",
"developer_needs": [
"tests_are_truth",
"cost_latency_tradeoffs",
"governance"
]
} | |
train_01543 | 2026-01-01T00:00:00 | Reasoning-first coding models and tunable deliberation | data_pipeline | advanced | Task: data_pipeline
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "Bash",
"developer_needs": [
"ci_integration",
"governance",
"tests_are_truth"
]
} | |
train_01544 | 2026-01-01T00:00:00 | Multimodal dev workflows (docs, diagrams, traces) | agent_loop | intermediate | Task: agent_loop
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: SQL
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "SQL",
"developer_needs": [
"ci_integration",
"cost_latency_tradeoffs",
"repo_scale_reasoning"
]
} | |
train_01545 | 2026-01-01T00:00:00 | Tool calling, sandboxes, and CI integration | compare | foundation | Task: compare
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
Target language: Rust
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Compare: capability, cost, latency, reliability, governance
| {
"target_language": "Rust",
"developer_needs": [
"tooling",
"repo_scale_reasoning",
"governance"
]
} | |
train_01546 | 2026-01-01T00:00:00 | SWE-bench style real-repo evaluation | code | intermediate | Task: code
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: SQL
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "SQL",
"developer_needs": [
"reproducibility",
"governance",
"tests_are_truth"
]
} | |
train_01547 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | explain | intermediate | Task: explain
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: Rust
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Rust",
"developer_needs": [
"cost_latency_tradeoffs",
"security_gates",
"governance"
]
} | |
train_01548 | 2026-01-01T00:00:00 | Agentic coding systems (plan→edit→test→reflect) | eval | foundation | Task: eval
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: foundation
Target language: Python
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "Python",
"developer_needs": [
"governance",
"ci_integration",
"tests_are_truth"
]
} | |
train_01549 | 2026-01-01T00:00:00 | Reasoning-first coding models and tunable deliberation | compare | expert | Task: compare
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
Target language: SQL
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Compare: capability, cost, latency, reliability, governance
| {
"target_language": "SQL",
"developer_needs": [
"security_gates",
"reproducibility",
"repo_scale_reasoning"
]
} | |
train_01550 | 2026-01-01T00:00:00 | Secure code generation and policy gates | code | advanced | Task: code
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: Rust
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Rust",
"developer_needs": [
"repo_scale_reasoning",
"documentation",
"ci_integration"
]
} | |
train_01551 | 2026-01-01T00:00:00 | Extended context and repo-scale understanding | eval | advanced | Task: eval
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: SQL
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "SQL",
"developer_needs": [
"evaluation_metrics",
"ci_integration",
"tooling"
]
} | |
train_01552 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | code | advanced | Task: code
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: advanced
Target language: Rust
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Rust",
"developer_needs": [
"repo_scale_reasoning",
"security_gates",
"governance"
]
} | |
train_01553 | 2026-01-01T00:00:00 | Model merging, distillation, and continued pretraining | compare | advanced | Task: compare
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: Go
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Compare: capability, cost, latency, reliability, governance
| {
"target_language": "Go",
"developer_needs": [
"ci_integration",
"evaluation_metrics",
"governance"
]
} | |
train_01554 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | explain | intermediate | Task: explain
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: C#
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "C#",
"developer_needs": [
"cost_latency_tradeoffs",
"reproducibility",
"documentation"
]
} | |
train_01555 | 2026-01-01T00:00:00 | Secure code generation and policy gates | review | advanced | Task: review
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: Python
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "Python",
"developer_needs": [
"evaluation_metrics",
"tooling",
"repo_scale_reasoning"
]
} | |
train_01556 | 2026-01-01T00:00:00 | Mixture-of-Experts (MoE) for code | compare | intermediate | Task: compare
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: JavaScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Compare: capability, cost, latency, reliability, governance
| {
"target_language": "JavaScript",
"developer_needs": [
"cost_latency_tradeoffs",
"evaluation_metrics",
"tooling"
]
} | |
train_01557 | 2026-01-01T00:00:00 | Agentic coding systems (plan→edit→test→reflect) | design | expert | Task: design
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: JavaScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "JavaScript",
"developer_needs": [
"evaluation_metrics",
"tooling",
"documentation"
]
} | |
train_01558 | 2026-01-01T00:00:00 | SWE-bench style real-repo evaluation | data_pipeline | foundation | Task: data_pipeline
Topic: SWE-bench style real-repo evaluation
Difficulty: foundation
Target language: JavaScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "JavaScript",
"developer_needs": [
"governance",
"security_gates",
"tests_are_truth"
]
} | |
train_01559 | 2026-01-01T00:00:00 | Multimodal dev workflows (docs, diagrams, traces) | explain | intermediate | Task: explain
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
Target language: Python
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Python",
"developer_needs": [
"tests_are_truth",
"governance",
"cost_latency_tradeoffs"
]
} | |
train_01560 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | explain | intermediate | Task: explain
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Go
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Go",
"developer_needs": [
"governance",
"cost_latency_tradeoffs",
"repo_scale_reasoning"
]
} | |
train_01561 | 2026-01-01T00:00:00 | SWE-bench style real-repo evaluation | review | advanced | Task: review
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: JavaScript
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "JavaScript",
"developer_needs": [
"cost_latency_tradeoffs",
"documentation",
"tooling"
]
} | |
train_01562 | 2026-01-01T00:00:00 | Tool calling, sandboxes, and CI integration | data_pipeline | expert | Task: data_pipeline
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: SQL
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "SQL",
"developer_needs": [
"ci_integration",
"security_gates",
"repo_scale_reasoning"
]
} | |
train_01563 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | explain | intermediate | Task: explain
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: Rust
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Rust",
"developer_needs": [
"ci_integration",
"repo_scale_reasoning",
"evaluation_metrics"
]
} | |
train_01564 | 2026-01-01T00:00:00 | Governance, provenance, and licensing for code data | code | foundation | Task: code
Topic: Governance, provenance, and licensing for code data
Difficulty: foundation
Target language: Rust
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Rust",
"developer_needs": [
"ci_integration",
"governance",
"repo_scale_reasoning"
]
} | |
train_01565 | 2026-01-01T00:00:00 | Secure code generation and policy gates | explain | intermediate | Task: explain
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: Java
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Java",
"developer_needs": [
"security_gates",
"reproducibility",
"cost_latency_tradeoffs"
]
} | |
train_01566 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | code | intermediate | Task: code
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: Python
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Reference scaffold:
```python
def agent_loop(plan, edit, test, issue, max_iters=3):
history = []
p = plan(issue)
for _ in range(max_iters):
patch = edit(issue, p)
ok, report = test(patch)
history.append({"plan": p, "passed": ok, "report": report[:200]})
if ok:
return patch, history
p = p + " | refine from failures"
return patch, history
```
Operational notes: sandbox, pinned deps, human gate. | {
"target_language": "Python",
"developer_needs": [
"tooling",
"security_gates",
"evaluation_metrics"
]
} | |
train_01567 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | agent_loop | advanced | Task: agent_loop
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: advanced
Target language: Go
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "Go",
"developer_needs": [
"documentation",
"governance",
"evaluation_metrics"
]
} | |
train_01568 | 2026-01-01T00:00:00 | Extended context and repo-scale understanding | explain | foundation | Task: explain
Topic: Extended context and repo-scale understanding
Difficulty: foundation
Target language: Python
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Python",
"developer_needs": [
"tooling",
"ci_integration",
"repo_scale_reasoning"
]
} | |
train_01569 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | data_pipeline | advanced | Task: data_pipeline
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: advanced
Target language: Go
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "Go",
"developer_needs": [
"ci_integration",
"documentation",
"security_gates"
]
} | |
train_01570 | 2026-01-01T00:00:00 | Multimodal dev workflows (docs, diagrams, traces) | review | foundation | Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: foundation
Target language: SQL
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "SQL",
"developer_needs": [
"repo_scale_reasoning",
"documentation",
"ci_integration"
]
} | |
train_01571 | 2026-01-01T00:00:00 | Agentic coding systems (plan→edit→test→reflect) | design | intermediate | Task: design
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: Bash
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Bash",
"developer_needs": [
"ci_integration",
"evaluation_metrics",
"tooling"
]
} | |
train_01572 | 2026-01-01T00:00:00 | Tool calling, sandboxes, and CI integration | explain | advanced | Task: explain
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: Java
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Java",
"developer_needs": [
"governance",
"reproducibility",
"tests_are_truth"
]
} | |
train_01573 | 2026-01-01T00:00:00 | Agentic coding systems (plan→edit→test→reflect) | review | intermediate | Task: review
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: Java
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "Java",
"developer_needs": [
"repo_scale_reasoning",
"ci_integration",
"reproducibility"
]
} | |
train_01574 | 2026-01-01T00:00:00 | Model merging, distillation, and continued pretraining | compare | advanced | Task: compare
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: Go
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Compare: capability, cost, latency, reliability, governance
| {
"target_language": "Go",
"developer_needs": [
"repo_scale_reasoning",
"cost_latency_tradeoffs",
"documentation"
]
} | |
train_01575 | 2026-01-01T00:00:00 | SWE-bench style real-repo evaluation | review | foundation | Task: review
Topic: SWE-bench style real-repo evaluation
Difficulty: foundation
Target language: Java
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "Java",
"developer_needs": [
"cost_latency_tradeoffs",
"reproducibility",
"ci_integration"
]
} | |
train_01576 | 2026-01-01T00:00:00 | Agentic coding systems (plan→edit→test→reflect) | agent_loop | expert | Task: agent_loop
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: Bash
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "Bash",
"developer_needs": [
"tooling",
"repo_scale_reasoning",
"reproducibility"
]
} | |
train_01577 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | review | advanced | Task: review
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: advanced
Target language: SQL
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "SQL",
"developer_needs": [
"reproducibility",
"repo_scale_reasoning",
"evaluation_metrics"
]
} | |
train_01578 | 2026-01-01T00:00:00 | Agentic coding systems (plan→edit→test→reflect) | code | advanced | Task: code
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: TypeScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "TypeScript",
"developer_needs": [
"governance",
"cost_latency_tradeoffs",
"evaluation_metrics"
]
} | |
train_01579 | 2026-01-01T00:00:00 | Reasoning-first coding models and tunable deliberation | data_pipeline | advanced | Task: data_pipeline
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: SQL
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "SQL",
"developer_needs": [
"security_gates",
"documentation",
"ci_integration"
]
} | |
train_01580 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | data_pipeline | expert | Task: data_pipeline
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: C#
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "C#",
"developer_needs": [
"cost_latency_tradeoffs",
"documentation",
"repo_scale_reasoning"
]
} | |
train_01581 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | data_pipeline | intermediate | Task: data_pipeline
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: C#
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "C#",
"developer_needs": [
"security_gates",
"tests_are_truth",
"tooling"
]
} | |
train_01582 | 2026-01-01T00:00:00 | SWE-bench style real-repo evaluation | explain | advanced | Task: explain
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: Python
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Python",
"developer_needs": [
"evaluation_metrics",
"ci_integration",
"repo_scale_reasoning"
]
} | |
train_01583 | 2026-01-01T00:00:00 | Code-specialized model families and sizing tradeoffs | eval | advanced | Task: eval
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: advanced
Target language: Go
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "Go",
"developer_needs": [
"documentation",
"repo_scale_reasoning",
"reproducibility"
]
} | |
train_01584 | 2026-01-01T00:00:00 | Reasoning-first coding models and tunable deliberation | data_pipeline | intermediate | Task: data_pipeline
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: TypeScript
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
| {
"target_language": "TypeScript",
"developer_needs": [
"security_gates",
"documentation",
"reproducibility"
]
} | |
train_01585 | 2026-01-01T00:00:00 | Reasoning-first coding models and tunable deliberation | eval | intermediate | Task: eval
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: TypeScript
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "TypeScript",
"developer_needs": [
"repo_scale_reasoning",
"reproducibility",
"ci_integration"
]
} | |
train_01586 | 2026-01-01T00:00:00 | Extended context and repo-scale understanding | explain | expert | Task: explain
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Bash",
"developer_needs": [
"documentation",
"ci_integration",
"tooling"
]
} | |
train_01587 | 2026-01-01T00:00:00 | Reasoning-first coding models and tunable deliberation | review | intermediate | Task: review
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: SQL
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Review: correctness, security, performance, governance
| {
"target_language": "SQL",
"developer_needs": [
"tooling",
"security_gates",
"reproducibility"
]
} | |
train_01588 | 2026-01-01T00:00:00 | Model merging, distillation, and continued pretraining | agent_loop | expert | Task: agent_loop
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: Rust
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "Rust",
"developer_needs": [
"governance",
"tooling",
"ci_integration"
]
} | |
train_01589 | 2026-01-01T00:00:00 | Secure code generation and policy gates | agent_loop | foundation | Task: agent_loop
Topic: Secure code generation and policy gates
Difficulty: foundation
Target language: Java
Context: Create an eval harness that reflects real developer workflows.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "Java",
"developer_needs": [
"documentation",
"ci_integration",
"reproducibility"
]
} | |
train_01590 | 2026-01-01T00:00:00 | Extended context and repo-scale understanding | agent_loop | expert | Task: agent_loop
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: TypeScript
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "TypeScript",
"developer_needs": [
"ci_integration",
"tests_are_truth",
"security_gates"
]
} | |
train_01591 | 2026-01-01T00:00:00 | SWE-bench style real-repo evaluation | eval | intermediate | Task: eval
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "JavaScript",
"developer_needs": [
"documentation",
"tooling",
"tests_are_truth"
]
} | |
train_01592 | 2026-01-01T00:00:00 | Reasoning-first coding models and tunable deliberation | agent_loop | intermediate | Task: agent_loop
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: TypeScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "TypeScript",
"developer_needs": [
"documentation",
"governance",
"tooling"
]
} | |
train_01593 | 2026-01-01T00:00:00 | Model merging, distillation, and continued pretraining | design | expert | Task: design
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: JavaScript
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "JavaScript",
"developer_needs": [
"evaluation_metrics",
"cost_latency_tradeoffs",
"tooling"
]
} | |
train_01594 | 2026-01-01T00:00:00 | Secure code generation and policy gates | agent_loop | advanced | Task: agent_loop
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: Bash
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "Bash",
"developer_needs": [
"repo_scale_reasoning",
"cost_latency_tradeoffs",
"governance"
]
} | |
train_01595 | 2026-01-01T00:00:00 | Model merging, distillation, and continued pretraining | agent_loop | foundation | Task: agent_loop
Topic: Model merging, distillation, and continued pretraining
Difficulty: foundation
Target language: SQL
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "SQL",
"developer_needs": [
"documentation",
"evaluation_metrics",
"cost_latency_tradeoffs"
]
} | |
train_01596 | 2026-01-01T00:00:00 | Dataset curation pipelines (filter, dedupe, quality) | eval | advanced | Task: eval
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: Java
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
| {
"target_language": "Java",
"developer_needs": [
"repo_scale_reasoning",
"cost_latency_tradeoffs",
"security_gates"
]
} | |
train_01597 | 2026-01-01T00:00:00 | Model merging, distillation, and continued pretraining | agent_loop | expert | Task: agent_loop
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: SQL
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "SQL",
"developer_needs": [
"evaluation_metrics",
"ci_integration",
"repo_scale_reasoning"
]
} | |
train_01598 | 2026-01-01T00:00:00 | Secure code generation and policy gates | agent_loop | intermediate | Task: agent_loop
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: Bash
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
| {
"target_language": "Bash",
"developer_needs": [
"tooling",
"documentation",
"reproducibility"
]
} | |
train_01599 | 2026-01-01T00:00:00 | Agentic coding systems (plan→edit→test→reflect) | design | expert | Task: design
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: Rust
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts. | Key facts:
- Modern AI coding emphasizes correctness via tests, agentic loops, and real-repo evaluation.
- Reasoning-first and MoE approaches improve capability-per-compute when paired with tools.
Design guidance with risks, metrics, acceptance criteria
| {
"target_language": "Rust",
"developer_needs": [
"documentation",
"governance",
"ci_integration"
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.