The Problem With "Just Do It" Agents
There's a certain type of agentic coding session that starts fine and ends with you staring at a diff you don't fully understand, wondering which of the twelve files the agent touched actually needed changing. I've been there. You give the agent a broad task, it goes off and writes, edits, renames, and you approve each step individually without ever seeing the full picture first.
That's the gap PlanMode fills.
What PlanMode Actually Does
When you activate PlanMode in lac agent, the agent stops before touching anything. Instead of immediately reading files and making edits, it lays out a complete plan: what it intends to read, what it intends to create or modify, what the overall approach is, and what order it's going to do things in.
You review that plan. You can push back, ask it to change the approach, cut a step, or add something it missed. Only once you explicitly approve does the agent start executing.
It sounds simple. In practice it changes how you use the tool entirely.
How to Trigger It
Inside a lac agent session, just prefix your task with /plan:
/plan refactor the auth module to use JWT refresh tokens and clean up the middleware stackThe agent comes back with something like:
- Read
src/auth/index.js,src/middleware/auth.js,src/routes/user.js - Create
src/auth/refresh.js— new refresh token logic - Edit
src/middleware/auth.js— swap session check for JWT verify + refresh call - Edit
src/routes/user.js— update protected route handler - Edit
src/auth/index.js— expose new refresh utilities - Check
package.json— confirmjsonwebtokenis present, suggest install if not
That list right there already tells you three things you might want to adjust before a single character gets written.
Why This Matters More Than You'd Think
The obvious benefit is safety. You see the blast radius before anything happens. But there's a less obvious benefit: the planning step forces the agent to think through the task more carefully. It has to articulate a coherent sequence, which tends to surface edge cases it would otherwise hit mid-execution and then awkwardly patch around.
I've had sessions where the plan itself revealed that the task I described was underspecified. The agent listed four files I hadn't thought about, and I realized my original instruction was going to produce something half-baked. Better to catch that at the plan than at the diff.
There's also a communication angle. If you're working on a team and you want a second opinion before the agent runs, you can paste the plan into Slack, get a quick thumbs-up, and then approve. That's a lightweight review loop that costs almost nothing.
Editing the Plan Before Approving
You're not just approving or rejecting the whole plan. You can reply conversationally to change it:
Skip the routes/user.js edit for now — just do the auth module and middleware. Also check if we have any tests for the old session logic before you touch it.The agent updates the plan accordingly and shows you the revised version. Once it looks right, you confirm and execution starts.
This back-and-forth usually takes two minutes, and it saves you from the "I need to undo three files because step four assumed something wrong" situation that the undo system exists to clean up after.
PlanMode + Project Memory
One thing that makes PlanMode more useful over time is that lac agent reads your .lac-memory.json before generating the plan. If you've stored notes like "never edit the generated files in /dist directly" or "always run tests after touching auth", the agent factors those into the plan it proposes.
So after a few sessions you stop having to manually redirect the agent on the same things. The memory carries your preferences and the plan reflects them automatically.
If you haven't set up project memory yet, start a session and run:
remember: always check for existing tests before modifying a moduleIt writes that to .lac-memory.json in your project root. From that point on, every plan in that project will include a test-check step for any module it's about to touch.
When to Use PlanMode vs. Just Running the Agent
I don't use PlanMode for everything. Small, contained tasks — "add a null check here", "rename this function", "write a quick utility" — I just let the agent run. The overhead of reviewing a plan isn't worth it for a one-file change.
But for anything that touches more than two or three files, crosses module boundaries, or involves deleting or restructuring something, PlanMode is worth the two extra minutes. The tasks where you most want to skip the planning step are usually the ones where skipping it costs you the most.
A good rule of thumb: if you'd want to explain your approach to a teammate before diving in, run /plan first.
A Practical Starting Point
If you haven't tried PlanMode yet, take whatever task you'd normally throw at lac agent today and prefix it with /plan. Read through what it proposes. Push back on one thing — even if you'd have let it slide. See how the revised plan looks.
After a few sessions it becomes second nature, and you'll find yourself catching problems at the plan stage that would have taken real effort to unwind after the fact.
Install or update lac-cli with:
pip install --upgrade lac-cliThen open a project and run lac agent to get started.