Planning Agent

Planning generates an implementation plan before the agent modifies code or runs commands.

Important

The new Qoder CN documentation site is now available. Content on this site may not reflect the latest product features and changes. Visit docs.qoder.cn for the latest product documentation.

Overview

For complex tasks — cross-file development, refactoring, or high-risk changes — Planning provides a transparent, controlled workflow with a clear path to completion.

With Planning enabled, Qoder CN generates a structured solution and plan from your natural-language request. Review and adjust the plan, then let the agent execute it step by step.

Use cases

Enable Planning for:

Complex features spanning multiple modules or files.
Multi-iteration tasks — design, implementation, testing, and cleanup.

For minor changes like fixing a typo or renaming a variable, use the agent directly.

How to use in agent mode

Planning is built into the agent mode and requires no extra configuration. Invoke it in two ways:

1) Automatic: The agent determines whether a plan is needed based on your request.

2) Explicit: Use the /plan command to request a plan.

Follow these steps:

Step 1: Describe your task

Run the /plan command or describe your task in natural language. Include:

The goal of the change or feature.
Constraints, such as preserving API behavior or legacy paths.
Optional: Important file or module paths.

Clearer descriptions produce more accurate plans.

Step 2: Generate a plan

With Planning enabled, Qoder CN:

Analyzes your request and project context.
Generates a plan that covers the objective, technical solution, tech stack, and implementation plan.

At this stage, only a plan is produced — no files are modified and no commands run.

Step 3: Review and adjust the plan

Before execution, adjust the plan as needed:

Refine the solution for precision and clarity.
Add steps the agent may have missed.

You can also use natural language to ask Qoder CN to adjust the plan in natural language. For example: "Add a final step to update the documentation."

Step 4: Start execution

Once the plan is ready, start execution:

The agent reads files, modifies code, runs commands, or calls MCP tools — same as standard agent mode.
Each to-do item updates in real time in the chat: Not Started, In Progress, or Completed.

Depending on your settings, some actions — especially terminal commands and MCP tool calls — may still require manual confirmation.

Step 5: Adjust during execution

During execution:

Track to-do item status at any time.
If a problem arises, pause, state new requirements in the chat, and have the agent update the plan and continue.
For blockers like test failures or missing dependencies, the agent flags them and plans next steps.

You stay in control while the agent handles the mechanical work.

Step 6: Finalize and review

After all to-do items complete, or you stop execution:

The agent can provide a summary of completed work, listing files modified per to-do item.
Review the result with diff view, local tests, or your standard PR process.
Start a new Planning process to continue iterating if needed.

Best practices

Clearly describe your objective: Write your prompt as if assigning a task to a colleague — specify scope, constraints, and acceptance criteria.
Enable Planning by default for high-risk tasks: refactoring, API adjustments, and core logic paths.
Iterate on the plan: If the first draft falls short, ask the agent to adjust. For example: "Focus more on testing" or "Minimize changes to public APIs."
Keep steps small: Each to-do item should fit in a small diff and be easy to review.

Planning balances safety and speed — well-designed plans without sacrificing agent efficiency.