id
stringlengths 11
11
| created
timestamp[s]date 2026-01-01 00:00:00
2026-01-01 00:00:00
| topic
stringclasses 14
values | task_type
stringclasses 10
values | difficulty
stringclasses 3
values | instruction
stringlengths 189
248
| input
stringclasses 1
value | output
stringclasses 9
values | reasoning_steps
listlengths 0
5
| metadata
dict | hash
stringlengths 40
40
|
|---|---|---|---|---|---|---|---|---|---|---|
train_45100
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
data_pipeline
|
expert
|
Task: data_pipeline
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: Java
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit
|
[] |
{
"target_language": "Java",
"developer_needs": [
"repo_scale_reasoning",
"cost_latency_tradeoffs",
"tooling",
"security_gates"
],
"moe_experts": [
"coding_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
8d2e549a485d5f636f61d40754772384eed9b0cd
|
|
train_45101
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
failure_analysis
|
intermediate
|
Task: failure_analysis
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: Go
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Go",
"developer_needs": [
"auditability",
"tests_are_truth",
"governance",
"tooling"
],
"moe_experts": [
"agentic_systems_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
fb91e9cc17b75d690bdc40473808ef118719e355
|
|
train_45102
| 2026-01-01T00:00:00
|
Self-improving agents and feedback loops
|
explain
|
expert
|
Task: explain
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: Go
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "Go",
"developer_needs": [
"reproducibility",
"governance",
"evaluation_metrics",
"tests_are_truth"
],
"moe_experts": [
"agentic_systems_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
e5e845325cdb4f1650c50e213790630a2b8ca6c5
|
|
train_45103
| 2026-01-01T00:00:00
|
Latency, cost, and reliability optimization
|
review
|
intermediate
|
Task: review
Topic: Latency, cost, and reliability optimization
Difficulty: intermediate
Target language: Go
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Review: correctness, security, performance, governance
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Go",
"developer_needs": [
"cost_latency_tradeoffs",
"security_gates",
"auditability",
"tooling"
],
"moe_experts": [
"performance_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
0c5754dde2990d0731ebca4402236b444ca0aaa7
|
|
train_45104
| 2026-01-01T00:00:00
|
SWE-bench style real-repo evaluation
|
review
|
intermediate
|
Task: review
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: JavaScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Review: correctness, security, performance, governance
|
[] |
{
"target_language": "JavaScript",
"developer_needs": [
"repo_scale_reasoning",
"ci_integration",
"evaluation_metrics",
"cost_latency_tradeoffs"
],
"moe_experts": [
"governance_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
16e1d0d5f08957d093d29e6d03fd13659dce77ec
|
|
train_45105
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
patch_diff
|
advanced
|
Task: patch_diff
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: SQL
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "SQL",
"developer_needs": [
"cost_latency_tradeoffs",
"ci_integration",
"evaluation_metrics",
"repo_scale_reasoning"
],
"moe_experts": [
"data_curation_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
777cec47d8aecdba531b235e17b25f0580d792cd
|
|
train_45106
| 2026-01-01T00:00:00
|
Extended context and repo-scale understanding
|
design
|
advanced
|
Task: design
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: Rust
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "Rust",
"developer_needs": [
"evaluation_metrics",
"governance",
"tooling",
"repo_scale_reasoning"
],
"moe_experts": [
"governance_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
54a687b98b2e83e457d5abe9b4bc7dce5d4203d6
|
|
train_45107
| 2026-01-01T00:00:00
|
Extended context and repo-scale understanding
|
compare
|
advanced
|
Task: compare
Topic: Extended context and repo-scale understanding
Difficulty: advanced
Target language: SQL
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "SQL",
"developer_needs": [
"repo_scale_reasoning",
"tooling",
"security_gates",
"tests_are_truth"
],
"moe_experts": [
"governance_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
3ee3306d68d1b46a20b62d9b9b791b6a25c1f832
|
|
train_45108
| 2026-01-01T00:00:00
|
Self-improving agents and feedback loops
|
review
|
expert
|
Task: review
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: C#
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Review: correctness, security, performance, governance
|
[] |
{
"target_language": "C#",
"developer_needs": [
"ci_integration",
"tooling",
"auditability",
"reproducibility"
],
"moe_experts": [
"evaluation_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
9687604bafe64fa885857b0e8253766b43d76b42
|
|
train_45109
| 2026-01-01T00:00:00
|
Self-improving agents and feedback loops
|
compare
|
advanced
|
Task: compare
Topic: Self-improving agents and feedback loops
Difficulty: advanced
Target language: Java
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[] |
{
"target_language": "Java",
"developer_needs": [
"evaluation_metrics",
"tests_are_truth",
"tooling",
"reproducibility"
],
"moe_experts": [
"evaluation_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
25ef4592b9588f687e3530fcbecaf0857f7988fe
|
|
train_45110
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
eval
|
advanced
|
Task: eval
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: JavaScript
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[] |
{
"target_language": "JavaScript",
"developer_needs": [
"evaluation_metrics",
"cost_latency_tradeoffs",
"auditability",
"documentation"
],
"moe_experts": [
"evaluation_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
5d60681b51348ef287729949218cdd60125f6c17
|
|
train_45111
| 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: Python
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Loop: Plan → Edit → Test → Reflect → Human gate
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Python",
"developer_needs": [
"tooling",
"auditability",
"documentation",
"tests_are_truth"
],
"moe_experts": [
"agentic_systems_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
44d0468929bd3e7e3297b9942b6c0766d4384536
|
|
train_45112
| 2026-01-01T00:00:00
|
Extended context and repo-scale understanding
|
failure_analysis
|
intermediate
|
Task: failure_analysis
Topic: Extended context and repo-scale understanding
Difficulty: intermediate
Target language: Java
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Java",
"developer_needs": [
"repo_scale_reasoning",
"cost_latency_tradeoffs",
"ci_integration",
"governance"
],
"moe_experts": [
"governance_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
364f482807fc8a1b571ddc3e6a28ead00d4fd013
|
|
train_45113
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
design
|
advanced
|
Task: design
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: SQL
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "SQL",
"developer_needs": [
"auditability",
"tests_are_truth",
"documentation",
"tooling"
],
"moe_experts": [
"security_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
ce580ea147a4bbc5231d21b24e4b7495dc059b6c
|
|
train_45114
| 2026-01-01T00:00:00
|
Reasoning-first coding models and tunable deliberation
|
compare
|
advanced
|
Task: compare
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "TypeScript",
"developer_needs": [
"tooling",
"auditability",
"security_gates",
"cost_latency_tradeoffs"
],
"moe_experts": [
"agentic_systems_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
ad423ad68f8aeb9024f9b29cca764fc6689d7e25
|
|
train_45115
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
compare
|
intermediate
|
Task: compare
Topic: Model merging, distillation, and continued pretraining
Difficulty: intermediate
Target language: SQL
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"evaluation_metrics",
"reproducibility",
"security_gates",
"ci_integration"
],
"moe_experts": [
"governance_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
91b1c2ab8b8b744f326a8dbe4c35db3214f8b2d1
|
|
train_45116
| 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: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Scaffold:
```python
def agent_loop(plan, edit, test, issue, max_iters=4):
history = []
p = plan(issue)
for _ in range(max_iters):
patch = edit(issue, p)
ok, report = test(patch)
history.append({"plan": p, "ok": ok})
if ok:
return patch, history
p = p + " | refine"
return patch, history
```
|
[] |
{
"target_language": "Python",
"developer_needs": [
"governance",
"tooling",
"ci_integration",
"cost_latency_tradeoffs"
],
"moe_experts": [
"security_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
8e26c884f4b4436c7bc38d2422fbe2c2ebda9641
|
|
train_45117
| 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: SQL
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Loop: Plan → Edit → Test → Reflect → Human gate
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"cost_latency_tradeoffs",
"documentation",
"ci_integration",
"governance"
],
"moe_experts": [
"evaluation_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
048bf7a2f0903bb7d5f12be4d5196df390a06d0d
|
|
train_45118
| 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: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Review: correctness, security, performance, governance
|
[] |
{
"target_language": "C#",
"developer_needs": [
"ci_integration",
"reproducibility",
"evaluation_metrics",
"documentation"
],
"moe_experts": [
"coding_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
06b8fec492a497a4309fb9d02a8a4d9e193e65e6
|
|
train_45119
| 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: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit
|
[] |
{
"target_language": "TypeScript",
"developer_needs": [
"repo_scale_reasoning",
"governance",
"cost_latency_tradeoffs",
"security_gates"
],
"moe_experts": [
"data_curation_expert",
"agentic_systems_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
9f9e6c557ffd1b7fe4db5deb19f7ddfc6c882705
|
|
train_45120
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
patch_diff
|
intermediate
|
Task: patch_diff
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: Rust
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[] |
{
"target_language": "Rust",
"developer_needs": [
"evaluation_metrics",
"documentation",
"tooling",
"cost_latency_tradeoffs"
],
"moe_experts": [
"agentic_systems_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
133ee636bb85b1697cca80272c3a367a66fb0d3e
|
|
train_45121
| 2026-01-01T00:00:00
|
Governance, provenance, and licensing for code data
|
compare
|
expert
|
Task: compare
Topic: Governance, provenance, and licensing for code data
Difficulty: expert
Target language: Go
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[] |
{
"target_language": "Go",
"developer_needs": [
"ci_integration",
"documentation",
"governance",
"cost_latency_tradeoffs"
],
"moe_experts": [
"data_curation_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
0e58caa79877ab53fb26d471acfa3750c4d9360e
|
|
train_45122
| 2026-01-01T00:00:00
|
Self-improving agents and feedback loops
|
patch_diff
|
advanced
|
Task: patch_diff
Topic: Self-improving agents and feedback loops
Difficulty: advanced
Target language: Java
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[] |
{
"target_language": "Java",
"developer_needs": [
"auditability",
"ci_integration",
"evaluation_metrics",
"tooling"
],
"moe_experts": [
"evaluation_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
c1f8f29917d2613975822d8a36c7aedf98de494c
|
|
train_45123
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
patch_diff
|
expert
|
Task: patch_diff
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: TypeScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "TypeScript",
"developer_needs": [
"tooling",
"documentation",
"repo_scale_reasoning",
"auditability"
],
"moe_experts": [
"evaluation_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
1f15ab0e8f4db859209278ac672d2fafa985afde
|
|
train_45124
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
agent_loop
|
advanced
|
Task: agent_loop
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: Python
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Loop: Plan → Edit → Test → Reflect → Human gate
|
[] |
{
"target_language": "Python",
"developer_needs": [
"cost_latency_tradeoffs",
"security_gates",
"tests_are_truth",
"repo_scale_reasoning"
],
"moe_experts": [
"performance_expert",
"coding_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
f04e0f6205d42a2dac1103baf7451939fbd45877
|
|
train_45125
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
compare
|
intermediate
|
Task: compare
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: TypeScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[] |
{
"target_language": "TypeScript",
"developer_needs": [
"cost_latency_tradeoffs",
"evaluation_metrics",
"ci_integration",
"auditability"
],
"moe_experts": [
"data_curation_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
cf0991058eef10b482cae76b7ebca2bddeb7d69c
|
|
train_45126
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
compare
|
intermediate
|
Task: compare
Topic: Model merging, distillation, and continued pretraining
Difficulty: intermediate
Target language: Go
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Go",
"developer_needs": [
"auditability",
"documentation",
"governance",
"cost_latency_tradeoffs"
],
"moe_experts": [
"evaluation_expert",
"agentic_systems_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
fe40b4e5f2e268ace1aa388f0ec6bf331fdc6c25
|
|
train_45127
| 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: Java
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "Java",
"developer_needs": [
"governance",
"tooling",
"documentation",
"tests_are_truth"
],
"moe_experts": [
"governance_expert",
"coding_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
5abaa141de42746539be727019d41ec493bf591f
|
|
train_45128
| 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: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Review: correctness, security, performance, governance
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "TypeScript",
"developer_needs": [
"tooling",
"ci_integration",
"governance",
"auditability"
],
"moe_experts": [
"governance_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
600fd9e7554332a79b655f71c51f232bdb39d8ec
|
|
train_45129
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
review
|
advanced
|
Task: review
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: Go
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Review: correctness, security, performance, governance
|
[] |
{
"target_language": "Go",
"developer_needs": [
"tests_are_truth",
"auditability",
"ci_integration",
"reproducibility"
],
"moe_experts": [
"security_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
aa7f4e6cef1e5bdcffb87e7f42760b06d17cf5fa
|
|
train_45130
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
patch_diff
|
intermediate
|
Task: patch_diff
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Bash
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Bash",
"developer_needs": [
"cost_latency_tradeoffs",
"tooling",
"governance",
"reproducibility"
],
"moe_experts": [
"data_curation_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
afb3e4987f840517385ea0a1ced148400128c0fb
|
|
train_45131
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
data_pipeline
|
advanced
|
Task: data_pipeline
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: Rust
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit
|
[] |
{
"target_language": "Rust",
"developer_needs": [
"auditability",
"cost_latency_tradeoffs",
"reproducibility",
"ci_integration"
],
"moe_experts": [
"coding_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
ad49338b7f8ef8f42b778c64f44f3cf9ae62296d
|
|
train_45132
| 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: SQL
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"cost_latency_tradeoffs",
"evaluation_metrics",
"repo_scale_reasoning",
"security_gates"
],
"moe_experts": [
"agentic_systems_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
077762be642420f7683c458f68bc884d3ce084e1
|
|
train_45133
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
explain
|
intermediate
|
Task: explain
Topic: Model merging, distillation, and continued pretraining
Difficulty: intermediate
Target language: Python
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Python",
"developer_needs": [
"repo_scale_reasoning",
"ci_integration",
"auditability",
"documentation"
],
"moe_experts": [
"agentic_systems_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
b658a01f35ab93c6756adda5bcfb5ae2bbf1f34f
|
|
train_45134
| 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: Java
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Review: correctness, security, performance, governance
|
[] |
{
"target_language": "Java",
"developer_needs": [
"documentation",
"cost_latency_tradeoffs",
"repo_scale_reasoning",
"auditability"
],
"moe_experts": [
"agentic_systems_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
61ac2ad231f148ac878d9ecf6811907d19410e55
|
|
train_45135
| 2026-01-01T00:00:00
|
Code-specialized model families and sizing tradeoffs
|
failure_analysis
|
intermediate
|
Task: failure_analysis
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: TypeScript
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "TypeScript",
"developer_needs": [
"auditability",
"documentation",
"reproducibility",
"repo_scale_reasoning"
],
"moe_experts": [
"data_curation_expert",
"agentic_systems_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
c5df16c0c3f743e8c80aa96865abfa119772d872
|
|
train_45136
| 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: Bash
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Bash",
"developer_needs": [
"repo_scale_reasoning",
"evaluation_metrics",
"ci_integration",
"documentation"
],
"moe_experts": [
"data_curation_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
e5914219d38a77dc96c9cb0b98c9df8a30829fae
|
|
train_45137
| 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: Java
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "Java",
"developer_needs": [
"auditability",
"tooling",
"evaluation_metrics",
"security_gates"
],
"moe_experts": [
"data_curation_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
923a4ef20390bdc995ec4af5005dcf6353864419
|
|
train_45138
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
code
|
advanced
|
Task: code
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: C#
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "C#",
"developer_needs": [
"evaluation_metrics",
"governance",
"documentation",
"security_gates"
],
"moe_experts": [
"evaluation_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
884de04cbe6cd9adff950e0cd38afcd5cfa24157
|
|
train_45139
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
code
|
intermediate
|
Task: code
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: intermediate
Target language: TypeScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "TypeScript",
"developer_needs": [
"reproducibility",
"tests_are_truth",
"repo_scale_reasoning",
"security_gates"
],
"moe_experts": [
"data_curation_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
229ce157193cfd82efe56f041f4f43959db010d0
|
|
train_45140
| 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: Rust
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Rust",
"developer_needs": [
"repo_scale_reasoning",
"tests_are_truth",
"reproducibility",
"security_gates"
],
"moe_experts": [
"agentic_systems_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
bfd6ca8197c22169db04d67af567abe7d2169f40
|
|
train_45141
| 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: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "JavaScript",
"developer_needs": [
"security_gates",
"ci_integration",
"repo_scale_reasoning",
"cost_latency_tradeoffs"
],
"moe_experts": [
"performance_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
42b0f395687d54b1d49afcffa8f6e3583c61bac5
|
|
train_45142
| 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: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "C#",
"developer_needs": [
"evaluation_metrics",
"tooling",
"governance",
"documentation"
],
"moe_experts": [
"performance_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
817bb89b0f21db34a0ce45aa84ef59b48b2f6c21
|
|
train_45143
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
patch_diff
|
intermediate
|
Task: patch_diff
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: SQL
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"reproducibility",
"cost_latency_tradeoffs",
"evaluation_metrics",
"auditability"
],
"moe_experts": [
"security_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
118ff4cadc75e1aa501b5f52dec203cdcf512f08
|
|
train_45144
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
patch_diff
|
expert
|
Task: patch_diff
Topic: Tool calling, sandboxes, and CI integration
Difficulty: expert
Target language: JavaScript
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "JavaScript",
"developer_needs": [
"tests_are_truth",
"documentation",
"governance",
"repo_scale_reasoning"
],
"moe_experts": [
"agentic_systems_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
4f5a7b4a4ad69f80b7e8b2e0c61d50dce2ca06fa
|
|
train_45145
| 2026-01-01T00:00:00
|
Extended context and repo-scale understanding
|
code
|
expert
|
Task: code
Topic: Extended context and repo-scale understanding
Difficulty: expert
Target language: Go
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "Go",
"developer_needs": [
"tests_are_truth",
"repo_scale_reasoning",
"documentation",
"evaluation_metrics"
],
"moe_experts": [
"performance_expert",
"coding_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
7069487b6ae48630f03f919a0b1ac1905a21d12c
|
|
train_45146
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
patch_diff
|
expert
|
Task: patch_diff
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: Python
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[] |
{
"target_language": "Python",
"developer_needs": [
"tooling",
"governance",
"documentation",
"cost_latency_tradeoffs"
],
"moe_experts": [
"coding_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
29aa54dfafe4d0da87f525119d3fa0954f8ea5b6
|
|
train_45147
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
explain
|
advanced
|
Task: explain
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: SQL
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "SQL",
"developer_needs": [
"evaluation_metrics",
"cost_latency_tradeoffs",
"governance",
"repo_scale_reasoning"
],
"moe_experts": [
"governance_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
2387b0448cc236189b71a208bd426721788553da
|
|
train_45148
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
data_pipeline
|
expert
|
Task: data_pipeline
Topic: Model merging, distillation, and continued pretraining
Difficulty: expert
Target language: Python
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Python",
"developer_needs": [
"security_gates",
"tooling",
"cost_latency_tradeoffs",
"governance"
],
"moe_experts": [
"evaluation_expert",
"coding_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
604cefb05179ffb3f4d8e7cabfcd9cbf324ff6d8
|
|
train_45149
| 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: C#
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "C#",
"developer_needs": [
"auditability",
"repo_scale_reasoning",
"security_gates",
"documentation"
],
"moe_experts": [
"data_curation_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
af7ef924754d390d7d81e6b2deb280e224347b3c
|
|
train_45150
| 2026-01-01T00:00:00
|
Secure code generation and policy gates
|
design
|
expert
|
Task: design
Topic: Secure code generation and policy gates
Difficulty: expert
Target language: Go
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "Go",
"developer_needs": [
"security_gates",
"cost_latency_tradeoffs",
"auditability",
"tooling"
],
"moe_experts": [
"coding_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
9e2c3b5240c0ec9727b42508ab715f23f23a136c
|
|
train_45151
| 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: JavaScript
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Loop: Plan → Edit → Test → Reflect → Human gate
|
[] |
{
"target_language": "JavaScript",
"developer_needs": [
"auditability",
"security_gates",
"ci_integration",
"cost_latency_tradeoffs"
],
"moe_experts": [
"security_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
98fc2fef1e6075c48b7e6a0708797dbbc668ab0c
|
|
train_45152
| 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: C#
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "C#",
"developer_needs": [
"auditability",
"documentation",
"governance",
"evaluation_metrics"
],
"moe_experts": [
"evaluation_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
a00ca5237cf949fba83bbd9e3dac627d204656d5
|
|
train_45153
| 2026-01-01T00:00:00
|
Secure code generation and policy gates
|
design
|
advanced
|
Task: design
Topic: Secure code generation and policy gates
Difficulty: advanced
Target language: Python
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "Python",
"developer_needs": [
"ci_integration",
"tests_are_truth",
"governance",
"evaluation_metrics"
],
"moe_experts": [
"governance_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
0979455f08781096c180d5cb055105c9922aecfb
|
|
train_45154
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
explain
|
advanced
|
Task: explain
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: TypeScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "TypeScript",
"developer_needs": [
"auditability",
"tooling",
"cost_latency_tradeoffs",
"ci_integration"
],
"moe_experts": [
"data_curation_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
b360361ef83ab5ddefdbefa10b8e83892d0f42a5
|
|
train_45155
| 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: Java
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Java",
"developer_needs": [
"auditability",
"security_gates",
"reproducibility",
"tooling"
],
"moe_experts": [
"performance_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
ad22dbbd04fdbfdeb6ac521cb9c3a35075c81a7d
|
|
train_45156
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
patch_diff
|
advanced
|
Task: patch_diff
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: Python
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[] |
{
"target_language": "Python",
"developer_needs": [
"auditability",
"evaluation_metrics",
"cost_latency_tradeoffs",
"reproducibility"
],
"moe_experts": [
"governance_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
5ea155024e26b1c85c7b4e35bd7459575c2735b7
|
|
train_45157
| 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: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Java",
"developer_needs": [
"governance",
"tests_are_truth",
"cost_latency_tradeoffs",
"tooling"
],
"moe_experts": [
"evaluation_expert",
"coding_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
36fec1eb406b8fb922e3203be013609880edb6bb
|
|
train_45158
| 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: SQL
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"repo_scale_reasoning",
"tooling",
"cost_latency_tradeoffs",
"evaluation_metrics"
],
"moe_experts": [
"coding_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
bb411324b0d265e5780e540c79c8ff41f0cc6ec9
|
|
train_45159
| 2026-01-01T00:00:00
|
Self-improving agents and feedback loops
|
explain
|
intermediate
|
Task: explain
Topic: Self-improving agents and feedback loops
Difficulty: intermediate
Target language: Bash
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Bash",
"developer_needs": [
"documentation",
"tooling",
"cost_latency_tradeoffs",
"security_gates"
],
"moe_experts": [
"performance_expert",
"agentic_systems_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
5bbeead378deeb68bc7282336fff0d0b011907fe
|
|
train_45160
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
compare
|
expert
|
Task: compare
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: SQL
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"cost_latency_tradeoffs",
"reproducibility",
"documentation",
"tests_are_truth"
],
"moe_experts": [
"governance_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
99966bb51a7fc52504750ab8580b9d41981d5d65
|
|
train_45161
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
data_pipeline
|
advanced
|
Task: data_pipeline
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: Python
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit
|
[] |
{
"target_language": "Python",
"developer_needs": [
"documentation",
"tests_are_truth",
"security_gates",
"auditability"
],
"moe_experts": [
"security_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
ccf6723a5a2f5edc030547dd09d8aa732928623a
|
|
train_45162
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
eval
|
intermediate
|
Task: eval
Topic: Tool calling, sandboxes, and CI integration
Difficulty: intermediate
Target language: JavaScript
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[] |
{
"target_language": "JavaScript",
"developer_needs": [
"documentation",
"repo_scale_reasoning",
"cost_latency_tradeoffs",
"security_gates"
],
"moe_experts": [
"coding_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
69ec6251d327eac16e427befb43542a50d30ef4e
|
|
train_45163
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
design
|
advanced
|
Task: design
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: Java
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "Java",
"developer_needs": [
"repo_scale_reasoning",
"auditability",
"ci_integration",
"tooling"
],
"moe_experts": [
"coding_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
633c8fed64b1d09e5703d5bd7c27d7860d037c65
|
|
train_45164
| 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: Java
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Java",
"developer_needs": [
"tooling",
"documentation",
"cost_latency_tradeoffs",
"auditability"
],
"moe_experts": [
"governance_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
306afdd6977e3724e79e72d13f7527cd8ca19f8c
|
|
train_45165
| 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: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Review: correctness, security, performance, governance
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Python",
"developer_needs": [
"security_gates",
"documentation",
"repo_scale_reasoning",
"tests_are_truth"
],
"moe_experts": [
"evaluation_expert",
"agentic_systems_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
0708930087b4e77ae2439ad3cc469b4a227b8e09
|
|
train_45166
| 2026-01-01T00:00:00
|
Governance, provenance, and licensing for code data
|
code
|
advanced
|
Task: code
Topic: Governance, provenance, and licensing for code data
Difficulty: advanced
Target language: Bash
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Bash",
"developer_needs": [
"tooling",
"tests_are_truth",
"reproducibility",
"cost_latency_tradeoffs"
],
"moe_experts": [
"coding_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
0aa2072913acb43b1f1888ee5eecefb54851414f
|
|
train_45167
| 2026-01-01T00:00:00
|
Self-improving agents and feedback loops
|
failure_analysis
|
expert
|
Task: failure_analysis
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: TypeScript
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test
|
[] |
{
"target_language": "TypeScript",
"developer_needs": [
"documentation",
"cost_latency_tradeoffs",
"reproducibility",
"evaluation_metrics"
],
"moe_experts": [
"evaluation_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
d1371523d0e3607b7a873aa3b3ca60c3187ea7e2
|
|
train_45168
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
eval
|
advanced
|
Task: eval
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: Python
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[] |
{
"target_language": "Python",
"developer_needs": [
"ci_integration",
"governance",
"cost_latency_tradeoffs",
"security_gates"
],
"moe_experts": [
"security_expert",
"agentic_systems_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
9fd5e5dddde41bcd8beba7fc4ca0796cab926ee5
|
|
train_45169
| 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: SQL
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Loop: Plan → Edit → Test → Reflect → Human gate
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"tooling",
"tests_are_truth",
"ci_integration",
"reproducibility"
],
"moe_experts": [
"coding_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
a3897b8f1b65858468953b8b7715ffc77b9b348d
|
|
train_45170
| 2026-01-01T00:00:00
|
Self-improving agents and feedback loops
|
review
|
advanced
|
Task: review
Topic: Self-improving agents and feedback loops
Difficulty: advanced
Target language: Java
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Review: correctness, security, performance, governance
|
[] |
{
"target_language": "Java",
"developer_needs": [
"governance",
"evaluation_metrics",
"ci_integration",
"auditability"
],
"moe_experts": [
"data_curation_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
a9184371a7bd185286025c0c8fe1ed4f4ed9beba
|
|
train_45171
| 2026-01-01T00:00:00
|
Code-specialized model families and sizing tradeoffs
|
explain
|
advanced
|
Task: explain
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: advanced
Target language: Bash
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "Bash",
"developer_needs": [
"reproducibility",
"repo_scale_reasoning",
"ci_integration",
"evaluation_metrics"
],
"moe_experts": [
"security_expert",
"coding_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
499a9c207db59c5d920a6954b543967e3d6531f3
|
|
train_45172
| 2026-01-01T00:00:00
|
Multimodal dev workflows (docs, diagrams, traces)
|
data_pipeline
|
expert
|
Task: data_pipeline
Topic: Multimodal dev workflows (docs, diagrams, traces)
Difficulty: expert
Target language: Python
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit
|
[] |
{
"target_language": "Python",
"developer_needs": [
"security_gates",
"ci_integration",
"tooling",
"tests_are_truth"
],
"moe_experts": [
"evaluation_expert",
"agentic_systems_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
eef4c94d3ee8561c6c19543f7d43a960434323f6
|
|
train_45173
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
eval
|
expert
|
Task: eval
Topic: Mixture-of-Experts (MoE) for code
Difficulty: expert
Target language: C#
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "C#",
"developer_needs": [
"auditability",
"documentation",
"security_gates",
"evaluation_metrics"
],
"moe_experts": [
"governance_expert",
"coding_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
001c35cf9757b9f6025b0d40d28ddeed1f04335e
|
|
train_45174
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
compare
|
advanced
|
Task: compare
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: advanced
Target language: Python
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[] |
{
"target_language": "Python",
"developer_needs": [
"auditability",
"tests_are_truth",
"cost_latency_tradeoffs",
"repo_scale_reasoning"
],
"moe_experts": [
"data_curation_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
adf6018b2a441bf89eeb45cc0090ee8c04f01316
|
|
train_45175
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
patch_diff
|
intermediate
|
Task: patch_diff
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: intermediate
Target language: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"reproducibility",
"repo_scale_reasoning",
"security_gates",
"ci_integration"
],
"moe_experts": [
"evaluation_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
f84e0ddb44224321361cf802fc7f25980d1e3363
|
|
train_45176
| 2026-01-01T00:00:00
|
Self-improving agents and feedback loops
|
agent_loop
|
expert
|
Task: agent_loop
Topic: Self-improving agents and feedback loops
Difficulty: expert
Target language: Python
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Loop: Plan → Edit → Test → Reflect → Human gate
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Python",
"developer_needs": [
"evaluation_metrics",
"documentation",
"repo_scale_reasoning",
"security_gates"
],
"moe_experts": [
"governance_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
1d2b8f0b43b7ce62ca4874c331492866b8637ed2
|
|
train_45177
| 2026-01-01T00:00:00
|
Code-specialized model families and sizing tradeoffs
|
failure_analysis
|
intermediate
|
Task: failure_analysis
Topic: Code-specialized model families and sizing tradeoffs
Difficulty: intermediate
Target language: Java
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Java",
"developer_needs": [
"tooling",
"documentation",
"governance",
"repo_scale_reasoning"
],
"moe_experts": [
"governance_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
e515026b7a82f2791988064ceeea5a79b6471054
|
|
train_45178
| 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: Go
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[] |
{
"target_language": "Go",
"developer_needs": [
"ci_integration",
"tests_are_truth",
"cost_latency_tradeoffs",
"governance"
],
"moe_experts": [
"agentic_systems_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
4e8c485f1168a3fb24b0696c7087d6ec75e9daaa
|
|
train_45179
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
data_pipeline
|
advanced
|
Task: data_pipeline
Topic: Mixture-of-Experts (MoE) for code
Difficulty: advanced
Target language: SQL
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"governance",
"ci_integration",
"repo_scale_reasoning",
"auditability"
],
"moe_experts": [
"security_expert",
"coding_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
4997f749ddd3e1df6842f9bd5bd62c8860613d19
|
|
train_45180
| 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: SQL
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"evaluation_metrics",
"tooling",
"security_gates",
"tests_are_truth"
],
"moe_experts": [
"coding_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
ed102da6b980a704e63a78db8bdc7ef66e3addce
|
|
train_45181
| 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: Python
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[] |
{
"target_language": "Python",
"developer_needs": [
"auditability",
"security_gates",
"tooling",
"reproducibility"
],
"moe_experts": [
"security_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
927c897e967378eb884fa3176182387a0db84d57
|
|
train_45182
| 2026-01-01T00:00:00
|
Tool calling, sandboxes, and CI integration
|
code
|
advanced
|
Task: code
Topic: Tool calling, sandboxes, and CI integration
Difficulty: advanced
Target language: C#
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "C#",
"developer_needs": [
"security_gates",
"reproducibility",
"evaluation_metrics",
"tests_are_truth"
],
"moe_experts": [
"governance_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
992a1ce2e0795477ec633c5b67fedb2b4c3767a1
|
|
train_45183
| 2026-01-01T00:00:00
|
Mixture-of-Experts (MoE) for code
|
eval
|
intermediate
|
Task: eval
Topic: Mixture-of-Experts (MoE) for code
Difficulty: intermediate
Target language: Rust
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Rust",
"developer_needs": [
"tooling",
"cost_latency_tradeoffs",
"repo_scale_reasoning",
"auditability"
],
"moe_experts": [
"evaluation_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
a1b5a608575a826aca1e683e534d10042c279d96
|
|
train_45184
| 2026-01-01T00:00:00
|
Latency, cost, and reliability optimization
|
eval
|
intermediate
|
Task: eval
Topic: Latency, cost, and reliability optimization
Difficulty: intermediate
Target language: Rust
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Rust",
"developer_needs": [
"repo_scale_reasoning",
"documentation",
"cost_latency_tradeoffs",
"reproducibility"
],
"moe_experts": [
"evaluation_expert",
"coding_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
1d0ee659d3afdacd8926114c3c56ef0c800e17e1
|
|
train_45185
| 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: Python
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Review: correctness, security, performance, governance
|
[] |
{
"target_language": "Python",
"developer_needs": [
"documentation",
"tests_are_truth",
"evaluation_metrics",
"ci_integration"
],
"moe_experts": [
"security_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
ec2b4a301d8585a9e37ad083f84e2260e43c6933
|
|
train_45186
| 2026-01-01T00:00:00
|
Agentic coding systems (plan→edit→test→reflect)
|
patch_diff
|
advanced
|
Task: patch_diff
Topic: Agentic coding systems (plan→edit→test→reflect)
Difficulty: advanced
Target language: Rust
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[] |
{
"target_language": "Rust",
"developer_needs": [
"cost_latency_tradeoffs",
"tooling",
"security_gates",
"auditability"
],
"moe_experts": [
"security_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
ef2327849b30a0c40e50fb2900cc7555338f69bf
|
|
train_45187
| 2026-01-01T00:00:00
|
Secure code generation and policy gates
|
compare
|
intermediate
|
Task: compare
Topic: Secure code generation and policy gates
Difficulty: intermediate
Target language: Bash
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Compare: capability, cost, latency, reliability
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Bash",
"developer_needs": [
"repo_scale_reasoning",
"tooling",
"ci_integration",
"tests_are_truth"
],
"moe_experts": [
"governance_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
d5002a77096709517dd028501473baa241239038
|
|
train_45188
| 2026-01-01T00:00:00
|
Dataset curation pipelines (filter, dedupe, quality)
|
agent_loop
|
expert
|
Task: agent_loop
Topic: Dataset curation pipelines (filter, dedupe, quality)
Difficulty: expert
Target language: C#
Context: Regulated environment requiring audit trails.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Loop: Plan → Edit → Test → Reflect → Human gate
|
[] |
{
"target_language": "C#",
"developer_needs": [
"tests_are_truth",
"governance",
"ci_integration",
"evaluation_metrics"
],
"moe_experts": [
"coding_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
c3ae75400d50d4860bdf69769bbb28550c4b774d
|
|
train_45189
| 2026-01-01T00:00:00
|
Self-improving agents and feedback loops
|
failure_analysis
|
intermediate
|
Task: failure_analysis
Topic: Self-improving agents and feedback loops
Difficulty: intermediate
Target language: Rust
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test
|
[] |
{
"target_language": "Rust",
"developer_needs": [
"security_gates",
"repo_scale_reasoning",
"evaluation_metrics",
"cost_latency_tradeoffs"
],
"moe_experts": [
"data_curation_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
a8f5c4fe5fa9aeb26505ea433c52eff3d00d0d23
|
|
train_45190
| 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: SQL
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "SQL",
"developer_needs": [
"evaluation_metrics",
"tests_are_truth",
"tooling",
"cost_latency_tradeoffs"
],
"moe_experts": [
"evaluation_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
5b16b1206e2ff34af52d76cc1796f90968e74f42
|
|
train_45191
| 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: TypeScript
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Pipeline:
Ingest → Normalize → Filter → Dedupe → Quality → Mix → Audit
|
[] |
{
"target_language": "TypeScript",
"developer_needs": [
"cost_latency_tradeoffs",
"ci_integration",
"security_gates",
"reproducibility"
],
"moe_experts": [
"data_curation_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
fe059374962e7d7762d8b245158f3ba416b3cb4d
|
|
train_45192
| 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: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Loop: Plan → Edit → Test → Reflect → Human gate
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "Bash",
"developer_needs": [
"cost_latency_tradeoffs",
"tests_are_truth",
"ci_integration",
"repo_scale_reasoning"
],
"moe_experts": [
"evaluation_expert",
"agentic_systems_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
0698fa67edd5751fbf83251bd1b07aae790c155a
|
|
train_45193
| 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: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Design with risks, metrics, acceptance criteria
|
[] |
{
"target_language": "Rust",
"developer_needs": [
"security_gates",
"governance",
"ci_integration",
"reproducibility"
],
"moe_experts": [
"coding_expert",
"security_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
6e49735f10d3ba1809dc1a4bb02915bdd896a911
|
|
train_45194
| 2026-01-01T00:00:00
|
Model merging, distillation, and continued pretraining
|
agent_loop
|
advanced
|
Task: agent_loop
Topic: Model merging, distillation, and continued pretraining
Difficulty: advanced
Target language: Bash
Context: Large monorepo with flaky tests and strict CI.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Loop: Plan → Edit → Test → Reflect → Human gate
|
[] |
{
"target_language": "Bash",
"developer_needs": [
"ci_integration",
"documentation",
"tooling",
"reproducibility"
],
"moe_experts": [
"governance_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
26ead9db86f3aba7b894c44f8e4881d35db891d0
|
|
train_45195
| 2026-01-01T00:00:00
|
SWE-bench style real-repo evaluation
|
patch_diff
|
advanced
|
Task: patch_diff
Topic: SWE-bench style real-repo evaluation
Difficulty: advanced
Target language: SQL
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[] |
{
"target_language": "SQL",
"developer_needs": [
"reproducibility",
"evaluation_metrics",
"repo_scale_reasoning",
"documentation"
],
"moe_experts": [
"coding_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
687e8d8d01a44dc7dfac427ec4509e9fdd35a821
|
|
train_45196
| 2026-01-01T00:00:00
|
Reasoning-first coding models and tunable deliberation
|
failure_analysis
|
advanced
|
Task: failure_analysis
Topic: Reasoning-first coding models and tunable deliberation
Difficulty: advanced
Target language: Python
Context: Research team validating claims against real repos.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Failure:
- Initial patch broke edge case
Reflection:
- Missing zero-input guard
Correction:
- Add explicit validation + test
|
[] |
{
"target_language": "Python",
"developer_needs": [
"governance",
"repo_scale_reasoning",
"auditability",
"documentation"
],
"moe_experts": [
"coding_expert",
"performance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
7adcef4f1063e144319d58a227244eb57d0cb9dd
|
|
train_45197
| 2026-01-01T00:00:00
|
SWE-bench style real-repo evaluation
|
patch_diff
|
intermediate
|
Task: patch_diff
Topic: SWE-bench style real-repo evaluation
Difficulty: intermediate
Target language: JavaScript
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Patch (diff-style):
```diff
- if x == 0:
- return 1/x
+ if x == 0:
+ raise ValueError('division by zero')
```
Acceptance:
- Tests pass
- No new regressions
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "JavaScript",
"developer_needs": [
"ci_integration",
"evaluation_metrics",
"security_gates",
"auditability"
],
"moe_experts": [
"coding_expert",
"governance_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
d614ba08a0f36713fd13e7fb3b5820e7a854f80a
|
|
train_45198
| 2026-01-01T00:00:00
|
Self-improving agents and feedback loops
|
eval
|
advanced
|
Task: eval
Topic: Self-improving agents and feedback loops
Difficulty: advanced
Target language: Bash
Context: Offline/local deployment with limited compute.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[] |
{
"target_language": "Bash",
"developer_needs": [
"ci_integration",
"documentation",
"auditability",
"security_gates"
],
"moe_experts": [
"performance_expert",
"data_curation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
796c073f6afcb8b17326181a8408b3d5c8006507
|
|
train_45199
| 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: TypeScript
Context: High-traffic service with latency SLOs.
Produce expert-level, production-ready artifacts.
|
Facts:
- Modern AI coding prioritizes correctness, evaluation, and governance.
- Agentic loops with test gates outperform single-pass generation.
Eval:
pass@k, time-to-green, regressions, diff size
|
[
"Identify failing behavior via tests",
"Minimize change surface",
"Apply patch",
"Run targeted + full suite",
"Verify no regressions"
] |
{
"target_language": "TypeScript",
"developer_needs": [
"security_gates",
"documentation",
"reproducibility",
"repo_scale_reasoning"
],
"moe_experts": [
"governance_expert",
"evaluation_expert"
],
"governance": {
"audit_required": true,
"tests_required": true
}
}
|
479d3cbe61db2c1b42f6efbe2507c74849476e23
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.