> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/cline/cline/llms.txt
> Use this file to discover all available pages before exploring further.

# Plan and Act mode

> Think before you build. Cline's two-mode system separates exploration from implementation so you approach every task with the right context.

Plan and Act are two distinct modes that structure how Cline engages with your codebase. Plan mode lets you explore and strategize without touching any files. Act mode executes against the plan you've built together.

<Tip>
  Watch the [Plan & Act deep dive](https://youtu.be/b7o6URFPp64) to see both modes in action.
</Tip>

## Plan mode

In Plan mode, Cline can read files, run searches, and discuss strategy — but it cannot modify files or execute commands. This constraint is intentional: it keeps the conversation focused on understanding and approach rather than jumping straight to implementation.

Use Plan mode to:

* Explore an unfamiliar codebase before making any changes
* Discuss architecture decisions and their tradeoffs
* Identify edge cases and potential issues before they become problems
* Review code and understand complex workflows
* Create a clear implementation strategy you're both aligned on

## Act mode

Once you have a plan, switch to Act mode. Cline carries the full context from your planning session forward — every file it read, every decision you discussed — and can now modify files and execute commands.

You don't need to repeat yourself. The conversation history transfers seamlessly between modes.

<Note>
  You can start directly in Act mode for simple tasks, but planning first is strongly recommended for anything non-trivial. The planning phase builds the context Cline needs to make the right decisions when implementing.
</Note>

## Switching between modes

The mode toggle appears at the bottom of the Cline chat input. Click it or use the keyboard shortcut to switch between Plan and Act.

For complex work, you may cycle between modes multiple times. If Act mode reveals unexpected complexity — a tangled dependency, an unforeseen edge case — switch back to Plan mode to rethink the approach, then return to Act mode to continue.

## Typical workflow

<Steps>
  <Step title="Start in Plan mode">
    Describe what you want to build. Point Cline at relevant files using [@ mentions](/core-workflows/working-with-files) so it can read them before you discuss the approach.
  </Step>

  <Step title="Explore and discuss">
    Let Cline read through the codebase. Discuss the approach, surface edge cases, and agree on a strategy. Ask Cline to create a markdown summary or todo list for reference.
  </Step>

  <Step title="Switch to Act mode">
    Once you're confident in the plan, switch to Act mode. Cline implements the solution using the context built during planning. Consider enabling [checkpoints](/core-workflows/checkpoints) before this step so you can roll back if needed.
  </Step>

  <Step title="Iterate as needed">
    If Act mode surfaces unexpected complexity, switch back to Plan mode to revisit the approach, then return to Act mode to continue.
  </Step>
</Steps>

## When to use each mode

| Scenario                                                  | Recommended mode |
| --------------------------------------------------------- | ---------------- |
| Starting a new feature where the approach isn't obvious   | Plan             |
| Debugging a tricky issue where you're unsure what's wrong | Plan             |
| Making architectural decisions that affect multiple files | Plan             |
| Understanding a complex workflow before modifying it      | Plan             |
| Code review and security analysis                         | Plan             |
| Learning a new codebase                                   | Plan             |
| Implementing a solution you've already planned out        | Act              |
| Making routine changes that follow established patterns   | Act              |
| Running tests and making small adjustments                | Act              |
| Quick fixes where the solution is obvious                 | Act              |

## Choosing the right approach by task size

<CardGroup cols={3}>
  <Card title="Small tasks" icon="bolt">
    Start directly in Act mode. Planning adds overhead when the solution is already clear.

    **Examples:** Fix a typo, add a missing import, update a config value, rename a variable.
  </Card>

  <Card title="Medium tasks" icon="map">
    Start in Plan mode to scope the work, then switch to Act mode to implement. The right balance for most features.

    **Examples:** Add an API endpoint, build a UI component, fix a bug that needs investigation, refactor a single module.
  </Card>

  <Card title="Large tasks" icon="drafting-compass">
    Use [`/deep-planning`](/core-workflows/using-commands#deep-planning) to produce a detailed implementation plan before writing any code.

    **Examples:** Features spanning frontend and backend, major refactors, new system integrations, multi-step migrations.
  </Card>
</CardGroup>

## Using different models for each mode

You can configure separate models for Plan and Act modes. This is useful when you want a stronger reasoning model for planning and a faster model for implementation.

<Steps>
  <Step title="Open Cline settings">
    Click the gear icon in the Cline sidebar.
  </Step>

  <Step title="Enable per-mode models">
    Toggle **Use different models for Plan and Act**.
  </Step>

  <Step title="Select a model for each mode">
    Choose your preferred model for Plan mode and a separate model for Act mode.
  </Step>
</Steps>

When enabled, switching modes automatically switches to the configured model. Example configurations:

| Goal              | Plan mode      | Act mode       |
| ----------------- | -------------- | -------------- |
| Cost optimization | GLM 4.6        | Grok Code Fast |
| Maximum quality   | Claude Opus    | Claude Sonnet  |
| Speed-focused     | Gemini 3 Flash | Cerebras       |

## Tips

* Use [file mentions](/core-workflows/working-with-files) to point Cline at relevant files during planning so it has full context before you discuss the approach
* Ask Cline to write a markdown summary of the plan for future reference — useful for long tasks or ones you'll return to later
* Switch back to Plan mode when you hit unexpected complexity rather than pushing through in Act mode
* Enable [checkpoints](/core-workflows/checkpoints) before switching to Act mode so you can restore files if something goes wrong
* For large tasks, ask Cline to create a todo list during planning that you can track as Act mode works through each step