# Turbo Draft

Turbo Draft is the step between autocomplete and a full agent task. Put the cursor in a
file, press a shortcut, and V3Code infers the unfinished intent, gathers relevant code
and compiler facts, then returns a diff you review hunk by hunk.

It does **not** silently save, commit, or publish anything. You decide which hunks stay.

> Note:
>
> The product name is **Turbo Draft**. “Turbo Boost” is sometimes used conversationally,
> but it is not a separate V3Code feature or command.

## When to use it

Turbo Draft is a good fit when the work is visible in the editor but would be tedious to
spell out in chat:

- Finish a partially implemented file.
- Turn a short comment-only brief into a scaffold.
- Implement a nearby `TODO` or `FIXME`.
- Complete work described by an open `plan.md`, `spec.md`, or similar document.
- Make a deeper pass that follows the callers of the code you are changing.
- Finish prose or documentation from the intent already on the page.

Use a normal refactor for a deterministic rename. Use [Agent mode](/editor/modes) when
the task needs exploration, clarification, commands, tests, and several iterations.

## Run a draft

| Action                             | Shortcut                                                            | Reach for it when                                            |
| ---------------------------------- | ------------------------------------------------------------------- | ------------------------------------------------------------ |
| **Turbo Draft**                    | `Shift + Tab`                                                       | You want the quickest bounded draft in the current file.     |
| **Turbo Draft (Deep)**             | `Alt + Shift + Tab`                                                 | The file needs a more complete context-aware pass.           |
| **Turbo Draft (Deep, multi-file)** | `Ctrl + Shift + Q` on Windows/Linux; `Control + Shift + Q` on macOS | The change should follow related callers, up to three files. |

You can also run all three actions from the Command Palette or the editor title/context
menus.

### Leave a useful signal

Select the most important instruction, place the cursor near a `TODO`, write a short
comment-only brief in a new file, or keep the relevant plan document open.

### Choose Fast or Deep

Press the shortcut. The Turbo Draft dock reports real phases such as reading,
recognizing intent, finding context, validating, and creating review tabs.

### Review every hunk

Press `Tab` to accept the current hunk, `Delete` or `Shift + Tab` to reject it, and
`Escape` to discard the remaining draft.

### Verify normally

Turbo Draft checks for newly introduced diagnostics after review. You should still
run the project's relevant formatter, type-check, tests, and build before shipping.

## How it understands intent

Turbo Draft looks for intent in a deliberate order so an old project plan does not
override what you are doing now:

1. Your current editor selection.
2. The nearest `TODO`, `FIXME`, `HACK`, or `XXX` around the cursor.
3. A nearly empty, comment-only file brief.
4. An open plan-like Markdown file.
5. A general whole-file pass when none of the above exists.

The request can combine the current file, cursor position, recent accepted Tab/V Go
edits, recent agent-chat context, related indexed code, and live language-service facts.

## Compiler truth

With **Use compiler truth** enabled, Turbo Draft asks the language server for current
evidence before it generates:

- Errors and warnings in the file.
- Nearby real symbol signatures.
- Call sites related to the code near the cursor.

That gives the model actual types and diagnostics instead of asking it to infer them from
lookalike code. The packet is time-bounded, so a slow or unavailable language server can
produce partial context.

## Fast, Deep, and multi-file

### Fast

Fast mode favors a smaller context packet and a bounded answer. Use it for an obvious
unfinished block, a small scaffold, or a short document section.

### Deep

Deep mode asks for a more complete file-level result and uses related code and chat
context more aggressively. Use it when “finish this” means understanding the shape of
the whole file.

### Deep multi-file

Multi-file mode starts with the active file, then follows computed related callers in a
small queue. It is intentionally bounded; it is not an unconstrained repository rewrite.
For migrations or architectural work, plan the change and let Agent mode execute and
test it incrementally.

## Safety and review

Turbo Draft does more than paste a model response into the editor:

- It accepts only anchored search/replace blocks or an explicit no-change result.
- It rejects missing, ambiguous, empty, or no-op edit anchors.
- It can ask the model once to repair malformed edits.
- It can salvage independently valid hunks when another hunk fails validation.
- It discards the draft if the source changed while generation was running.
- It applies valid work through V3Code's normal diff review surface.
- It compares diagnostics before and after review and can draft a narrow fix for new errors.

These checks protect the edit transaction; they do not prove that the change is correct
for your application. Human review, tests, and builds still matter.

## Model and feature settings

Open **Settings → Features → Turbo Draft**.

| Control                | Default                       | Does                                                                               |
| ---------------------- | ----------------------------- | ---------------------------------------------------------------------------------- |
| **Same as Chat model** | Off                           | When enabled, Turbo Draft follows the eligible cloud model selected for Chat.      |
| **Turbo Draft model**  | Not selected until configured | Lets you dedicate a compatible cloud chat model to drafting.                       |
| **Use compiler truth** | On                            | Adds live diagnostics, signatures, and call sites when available.                  |
| **Verify draft**       | On                            | Checks accepted work for newly introduced errors and can prepare a focused repair. |

Small local FIM models are designed for Autocomplete and V Go, not whole-file drafting,
so Turbo Draft requires a compatible cloud chat model.

## Review shortcuts

| While reviewing                 | Shortcut                                             |
| ------------------------------- | ---------------------------------------------------- |
| Accept current hunk and advance | `Tab`                                                |
| Reject current hunk and advance | `Delete` or `Shift + Tab`                            |
| Discard all remaining hunks     | `Escape`                                             |
| Cancel an active generation     | Run **Turbo Draft: Cancel** from the Command Palette |

## Troubleshooting

### V3Code asks me to pick a model

Open **Settings → Features → Turbo Draft** and choose a compatible cloud chat model,
or turn on **Same as Chat model** when Chat already uses one.

### Turbo Draft returns no changes

Give it a stronger local signal: select the instruction, add a nearby `TODO`, or put
a concise comment-only brief at the top of a new file. Deep mode is a better fit when
the intent depends on the whole document.

### The draft was discarded because the source changed

The file changed while the model was working, so V3Code rejected the stale result.
Keep the new typing, then run the draft again against the current source.

### Compiler truth is empty or incomplete

Confirm the language extension for that file is active and that the Problems panel,
hover, and references work normally. Turbo Draft can continue with partial context,
but you should verify the result more carefully.

### The draft is structurally valid but wrong

Reject the hunk. Quality gates verify safe anchoring and review flow, not your business
requirements. Use Agent mode when the work needs tests, interactive clarification, or
a longer feedback loop.