Edit and write tools are switched off, while tests and typecheckers still run. Review the plan, then switch to Build to make the change.
Fix the registration validation bug and run the relevant tests.
plan.md
Fix registration validation
Ask ML.ai...
Developers starting large changes who want to map the codebase, identify trade-offs, and produce a step-by-step plan before committing to any edits.
Map the codebase and get a step-by-step plan before any file is edited.
Settle the choices up front so they do not resurface halfway through the build.
Plan steps that each land as their own reviewable diff once you switch to Build.
The agent reads, searches and runs checks while edit and write tools stay off. You get a plan to review, and the repo stays as it is until you switch to Build.
PLAN.md · image uploads
## Step 1: add an uploads queue
- create src/jobs/resizeImage.ts
- enqueue from POST /uploads
- test: jobs/resizeImage.test.ts
The plan, written as steps to review
The agent reads the code the change touches, then writes the plan as numbered steps. Each step names the files involved and the test that proves it worked.
await queue.add('resize', file)
queue.process('resize', resizeImage)
expect(queue.add).toHaveBeenCalled()
Proposed edits stay in the plan as text
Where a step needs code, the plan shows the lines it would add. Edit and write tools are denied for the turn, so those lines stay proposals until you move to Build.
“Write the resize worker now”
await queue.add('resize', file)
return res.status(202).json(file)
Waiting for your approval
Edits wait until you switch to Build
If a Plan mode turn calls for an edit, the edit tool is denied and the agent describes the change instead. Switch the next turn to Build and it goes through a normal permission prompt.
Plan the upload queue change
Which queue should the resize worker use?
Reuse the existing Redis queue
Add a separate uploads queue
Trade-offs are raised before any code exists
When the plan forks, the agent lays out the options and the trade-offs of each. You pick one, and the rest of the plan is written around your choice.
· BuildRead cart.ts and cart.test.ts
Edit src/cart.ts?
−return subtotal
+return subtotal - discount
· PlanEdit and write tools are off for this turn
Read cart.ts and cart.test.ts
Ran the tests and the typechecker
Plan ready with 3 steps to review
Build mode has the full tool set, and every edit and command still goes through Allow, Always or Deny with the real diff in front of you.
Reading, search, tests and typecheckers stay on while edit and write tools are denied, so the turn ends with a plan and an untouched repo.
Mode applies to a single turn, so you can plan in one message and build in the next without starting a new conversation.
Plan moving image uploads to a background job queue
Edit and write tools are off for this turn
Reuse the existing Redis queue instead
1. add a resize job to the Redis queue
2. enqueue from POST /uploads
3. test: jobs/resizeImage.test.ts
Edit and write tools are off for this turn
BuildEdits files, runs commands, verifies the result.
PlanInvestigates and returns a plan. Cannot edit or write.
Carry out the plan, starting with step 1
Read src/routes/uploads.ts
Edit src/routes/uploads.ts?
−await resizeImage(file)
+await queue.add('resize', file)
Plan moving image uploads to a background job queue
Edit and write tools are off for this turn
A few details about how Plan mode behaves that are easy to miss the first time you use it.
What goes wrong
How handles it
A plan written against last week’s code can miss a file that has changed since, and a step that looked safe on paper breaks as soon as someone starts typing.
How handles it
The agent reads the current files and can run your tests and typecheckers while planning, so every step is grounded in how the repo behaves right now.
A ten-step plan buried in a long conversation is hard to hand to a teammate or to pick up again the next morning.
How handles it
Call planSubAgent with @ and the plan is saved to a file you can commit, share, or split into separate pieces of work.
Because mode applies per turn, it is easy to assume you are still in Plan mode after switching to Build for a single change.
How handles it
The mode chip in the composer shows the current mode for every message, and edits in Build still stop at an Allow, Always or Deny prompt before they land.
SettingsAgents
Pick a subagent and it stays selected until you swap it. Only general carries out changes end to end.
@explore · Where is the refresh token rotated?
› Searched refreshToken · 14 matches
› Read src/auth/session.ts, src/auth/rotate.ts
› Answered · 0 files changed
@exploreAsk ML.ai... @ to delegate
Searched getUser9 matches
Edited 4 files+12 −12
Ran pnpm test48 passed
Inside the project only · back to you after one turn
Edits and commands, inside the project
Use architect or planSubAgent for a deeper read-only pass that lists critical files, trade-offs and a step-by-step plan.
Found the refresh path. Updating the session helper now.
GreprefreshToken · 6 matches in app/auth
Fs.readapp/auth/session.ts
Fs.writeapp/auth/session.tspending
app/auth/session.ts2 lines changedlines 42-50
42export async function refresh(token) {
43 if (!token) return null;
44 if (!token?.exp) throw new Error('expired');
45 return await rotate(token);
46}
47
48async function rotate(token) {
49 const next = await issue(token.sub);
50 return next;
12@@ -12,3 +12,3 @@ export type Invoice
13- userId: string;
13+ accountId: string;
14 amount: number;
Three answers on every prompt
Once you switch to Build, every edit and command opens with a real diff and an Allow, Always or Deny choice.
No. Plan mode denies edit and write tools for the turn, whatever your approval settings. Shell commands still pass through the safety classifier, whose absolute refusals hold in every mode, auto-approve included.
Every step should name the files it touches and the test that proves it. If not, ask the agent to fill the gaps while you are still in Plan mode.
Yes. Check which trade-offs the plan settled and whether you agree with each one, since a choice you skip tends to come back halfway through the build.
Small enough to land as its own reviewable diff, so each one is easy to approve once you switch the turn to Build.
Map the files, weigh the trade-offs and agree on the steps in Plan mode, then switch to Build when the plan looks right.
