MicroCoder-Dataset: Curated Corpus for Code Generation

• MicroCoder-Dataset is a curated training corpus of competitive programming problems that emphasizes recent, difficult challenges to enhance code generation models.
• It employs a four-stage Data Processing Framework with Automatic Difficulty Filtering to ensure tasks are recent, clean, and sufficiently challenging.
• Empirical evaluations show the dataset achieves up to 3x performance gains in reinforcement learning settings compared to standard coding corpora.

Searching arXiv for the MicroCoder papers to ground the article in the latest preprints. MicroCoder-Dataset is a curated training corpus for code generation models, centered on real competitive programming problems selected for recency, difficulty, and execution reliability. It was introduced in conjunction with MicroCoder-GRPO and MicroCoder-Evaluator to address a specific training bottleneck: contemporary coding models exhibit “extended outputs, accelerated capability growth, and changed training dynamics,” while mainstream coding corpora have become too easy to produce strong learning signals. In the dataset-focused account, MicroCoder is described as a difficulty-aware, recency-focused corpus built through a four-stage Data Processing Framework and an Automatic Difficulty Filtering procedure; in the training-focused account, it is characterized as a more challenging corpus that elicits longer solution paths, lower critic rewards, and faster response-length growth during reinforcement learning (Li et al., 8 Mar 2026, Li et al., 8 Mar 2026).

1. Definition and intended function

MicroCoder-Dataset is designed as a training dataset rather than an evaluation benchmark. Its role is to supply reinforcement learning for coding models with recent, hard, and clean tasks that better stretch model capabilities, especially on medium and hard problems. The central motivation is that existing code corpora suffer from difficulty imbalance skewed toward easy tasks, format inconsistency between function-completion and input/output problem styles, and data quality problems such as noisy or incomplete statements and test suites (Li et al., 8 Mar 2026).

The dataset is also explicitly tied to a broader training stack. MicroCoder-GRPO addresses long-output and diversity bottlenecks through conditional truncation masking, diversity-determined temperature selection, and removal of KL loss with high clipping; MicroCoder-Evaluator improves reward reliability through more robust output checking. MicroCoder-Dataset supplies the harder problem distribution that makes these algorithmic and evaluator modifications consequential in practice (Li et al., 8 Mar 2026).

A common misconception is to treat MicroCoder primarily as a catalog of coding tasks. In the papers, its significance is instead methodological: it is a deliberately curated corpus meant to change training dynamics. The reported gains are therefore interpreted not merely as a consequence of more data, but of fresher, more difficult, and more consistently formatted data (Li et al., 8 Mar 2026).

2. Corpus composition and source profile

MicroCoder comprises exclusively real competitive programming problems and contains no synthetic content. After full processing and filtering, the dataset size is reported as 13,300 curated problems. The sources include both open and privately collected platforms. Open contributions are primarily from TACO and OlympicCoder, while private collections contribute competition problems from AIZU, AtCoder, CodeChef, and Kattis; these private collections form the primary backbone of the final corpus (Li et al., 8 Mar 2026).

The corpus emphasizes recent contests and recent problems in order to reduce pretraining familiarity and increase inherent difficulty. The papers do not specify an exact time range, but they repeatedly frame recency as a deliberate design principle. This suggests that the dataset is intended not only to rebalance difficulty, but also to mitigate hidden leakage from older, highly reused benchmark-style problems.

MicroCoder remains tightly scoped. It focuses on classical competitive programming task formats with executable test cases. Problems without test cases are removed. Problems requiring functional validation with multiple acceptable answer formats are excluded. Items whose essential content depends on unrecoverable images or formulas are dropped. The training setup is therefore aligned with I/O-driven execution rather than arbitrary code synthesis tasks (Li et al., 8 Mar 2026).

The papers provide some descriptive statistics but not a full schema. Most problems are reported to cluster between 1,000 and 3,000 characters, and AIZU has the longest average statements. Private collections tend to have more test cases per problem. The papers do not specify programming language distributions, token counts, domain tags, or field-level metadata (Li et al., 8 Mar 2026).

3. Data processing and standardization pipeline

