# Build Mode





<DocVideo src="features/modes/switch-to-build" alt="Clicking the Plan button in the chat input to switch to Build, then typing a change to make" width="960" height="252" />

Build Mode is the default mode in Ideavo. It allows the agent to think, plan, and act autonomously — making it capable, reliable, and independent when working on complex development tasks.

<Callout type="info">
  **Ideavo has two modes:**

  * [**Plan Mode**](/docs/features/plan-mode) — think through the problem, explore options, and decide on an approach
  * **Build Mode** — implement changes and verify the outcome

  Plan Mode is for decision-making. Build Mode is for execution. You can switch between them at any time.

  Both modes are available in [**Tasks**](/docs/features/tasks) as well.
</Callout>

<Cards>
  <Card title="Autonomous by default" icon="<Bot />" description="Build Mode is always on. Describe what you want and the agent handles the rest — no setup needed." />

  <Card title="Verifies as it builds" icon="<ShieldCheck />" description="Inspects errors, reads logs, and iterates until changes work correctly before finishing." />
</Cards>

## What Build Mode can do [#what-build-mode-can-do]

When you give Ideavo a task in Build Mode, it takes full ownership of execution. It understands your intent, explores the codebase for the right context, applies changes across files, and resolves issues that come up along the way — without needing step-by-step supervision.

The agent can:

* Interpret your requests and infer intent from context
* Explore your codebase to gather the right context before making changes
* Apply coordinated changes across frontend, backend, and configuration
* Fix and refactor code across multiple files in a single pass
* Debug issues proactively — inspecting logs, tracing errors, and iterating on fixes
* Search the web in real time to fetch documentation or reference material
* Verify that changes work correctly before finishing

## How to Use Build Mode [#how-to-use-build-mode]

Build Mode is active by default — just describe what you want in the chat and the agent gets to work.

Clear, specific prompts consistently produce better results. The more context you give upfront — what to change, what to preserve, and how it should behave — the less back-and-forth you'll need.

### Writing effective prompts [#writing-effective-prompts]

**Be specific about what you want**

```
Add a contact form with name, email, and message fields. Validate email format and show error messages inline.
```

**Describe the expected behavior**

```
When users click 'Add to Cart', show a success message and update the cart count in the header. Store cart items in local storage.
```

**Mention filenames for better agent clarity**

```
Update the dashboard in src/pages/Dashboard.tsx to show sales data from the last 30 days. Match the styling used in src/pages/Analytics.tsx.
```

**Set boundaries for sensitive areas**

```
Add a notifications panel to the sidebar. Do not modify the existing authentication logic or the shared Layout component.
```

## Execution & Visibility [#execution--visibility]

### Task progress [#task-progress]

While Build Mode is working, you can follow along step by step in the **Details view**. It shows:

* The current step being executed
* Files being read or modified
* Tools in use — web search, log inspection, verification
* Progress through multi-step implementations

This keeps you oriented on complex builds and helps you spot potential issues early.

### Prompt queue [#prompt-queue]

Build Mode processes one task at a time, but you don't have to wait. You can send additional prompts while it works — they're added to a visible queue above the chat input.

From the queue you can:

* Remove individual queued prompts
* Change a prompt by removing it and sending a new one
* Pause and resume the queue at any time

This makes it easy to batch work, plan ahead, and keep momentum without waiting for each step to finish.

## Debugging & Verification [#debugging--verification]

Build Mode doesn't just write code — it checks that things actually work. During and after implementation, the agent can:

* Observe build errors and act on them immediately
* Inspect console output and runtime logs to trace issues
* Reproduce reported bugs to confirm root cause before fixing
* Iterate on fixes until behavior matches what was requested

This tightens the feedback loop and reduces the number of follow-up prompts needed to get to a working result.

## FAQ [#faq]

<Accordions>
  <Accordion title="Does Build Mode modify my project directly?">
    Yes. Build Mode applies changes directly to your project. All modifications
    are visible through file diffs and summaries in the Details view.
  </Accordion>

  <Accordion title="How does Build Mode handle errors during implementation?">
    The agent doesn't stop at the first error. It inspects build output, reads
    logs, and iterates on fixes as part of the same task — only surfacing to you
    when it needs more context or hits a genuine blocker.
  </Accordion>

  <Accordion title="Can Build Mode work across multiple files at once?">
    Yes. Build Mode applies coordinated changes across frontend, backend, and
    configuration files in a single pass, keeping everything consistent.
  </Accordion>

  <Accordion title="When should I switch to Plan Mode?">
    Switch to [Plan Mode](/docs/features/plan-mode) when you want to think
    through a complex change before implementation, compare approaches, or
    investigate an issue before any code is touched.
  </Accordion>
</Accordions>
