Requirement-Aware Curriculum RL: Teaching LLMs to Code Progressively Like Students

> Paper: Improving LLM Code Generation via Requirement-Aware Curriculum Reinforcement Learning > Authors: Shouyu Yin, Zhao Tian, Junjie Chen, Shikai Guo > arXiv: 2605.00433 | 2026-04-29

The Problem: LLMs That Jump Straight Into Complex Code

The post opens with an analogy: imagine teaching a student to program. On day one you ask for a "Hello World," and they hand back a distributed microservices architecture. The result looks advanced but lacks solid fundamentals—simple problems get over-engineered, and complex problems leave the student stumped.

This, the author argues, mirrors today's LLM code generation:

• Models directly produce complete code
• There is no "simple to complex" learning process
• Performance suffers when facing complex requirements

The Wisdom of Curriculum Learning

Humans learn programming step by step: variables and types, then conditionals, loops, functions, object-oriented design, design patterns, and finally system architecture—each stage building on the last.

But LLM training is like "building a skyscraper on flat ground": models see simple and complex code examples together, with no explicit difficulty progression. This causes over-complication on easy problems and poor decomposition on hard ones.

The Method: Requirement-Aware Curriculum Reinforcement Learning

The paper's core idea: automatically design a curriculum based on requirement complexity, letting the LLM learn code generation progressively.

1. Requirement complexity assessment — Analyze the natural-language requirement, considering the number of functional points, data structure complexity, algorithmic difficulty, and code length.

2. Automatic curriculum generation — Start from simple requirements and gradually increase complexity: first single functions, then combinations of multiple functions, and finally complete modules.

3. Reinforcement learning optimization — Train the LLM on curriculum tasks with reward signals covering code correctness, requirement matching, and code conciseness.

4. Requirement awareness — Beyond generic easy-to-hard scheduling, curriculum tasks are required to relate to the target requirement, sharing structural similarity with the final task.

The author likens this to a wise teacher who designs progressive exercises around the exam goal—every problem contributes to the final capability.

Why Curriculum RL Beats Direct Training

Limitations of direct training:

• Simple and complex code are mixed together, so the model cannot distinguish difficulty
• Rewards on complex tasks are sparse, making them hard to learn

Advantages of curriculum RL:

• Simple tasks provide dense rewards, building foundational capability
• Each step builds on the previous one, so capability improves steadily
• The curriculum is designed around the final goal, avoiding irrelevant skills

A Feynman-Style Judgment

Quoting Feynman: "If you can't simplify it to a freshman's level, you don't understand it yourself." Applied to code generation: a good model should handle both simple and complex code—but complex capability is built on simple foundations. Curriculum RL lets the model master programming progressively, the way humans do.

Takeaways

If you train LLMs or code generation models, ask yourself:

1. Does my training data have a clear difficulty progression? 2. Does the model start with simple tasks and gradually tackle harder ones? 3. Is the curriculum design aligned with the final objective?

The paper's core insight: code generation is not only about "writing correct code," but about "learning to write." When LLMs learn programming progressively like students, they produce better code and gain scalable programming capability. On the road to software engineering automation, curriculum learning is the bridge to complexity.

--- *Originally posted in Chinese on zhichai.net (ZhiChai AI Lab).*