MicroCoder is built through a four-stage Data Processing Framework: Collect, Process, Filter, and Verify. The Collect stage aggregates public datasets such as TACO, KodCode, and DeepCoder, together with web-collected contest problems, with provenance maintained for later overlap checks. The stated objective is to maximize platform coverage and recency (Li et al., 8 Mar 2026).

The Process stage performs standardization in five steps. First, non-English statements, including Japanese AIZU problems, are translated to English. Second, noise removal and refinement target missing images critical to comprehension, incomplete mathematical formulas or symbols, broken tables or graphics, irrelevant scraped content such as ads or links, incomplete descriptions, and other general content-quality issues. Problems that cannot be adequately repaired are removed, and the process is described as avoiding subjective edits that would change problem semantics.

Third, test case optimization addresses both missing and excessive tests. For problems with reference solutions but lacking or noisy tests, an LLM generates comprehensive test inputs including boundary cases, and the reference solution is executed to obtain ground-truth outputs. For problems with hundreds of long tests, the pipeline selects the 15 longest test cases per problem, following DeepCoder, to control compute and stabilize training while preserving difficulty signals. Fourth, format standardization reconciles function-completion and I/O-based tasks: CF retains its native format, while other sources adopt the LiveCodeBench format. Fifth, completeness validation ensures coherent statements and executable, appropriately sized test suites (Li et al., 8 Mar 2026).

The Verify stage performs final manual validation for readability, completeness, and test-case accuracy before release. In the training-oriented description, verification is summarized more compactly as readability, completeness, and test case accuracy checks, reinforcing that correctness signals are integral to the corpus rather than an auxiliary annotation layer (Li et al., 8 Mar 2026).

4. Difficulty modeling, calibration, and contamination control

The distinctive feature of MicroCoder is its explicit difficulty-aware curation. Automatic Difficulty Filtering follows a predict–calibrate–select framework. In the predict step, three independent GPT-4O assessments score each problem on five dimensions using a 1–5 scale: Algorithmic Thinking Complexity (ATC), Implementation Difficulty (ID), Problem Comprehension Difficulty (PCD), Knowledge Breadth Requirements (KBR), and OD, whose acronym is used in scoring but not expanded in the paper. The weighted score is

$$S(j)=0.45\cdot ATC(j)+0.35\cdot ID(j)+0.10\cdot OD(j)+0.05\cdot PCD(j)+0.05\cdot KBR(j),$$

and the final score is

$\bar{S}=\frac{1}{3}\sum_{j=1}^{3} S(j).$

The weighting makes ATC and ID the dominant contributors, with PCD and KBR minimized, and OD assigned intermediate influence (Li et al., 8 Mar 2026).

In the calibrate step, ground-truth difficulty is measured by the success rate of Qwen-3-4B-thinking over four attempts per problem. The predicted score distribution is then aligned to empirical performance on a calibration subset. The reported category boundaries are $\bar{S}=2.5$ for easy versus medium and $\bar{S}=2.75$ for medium versus hard, yielding a near-perfect match to the actual distribution. The paper does not specify a named calibration algorithm, such as isotonic regression or temperature scaling (Li et al., 8 Mar 2026).

In the select step, problems below the target threshold are removed. In the reported LiveCodeBench v6 case study, removing all problems with $\bar{S}<2.5$ eliminates about 30% of the data overall and preferentially removes easy problems. The paper reports over 60% recall of the easy category at 30% filtering and elsewhere states that more than 65% of easy problems are removed. It also reports a substantial drop in easy-problem share and an increase in the difficult share after filtering. These figures are presented as evidence that the filtering procedure reshapes the corpus toward medium and hard content rather than performing indiscriminate pruning (Li et al., 8 Mar 2026).

Contamination control is handled through deduplication and train–test separation. The dataset uses 16-gram similarity with a threshold of 0.22 against evaluation sets. The paper reports that validation using AtCoder against LiveCodeBench v6 found about 3% of training items exceeding the threshold, but none were identical to test problems; additional cosine similarity checks against AtCoder, LeetCode, and LiveCodeBench benchmarks lie in the range 0.04–0.14, indicating low cross-set similarity. The papers do not provide a quantitative contamination analysis beyond these overlap checks, so any stronger claim about leakage resistance would be inferential rather than explicitly established (Li et al., 8 Mar 2026).

