Requirement-Aware Curriculum Reinforcement Learning: Teaching LLMs to Write Code Step by Step

> 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

1. The LLM That Writes Complex Code Right Away

Imagine teaching a student to program:

Day one: you ask for a "Hello World." Result: they produce a distributed microservices architecture.

Problems:

• The code looks "advanced," but the fundamentals are weak
• Simple problems get over-complicated
• Complex problems leave the model helpless

This is exactly the problem with current LLM code generation:

• Complete code is generated in one shot
• There is no "simple-to-complex" learning process
• Performance degrades when facing complex requirements

2. The Wisdom of Curriculum Learning

How humans learn to program: 1. Variables and types 2. Conditionals 3. Loops 4. Functions 5. Object-oriented programming 6. Design patterns 7. System architecture

Each step builds on the previous one.

But LLM training is like "building a tower from a flat plain":

• Simple and complex code examples are mixed together
• There is no explicit difficulty progression
• The result: over-complication on simple problems, poor decomposition on complex ones

3. Requirement-Aware Curriculum Reinforcement Learning

The paper proposes Requirement-Aware Curriculum RL:

Core idea: > Automatically design a curriculum based on the complexity of programming requirements, letting the LLM learn code generation step by step.

Technical approach:

1. Requirement complexity assessment — analyze the natural-language requirement, considering the number of features, data-structure complexity, algorithm difficulty, and code length. 2. Automatic curriculum generation — start from simple requirements and gradually increase complexity: single functions first, then combinations of functions, then complete modules. 3. Reinforcement learning optimization — train the LLM on curriculum tasks with reward signals for code correctness, requirement matching, and code conciseness. 4. Requirement awareness — not just "easy to hard," but also "relevant to the target requirement": curriculum tasks are structurally similar to the final task.

Like a wise teacher: designing progressive exercises aligned with the exam goal, where every problem contributes to the final capability.

4. 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:

• Dense rewards from simple tasks establish foundational ability
• Each step builds on the last, so capability improves steadily
• Curriculum design is aligned with the final goal, avoiding irrelevant skills

5. A Feynman-Style Judgment: Good Learning Needs a Good Curriculum

Feynman said:

> "If you can't simplify it to a freshman's level, you don't understand it yourself."

For code generation:

> "A good code-generation model should write both simple and complex code. But complex ability is built on simple foundations. Curriculum RL lets the model master programming progressively, like a human."

6. Takeaways

If you are training LLMs or code-generation models, ask yourself:

1. "Does my training data have a clear difficulty progression?" 2. "Does the model start from simple tasks before tackling complex ones?" 3. "Is the curriculum design aligned with the final objective?"

The core lesson: code generation is not only about "writing it right" — it is about "learning to write."

When an LLM learns programming progressively like a student, it not only generates better code but also gains scalable programming ability. On the road to software engineering automation, curriculum learning is the bridge to complexity.