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_01000
| 2026-01-01T00:00:00
|
Reasoning-first coding models and tunable deliberation
|
explain
|
intermediate
|
Task: explain
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
Target language: JavaScript
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": [
"tooling",
"reproducibility",
"ci_integration"
]
}
|
|
train_01001
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
code
|
expert
|
Task: code
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: C#
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": "C#",
"developer_needs": [
"cost_latency_tradeoffs",
"tooling",
"tests_are_truth"
]
}
|
|
train_01002
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
review
|
expert
|
Task: review
Topic: Mixture-of-Experts (MoE) for code
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.
Review: correctness, security, performance, governance
|
{
"target_language": "Bash",
"developer_needs": [
"evaluation_metrics",
"tests_are_truth",
"documentation"
]
}
|
|
train_01003
| 2026-01-01T00:00:00
|
Reasoning-first coding models and tunable deliberation
|
eval
|
expert
|
Task: eval
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: expert
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.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
|
{
"target_language": "Go",
"developer_needs": [
"repo_scale_reasoning",
"ci_integration",
"governance"
]
}
|
|
train_01004
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
design
|
expert
|
Task: design
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "Bash",
"developer_needs": [
"tests_are_truth",
"governance",
"cost_latency_tradeoffs"
]
}
|
|
train_01005
| 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: 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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "Bash",
"developer_needs": [
"tooling",
"evaluation_metrics",
"ci_integration"
]
}
|
|
train_01006
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
design
|
foundation
|
Task: design
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
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": [
"reproducibility",
"security_gates",
"ci_integration"
]
}
|
|
train_01007
| 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: 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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "JavaScript",
"developer_needs": [
"security_gates",
"cost_latency_tradeoffs",
"evaluation_metrics"
]
}
|
|
train_01008
| 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: 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": [
"tests_are_truth",
"reproducibility",
"governance"
]
}
|
|
train_01009
| 2026-01-01T00:00:00
|
SWE-bench style real-repo evaluation
|
data_pipeline
|
expert
|
Task: data_pipeline
Topic: SWE-bench style real-repo evaluation
Difficulty: expert
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.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
|
{
"target_language": "Go",
"developer_needs": [
"governance",
"evaluation_metrics",
"cost_latency_tradeoffs"
]
}
|
|
train_01010
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
compare
|
foundation
|
Task: compare
Topic: Model merging, distillation, and continued pretraining
Difficulty: foundation
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.
Compare: capability, cost, latency, reliability, governance
|
{
"target_language": "Java",
"developer_needs": [
"cost_latency_tradeoffs",
"repo_scale_reasoning",
"tooling"
]
}
|
|
train_01011
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
code
|
foundation
|
Task: code
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
Target language: Python
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": [
"reproducibility",
"repo_scale_reasoning",
"tests_are_truth"
]
}
|
|
train_01012
| 2026-01-01T00:00:00
|
Code-specialized model families and sizing tradeoffs
|
design
|
expert
|
Task: design
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: expert
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "SQL",
"developer_needs": [
"reproducibility",
"evaluation_metrics",
"governance"
]
}
|
|
train_01013
| 2026-01-01T00:00:00
|
Multimodal dev workflows (docs, diagrams, traces)
|
explain
|
expert
|
Task: explain
Topic: Multimodal dev workflows (docs, diagrams, traces)
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": [
"cost_latency_tradeoffs",
"reproducibility",
"documentation"
]
}
|
|
train_01014
| 2026-01-01T00:00:00
|
Multimodal dev workflows (docs, diagrams, traces)
|
data_pipeline
|
foundation
|
Task: data_pipeline
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: foundation
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",
"ci_integration",
"tests_are_truth"
]
}
|
|
train_01015
| 2026-01-01T00:00:00
|
Extended context and repo-scale understanding
|
review
|
advanced
|
Task: review
Topic: Extended context and repo-scale understanding
Difficulty: advanced
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.
Review: correctness, security, performance, governance
|
{
"target_language": "Python",
"developer_needs": [
"tests_are_truth",
"cost_latency_tradeoffs",
"reproducibility"
]
}
|
|
train_01016
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
compare
|
expert
|
Task: compare
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: TypeScript
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": "TypeScript",
"developer_needs": [
"ci_integration",
"evaluation_metrics",
"repo_scale_reasoning"
]
}
|
|
train_01017
| 2026-01-01T00:00:00
|
SWE-bench style real-repo evaluation
|
data_pipeline
|
advanced
|
Task: data_pipeline
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: Java
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": "Java",
"developer_needs": [
"cost_latency_tradeoffs",
"evaluation_metrics",
"documentation"
]
}
|
|
train_01018
| 2026-01-01T00:00:00
|
SWE-bench style real-repo evaluation
|
code
|
foundation
|
Task: code
Topic: SWE-bench style real-repo evaluation
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.
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": [
"governance",
"reproducibility",
"evaluation_metrics"
]
}
|
|
train_01019
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
review
|
advanced
|
Task: review
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
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.
Review: correctness, security, performance, governance
|
{
"target_language": "Java",
"developer_needs": [
"ci_integration",
"tooling",
"security_gates"
]
}
|
|
train_01020
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
review
|
expert
|
Task: review
Topic: Tool calling, sandboxes, and CI integration
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.
Review: correctness, security, performance, governance
|
{
"target_language": "TypeScript",
"developer_needs": [
"ci_integration",
"tooling",
"governance"
]
}
|
|
train_01021
| 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: 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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "TypeScript",
"developer_needs": [
"tooling",
"ci_integration",
"tests_are_truth"
]
}
|
|
train_01022
| 2026-01-01T00:00:00
|
Code-specialized model families and sizing tradeoffs
|
eval
|
intermediate
|
Task: eval
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": "Bash",
"developer_needs": [
"ci_integration",
"cost_latency_tradeoffs",
"security_gates"
]
}
|
|
train_01023
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
data_pipeline
|
foundation
|
Task: data_pipeline
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: foundation
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.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
|
{
"target_language": "Rust",
"developer_needs": [
"security_gates",
"cost_latency_tradeoffs",
"evaluation_metrics"
]
}
|
|
train_01024
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
eval
|
foundation
|
Task: eval
Topic: Mixture-of-Experts (MoE) for code
Difficulty: foundation
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.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
|
{
"target_language": "Bash",
"developer_needs": [
"ci_integration",
"repo_scale_reasoning",
"governance"
]
}
|
|
train_01025
| 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: 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.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
|
{
"target_language": "Python",
"developer_needs": [
"documentation",
"repo_scale_reasoning",
"tooling"
]
}
|
|
train_01026
| 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": [
"tests_are_truth",
"security_gates",
"documentation"
]
}
|
|
train_01027
| 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: 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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "JavaScript",
"developer_needs": [
"cost_latency_tradeoffs",
"governance",
"tests_are_truth"
]
}
|
|
train_01028
| 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: 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": "Go",
"developer_needs": [
"tooling",
"ci_integration",
"reproducibility"
]
}
|
|
train_01029
| 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: Python
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": "Python",
"developer_needs": [
"cost_latency_tradeoffs",
"ci_integration",
"tests_are_truth"
]
}
|
|
train_01030
| 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: Bash
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": "Bash",
"developer_needs": [
"reproducibility",
"governance",
"tests_are_truth"
]
}
|
|
train_01031
| 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: 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": [
"governance",
"tooling",
"repo_scale_reasoning"
]
}
|
|
train_01032
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
design
|
foundation
|
Task: design
Topic: Mixture-of-Experts (MoE) for code
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "SQL",
"developer_needs": [
"reproducibility",
"security_gates",
"documentation"
]
}
|
|
train_01033
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
design
|
foundation
|
Task: design
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: foundation
Target language: Python
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": [
"repo_scale_reasoning",
"evaluation_metrics",
"ci_integration"
]
}
|
|
train_01034
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
explain
|
intermediate
|
Task: explain
Topic: Agentic coding systems (plan→edit→test→reflect)
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "Python",
"developer_needs": [
"evaluation_metrics",
"repo_scale_reasoning",
"tests_are_truth"
]
}
|
|
train_01035
| 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: 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": [
"reproducibility",
"security_gates",
"evaluation_metrics"
]
}
|
|
train_01036
| 2026-01-01T00:00:00
|
Governance, provenance, and licensing for code data
|
compare
|
advanced
|
Task: compare
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
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.
Compare: capability, cost, latency, reliability, governance
|
{
"target_language": "Java",
"developer_needs": [
"security_gates",
"tests_are_truth",
"repo_scale_reasoning"
]
}
|
|
train_01037
| 2026-01-01T00:00:00
|
Code-specialized model families and sizing tradeoffs
|
compare
|
intermediate
|
Task: compare
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: TypeScript
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": "TypeScript",
"developer_needs": [
"security_gates",
"reproducibility",
"repo_scale_reasoning"
]
}
|
|
train_01038
| 2026-01-01T00:00:00
|
Code-specialized model families and sizing tradeoffs
|
eval
|
intermediate
|
Task: eval
Topic: Code-specialized model families and sizing tradeoffs
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.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
|
{
"target_language": "JavaScript",
"developer_needs": [
"cost_latency_tradeoffs",
"tests_are_truth",
"documentation"
]
}
|
|
train_01039
| 2026-01-01T00:00:00
|
Extended context and repo-scale understanding
|
agent_loop
|
advanced
|
Task: agent_loop
Topic: Extended context and repo-scale understanding
Difficulty: advanced
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": [
"documentation",
"security_gates",
"tooling"
]
}
|
|
train_01040
| 2026-01-01T00:00:00
|
SWE-bench style real-repo evaluation
|
design
|
foundation
|
Task: design
Topic: SWE-bench style real-repo evaluation
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "C#",
"developer_needs": [
"evaluation_metrics",
"repo_scale_reasoning",
"cost_latency_tradeoffs"
]
}
|
|
train_01041
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
explain
|
foundation
|
Task: explain
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "TypeScript",
"developer_needs": [
"repo_scale_reasoning",
"security_gates",
"documentation"
]
}
|
|
train_01042
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
eval
|
foundation
|
Task: eval
Topic: Mixture-of-Experts (MoE) for code
Difficulty: foundation
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.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
|
{
"target_language": "Bash",
"developer_needs": [
"documentation",
"tests_are_truth",
"security_gates"
]
}
|
|
train_01043
| 2026-01-01T00:00:00
|
Code-specialized model families and sizing tradeoffs
|
code
|
expert
|
Task: code
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: expert
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",
"cost_latency_tradeoffs",
"reproducibility"
]
}
|
|
train_01044
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
review
|
advanced
|
Task: review
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: Bash
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": "Bash",
"developer_needs": [
"security_gates",
"cost_latency_tradeoffs",
"governance"
]
}
|
|
train_01045
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
review
|
expert
|
Task: review
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: Python
Context: Evaluate two coding models for internal rollout under strict governance.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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",
"security_gates",
"ci_integration"
]
}
|
|
train_01046
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
code
|
foundation
|
Task: code
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "Go",
"developer_needs": [
"documentation",
"ci_integration",
"tests_are_truth"
]
}
|
|
train_01047
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
data_pipeline
|
foundation
|
Task: data_pipeline
Topic: Mixture-of-Experts (MoE) for code
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.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
|
{
"target_language": "SQL",
"developer_needs": [
"repo_scale_reasoning",
"governance",
"cost_latency_tradeoffs"
]
}
|
|
train_01048
| 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: 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.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
|
{
"target_language": "SQL",
"developer_needs": [
"repo_scale_reasoning",
"governance",
"reproducibility"
]
}
|
|
train_01049
| 2026-01-01T00:00:00
|
Governance, provenance, and licensing for code data
|
compare
|
intermediate
|
Task: compare
Topic: Governance, provenance, and licensing for code data
Difficulty: intermediate
Target language: TypeScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": "TypeScript",
"developer_needs": [
"cost_latency_tradeoffs",
"reproducibility",
"evaluation_metrics"
]
}
|
|
train_01050
| 2026-01-01T00:00:00
|
Code-specialized model families and sizing tradeoffs
|
compare
|
foundation
|
Task: compare
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: foundation
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.
Compare: capability, cost, latency, reliability, governance
|
{
"target_language": "JavaScript",
"developer_needs": [
"governance",
"tooling",
"cost_latency_tradeoffs"
]
}
|
|
train_01051
| 2026-01-01T00:00:00
|
SWE-bench style real-repo evaluation
|
compare
|
foundation
|
Task: compare
Topic: SWE-bench style real-repo evaluation
Difficulty: foundation
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.
Compare: capability, cost, latency, reliability, governance
|
{
"target_language": "Rust",
"developer_needs": [
"security_gates",
"tests_are_truth",
"tooling"
]
}
|
|
train_01052
| 2026-01-01T00:00:00
|
Reasoning-first coding models and tunable deliberation
|
code
|
foundation
|
Task: code
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: foundation
Target language: Python
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": [
"evaluation_metrics",
"security_gates",
"cost_latency_tradeoffs"
]
}
|
|
train_01053
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
compare
|
expert
|
Task: compare
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: JavaScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": [
"evaluation_metrics",
"reproducibility",
"governance"
]
}
|
|
train_01054
| 2026-01-01T00:00:00
|
Code-specialized model families and sizing tradeoffs
|
explain
|
foundation
|
Task: explain
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: foundation
Target language: Go
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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",
"repo_scale_reasoning",
"cost_latency_tradeoffs"
]
}
|
|
train_01055
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
agent_loop
|
expert
|
Task: agent_loop
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.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
|
{
"target_language": "Java",
"developer_needs": [
"evaluation_metrics",
"documentation",
"reproducibility"
]
}
|
|
train_01056
| 2026-01-01T00:00:00
|
SWE-bench style real-repo evaluation
|
agent_loop
|
advanced
|
Task: agent_loop
Topic: SWE-bench style real-repo evaluation
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": [
"governance",
"cost_latency_tradeoffs",
"security_gates"
]
}
|
|
train_01057
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
explain
|
expert
|
Task: explain
Topic: Agentic coding systems (plan→edit→test→reflect)
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": [
"security_gates",
"tests_are_truth",
"reproducibility"
]
}
|
|
train_01058
| 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: 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.
Review: correctness, security, performance, governance
|
{
"target_language": "C#",
"developer_needs": [
"reproducibility",
"evaluation_metrics",
"repo_scale_reasoning"
]
}
|
|
train_01059
| 2026-01-01T00:00:00
|
Multimodal dev workflows (docs, diagrams, traces)
|
explain
|
advanced
|
Task: explain
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: advanced
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "Bash",
"developer_needs": [
"tooling",
"tests_are_truth",
"reproducibility"
]
}
|
|
train_01060
| 2026-01-01T00:00:00
|
Multimodal dev workflows (docs, diagrams, traces)
|
explain
|
foundation
|
Task: explain
Topic: Multimodal dev workflows (docs, diagrams, traces)
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "Java",
"developer_needs": [
"cost_latency_tradeoffs",
"repo_scale_reasoning",
"evaluation_metrics"
]
}
|
|
train_01061
| 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: 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": [
"documentation",
"ci_integration",
"evaluation_metrics"
]
}
|
|
train_01062
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
design
|
intermediate
|
Task: design
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "Bash",
"developer_needs": [
"reproducibility",
"tests_are_truth",
"evaluation_metrics"
]
}
|
|
train_01063
| 2026-01-01T00:00:00
|
Reasoning-first coding models and tunable deliberation
|
agent_loop
|
foundation
|
Task: agent_loop
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: foundation
Target language: Go
Context: Design a data pipeline for continued pretraining with auditability.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": [
"ci_integration",
"cost_latency_tradeoffs",
"reproducibility"
]
}
|
|
train_01064
| 2026-01-01T00:00:00
|
Secure code generation and policy gates
|
data_pipeline
|
expert
|
Task: data_pipeline
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: Python
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": "Python",
"developer_needs": [
"tooling",
"repo_scale_reasoning",
"governance"
]
}
|
|
train_01065
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
explain
|
expert
|
Task: explain
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: expert
Target language: C#
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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",
"reproducibility"
]
}
|
|
train_01066
| 2026-01-01T00:00:00
|
SWE-bench style real-repo evaluation
|
compare
|
foundation
|
Task: compare
Topic: SWE-bench style real-repo evaluation
Difficulty: foundation
Target language: TypeScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": "TypeScript",
"developer_needs": [
"evaluation_metrics",
"repo_scale_reasoning",
"tests_are_truth"
]
}
|
|
train_01067
| 2026-01-01T00:00:00
|
Governance, provenance, and licensing for code data
|
explain
|
intermediate
|
Task: explain
Topic: Governance, provenance, and licensing for code data
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "TypeScript",
"developer_needs": [
"repo_scale_reasoning",
"cost_latency_tradeoffs",
"documentation"
]
}
|
|
train_01068
| 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: 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.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
|
{
"target_language": "Java",
"developer_needs": [
"evaluation_metrics",
"reproducibility",
"governance"
]
}
|
|
train_01069
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
data_pipeline
|
foundation
|
Task: data_pipeline
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
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.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
|
{
"target_language": "JavaScript",
"developer_needs": [
"tooling",
"documentation",
"cost_latency_tradeoffs"
]
}
|
|
train_01070
| 2026-01-01T00:00:00
|
Reasoning-first coding models and tunable deliberation
|
code
|
advanced
|
Task: code
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: SQL
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": [
"security_gates",
"reproducibility",
"tooling"
]
}
|
|
train_01071
| 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: 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.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
|
{
"target_language": "Rust",
"developer_needs": [
"documentation",
"repo_scale_reasoning",
"governance"
]
}
|
|
train_01072
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
agent_loop
|
expert
|
Task: agent_loop
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
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.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
|
{
"target_language": "Java",
"developer_needs": [
"repo_scale_reasoning",
"reproducibility",
"ci_integration"
]
}
|
|
train_01073
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
explain
|
intermediate
|
Task: explain
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: Java
Context: Integrate an LLM agent into CI for a large monorepo.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": [
"documentation",
"reproducibility",
"governance"
]
}
|
|
train_01074
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
agent_loop
|
advanced
|
Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
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.
Agent loop: Plan → Edit (diff) → Test → Reflect → Human gate
|
{
"target_language": "Rust",
"developer_needs": [
"tooling",
"security_gates",
"cost_latency_tradeoffs"
]
}
|
|
train_01075
| 2026-01-01T00:00:00
|
Extended context and repo-scale understanding
|
compare
|
foundation
|
Task: compare
Topic: Extended context and repo-scale understanding
Difficulty: foundation
Target language: TypeScript
Context: Fix a failing issue with tests as the oracle and produce a safe patch.
Deliver production-grade guidance or artifacts.
|
Key facts:
- Modern AI 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": "TypeScript",
"developer_needs": [
"ci_integration",
"governance",
"repo_scale_reasoning"
]
}
|
|
train_01076
| 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: TypeScript
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": "TypeScript",
"developer_needs": [
"tooling",
"governance",
"ci_integration"
]
}
|
|
train_01077
| 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: 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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "C#",
"developer_needs": [
"tooling",
"ci_integration",
"evaluation_metrics"
]
}
|
|
train_01078
| 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": [
"documentation",
"governance",
"tooling"
]
}
|
|
train_01079
| 2026-01-01T00:00:00
|
Reasoning-first coding models and tunable deliberation
|
design
|
intermediate
|
Task: design
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: intermediate
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": [
"ci_integration",
"documentation",
"reproducibility"
]
}
|
|
train_01080
| 2026-01-01T00:00:00
|
Reasoning-first coding models and tunable deliberation
|
code
|
advanced
|
Task: code
Topic: Reasoning-first coding models and tunable deliberation
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "JavaScript",
"developer_needs": [
"security_gates",
"repo_scale_reasoning",
"evaluation_metrics"
]
}
|
|
train_01081
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
data_pipeline
|
intermediate
|
Task: data_pipeline
Topic: Agentic coding systems (plan→edit→test→reflect)
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.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
|
{
"target_language": "SQL",
"developer_needs": [
"ci_integration",
"cost_latency_tradeoffs",
"evaluation_metrics"
]
}
|
|
train_01082
| 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: 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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "Java",
"developer_needs": [
"tooling",
"security_gates",
"ci_integration"
]
}
|
|
train_01083
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
data_pipeline
|
foundation
|
Task: data_pipeline
Topic: Tool calling, sandboxes, and CI integration
Difficulty: foundation
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.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
|
{
"target_language": "TypeScript",
"developer_needs": [
"repo_scale_reasoning",
"evaluation_metrics",
"tests_are_truth"
]
}
|
|
train_01084
| 2026-01-01T00:00:00
|
Multimodal dev workflows (docs, diagrams, traces)
|
eval
|
intermediate
|
Task: eval
Topic: Multimodal dev workflows (docs, diagrams, traces)
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.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
|
{
"target_language": "SQL",
"developer_needs": [
"evaluation_metrics",
"repo_scale_reasoning",
"governance"
]
}
|
|
train_01085
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
code
|
foundation
|
Task: code
Topic: Dataset curation pipelines (filter, dedupe, quality)
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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "SQL",
"developer_needs": [
"documentation",
"governance",
"cost_latency_tradeoffs"
]
}
|
|
train_01086
| 2026-01-01T00:00:00
|
Secure code generation and policy gates
|
review
|
intermediate
|
Task: review
Topic: Secure code generation and policy gates
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.
Review: correctness, security, performance, governance
|
{
"target_language": "SQL",
"developer_needs": [
"evaluation_metrics",
"cost_latency_tradeoffs",
"tests_are_truth"
]
}
|
|
train_01087
| 2026-01-01T00:00:00
|
Multimodal dev workflows (docs, diagrams, traces)
|
design
|
expert
|
Task: design
Topic: Multimodal dev workflows (docs, diagrams, traces)
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": [
"tests_are_truth",
"security_gates",
"repo_scale_reasoning"
]
}
|
|
train_01088
| 2026-01-01T00:00:00
|
Extended context and repo-scale understanding
|
review
|
foundation
|
Task: review
Topic: Extended context and repo-scale understanding
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": [
"evaluation_metrics",
"cost_latency_tradeoffs",
"ci_integration"
]
}
|
|
train_01089
| 2026-01-01T00:00:00
|
Multimodal dev workflows (docs, diagrams, traces)
|
explain
|
foundation
|
Task: explain
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: foundation
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": [
"tests_are_truth",
"repo_scale_reasoning",
"evaluation_metrics"
]
}
|
|
train_01090
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
compare
|
advanced
|
Task: compare
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
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": [
"governance",
"tooling",
"evaluation_metrics"
]
}
|
|
train_01091
| 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: Go
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": "Go",
"developer_needs": [
"governance",
"tooling",
"evaluation_metrics"
]
}
|
|
train_01092
| 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: 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.
Design guidance with risks, metrics, acceptance criteria
|
{
"target_language": "C#",
"developer_needs": [
"ci_integration",
"governance",
"evaluation_metrics"
]
}
|
|
train_01093
| 2026-01-01T00:00:00
|
Multimodal dev workflows (docs, diagrams, traces)
|
review
|
intermediate
|
Task: review
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: intermediate
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": [
"repo_scale_reasoning",
"reproducibility",
"cost_latency_tradeoffs"
]
}
|
|
train_01094
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
eval
|
advanced
|
Task: eval
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: TypeScript
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": "TypeScript",
"developer_needs": [
"governance",
"security_gates",
"evaluation_metrics"
]
}
|
|
train_01095
| 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: 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",
"ci_integration",
"tests_are_truth"
]
}
|
|
train_01096
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
eval
|
intermediate
|
Task: eval
Topic: Model merging, distillation, and continued pretraining
Difficulty: intermediate
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.
Eval:
- Tasks: real issues
- Metrics: pass@k, time-to-green
- Gates: lint/security
|
{
"target_language": "C#",
"developer_needs": [
"tooling",
"security_gates",
"tests_are_truth"
]
}
|
|
train_01097
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
data_pipeline
|
foundation
|
Task: data_pipeline
Topic: Agentic coding systems (plan→edit→test→reflect)
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.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
|
{
"target_language": "Go",
"developer_needs": [
"repo_scale_reasoning",
"tests_are_truth",
"cost_latency_tradeoffs"
]
}
|
|
train_01098
| 2026-01-01T00:00:00
|
Secure code generation and policy gates
|
review
|
expert
|
Task: review
Topic: Secure code generation and policy gates
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.
Review: correctness, security, performance, governance
|
{
"target_language": "Bash",
"developer_needs": [
"ci_integration",
"documentation",
"tests_are_truth"
]
}
|
|
train_01099
| 2026-01-01T00:00:00
|
Secure code generation and policy gates
|
data_pipeline
|
intermediate
|
Task: data_pipeline
Topic: Secure code generation and policy gates
Difficulty: intermediate
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.
Pipeline:
1) Ingest
2) Normalize
3) Filter
4) Dedupe
5) Quality score
6) Sample
7) Audit
|
{
"target_language": "Go",
"developer_needs": [
"evaluation_metrics",
"documentation",
"reproducibility"
]
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.