Training mode for coding agents: optimize for developer skill acquisition, not task completion

What variant of Codex are you using?

IDE Extension

What feature would you like to see?

Add a first-class Training Mode (e.g. --training / /training) for Codex coding agents.

The goal is different from normal agent operation:

Normal mode: maximize the quality and speed of the resulting software.

Training mode: maximize the growth of the developer using the agent.

This distinction is becoming increasingly important as coding agents become capable of implementing increasingly large portions of a task autonomously.

Motivation

AI-assisted development is extremely powerful for experienced developers. A seasoned engineer can use the agent as an amplifier: they provide problem formulation, architecture, judgment, verification and direction, while the agent handles large amounts of implementation and investigation.

For beginners and less experienced developers, however, the same behavior can have the opposite effect.

If the agent routinely:

• designs the architecture,
• writes the implementation,
• finds the bugs,
• fixes the bugs,
• generates the tests,
• explains the result,

the developer can become highly productive without necessarily developing the expertise required to independently perform or evaluate those activities.

This creates a potential apprenticeship problem: the agent can remove exactly the work through which developers traditionally acquire competence.

Training Mode should address this explicitly.

Proposed behavior

When Training Mode is enabled, Codex should deliberately avoid solving problems that the developer can reasonably solve themselves.

For example:

Normal mode | Training mode -- | -- Implement the requested feature | Ask the developer to propose an implementation first Write the code | Have the developer write key portions Fix the bug | Ask the developer to diagnose it first Provide the answer | Give progressive hints Choose the architecture | Ask the developer to propose alternatives Generate tests | Ask what should be tested and why Explain the solution afterward | Ask the developer to predict the solution first Optimize for completion | Optimize for learning

Adaptive scaffolding

Training Mode should not simply refuse to help.

It should provide adaptive scaffolding based on demonstrated competence:

1. Ask the developer to attempt the task.
2. Evaluate the attempt.
3. If correct, move to the next challenge.
4. If partially correct, provide a targeted hint.
5. If incorrect, provide a counterexample or question that exposes the error.
6. Only progressively reveal more of the solution when necessary.
7. After the task, explain what was learned and identify remaining weaknesses.

The agent should adapt the level of intervention to the developer rather than applying a fixed "beginner mode."

Examples

Instead of:

"Implement Dijkstra's algorithm."

and immediately producing the implementation, Training Mode might ask:

"Before coding: what invariant does your priority queue maintain?"

Instead of automatically fixing a failing test:

"What do you think is causing this failure? Give me your hypothesis before I investigate it."

Instead of automatically selecting an architecture:

"Propose two architectures. I'll try to find failure modes and tradeoffs in each."

Prediction / challenge mode

An especially useful feature would be requiring the developer to make a prediction before the agent reveals its analysis.

Examples:

• "What is the worst-case complexity?"
• "Which implementation will scale better?"
• "What failure mode do you expect here?"
• "Which invariant does this code rely on?"
• "Where do you think this race condition originates?"

The agent can then compare the prediction with reality.

This turns ordinary development into deliberate practice.

Important distinction from Study Mode

A general Study Mode is useful, and I see the related proposal in #33112.

Training Mode would be specifically integrated into the coding-agent workflow.

The developer should still be working on a real repository and real software. The objective is simply to prevent the agent from automatically removing the learning opportunities embedded in that work.

In other words:

Study Mode: "Teach me software engineering."

Training Mode: "Let me develop this real software, but don't let your capabilities prevent me from developing my own capabilities."

Possible configuration

Something along these lines could eventually be exposed:

training:
  enabled: true
  require_user_attempt: true
  progressive_hints: true
  adaptive_scaffolding: true
  require_reasoning: true
  auto_fix: false
  auto_implement: constrained
  prediction_challenges: true
  post_task_review: true

The exact configuration isn't important; the important part is that training becomes an explicit agent objective rather than an accidental side effect of using an AI assistant.

Why this matters

Coding agents are rapidly changing the economics of software development.

For experienced developers, this can be transformative: the agent amplifies existing expertise.

For developers still acquiring expertise, however, unrestricted automation may create a paradox:

The better the agent becomes at doing the work, the fewer opportunities the learner has to practice doing the work.

A first-class Training Mode would allow Codex to preserve the benefits of AI assistance while deliberately maintaining the human learning loop.

I believe this could become an important feature for students, junior developers, career changers, and anyone deliberately trying to build software-engineering expertise while using increasingly autonomous coding agents.

Additional information

No response

No files, tests, or implementation entry points are identified in the issue. Start by reviewing the existing coding-agent workflow and related Study Mode proposal #33112; done would require a defined Training Mode with adaptive scaffolding, progressive hints, prediction challenges, and explicit configuration behavior.