5. Task format and use in reinforcement learning

MicroCoder is constructed for executable RL training. Each problem functions as a query $q$, from which multiple candidate solutions are sampled and validated against tests to produce a binary reward. The reward signal is stated as “0–1 binary accuracy as reward,” with correctness established by passing all test cases under runtime limits. Evaluation uses strictly unseen LiveCodeBench v6 problems, specifically unseen AtCoder and LeetCode subsets, and average accuracy is computed across four inference attempts per problem (Li et al., 8 Mar 2026).

The papers do not provide a field-by-field public schema, but they do specify the execution regime. Format normalization is intended to prevent “right algorithm, wrong format” failures. CF retains native formatting, while other sources are converted to the LiveCodeBench prompt and execution format. This reflects a view that formatting errors are not mere presentation issues; in RL settings with binary execution rewards, they can erase otherwise correct algorithmic behavior (Li et al., 8 Mar 2026).

MicroCoder’s training role becomes clearer in its interaction with long-output policies. Default experiments use maximum response lengths of 8K tokens, and several analyses compare 4K training with 4K or 8K testing to study reasoning-budget scalability. The dataset is described as eliciting longer solution paths, with Figure 1 showing sustained accuracy increases, lower critic rewards because the problems are harder, and faster and ultimately longer response growth than DeepCoder. This coupling between problem difficulty and output length is a recurrent theme in the MicroCoder program: harder problems are not only more discriminative, but also more compatible with training methods designed for extended reasoning traces (Li et al., 8 Mar 2026).

6. Empirical effects, ecosystem links, and limitations

The principal empirical claim is that MicroCoder achieves 3x larger performance gains within 300 training steps than widely used baseline datasets of similar size, with advantages visible under both GRPO and DAPO. In the training-focused paper, the comparable statement is that MicroCoder-Dataset achieves “3x larger performance gains than mainstream datasets on LiveCodeBench v6 within 300 training steps.” Both accounts emphasize that the gains are concentrated on more difficult regimes rather than easy problems (Li et al., 8 Mar 2026, Li et al., 8 Mar 2026).

The dataset-focused paper reports concrete comparisons against DeepCoder for Qwen3-4B-Instruct-2507 at 8k. Under GRPO, MicroCoder versus DeepCoder yields +2.2 points on AtCoder, +1.6 on LeetCode, and +2.0 on LiveCodeBench overall, with an example hard-category gain of +3.7 points on LeetCode Hard. Under DAPO, the corresponding gains are +3.6 on AtCoder, +6.0 on LeetCode, and +4.4 on LiveCodeBench overall, with pronounced medium-category improvements such as +9.7 points on LeetCode Medium, described as a +40.4% relative improvement. The same paper reports up to 17.2% relative gains in overall performance, especially where model capabilities are most stretched (Li et al., 8 Mar 2026).

The companion training paper situates MicroCoder-Dataset within a larger system. MicroCoder-GRPO achieves up to 17.6% relative improvement over strong baselines on LiveCodeBench v6, while MicroCoder-Evaluator improves evaluation accuracy by approximately 25% and execution speed by around 40%. The dataset is presented as the harder corpus that makes these algorithmic and evaluator gains more meaningful by providing stronger gradients, lower critic rewards, and longer outputs during training (Li et al., 8 Mar 2026).

Several limitations are explicit. The papers do not provide a public schema, token counts, programming language distributions, domain breakdowns, dataset versioning, or licensing terms. The OD dimension is used in difficulty scoring but not expanded by name. The calibration methodology is empirical and not specified as a particular statistical model. Although the verification pipeline includes test-case checks and the evaluation protocol uses unseen LiveCodeBench v6 splits, the papers do not quantify contamination risk beyond the stated overlap analyses. For this reason, MicroCoder should be understood as a rigorously curated but not fully exhaustively documented training corpus (Li et al., 8 Mar 2026, Li et al., 8 Mar 2026).