Devin Local has three working modes - Ask, Plan and Normal - and they are most often chosen wrongly: by the scale of the task. "A big task means straight to Normal so it does the work", "a small one, also Normal, nothing to plan here". Scale, however, is not the axis by which to choose a mode at all, and swapping the axis is the root of most stumbles at the start.
The naive logic ties the mode to size and to impatience. Since the goal is clear to me, it must be clear to the agent - I switch to Normal and wait for the diff. Ask and Plan, seen this way, look like a delay: an extra conversation before the work that one wants to skip. It is exactly this impatience that triggers the most expensive scenario - execution while uncertainty is unresolved.
It breaks on the fact that the modes are laid out not by scale but by the level of the unknown. Ask - when you need to understand without touching the code: the agent answers, points to places in the code, names risks, but does not act. Plan - when the architecture or the area is unclear: the agent runs a read-only investigation and offers an agreed plan. Normal - when the goal is clear and it can be executed: the output is a diff, commands and verification. The axis is one - how much in the task is still unclear - and the mode reflects it. The scale can be anything: a tiny edit in an unfamiliar module honestly starts with Ask, while a large but thoroughly clear task starts straight with Normal.
Let us fold this into a table so the choice takes a second. Below are three rows: the mode, the situation in which it fits, and the output expected from it. You return to the table before starting, to name the mode deliberately rather than by the inertia of "I always work in Normal".
Separately, one should distinguish agent mode from permission mode: these are different axes, and they are constantly confused. The mode sets the kind of work - understand, plan, execute. The permission mode sets how freely the agent acts without approval, through deny, ask and allow rules. You can be in Normal with a cautious permission policy and in Plan with no write risk at all. In practice these are two knobs turned independently: one answers "what the agent should do now", the other "what it is allowed to do without you". The common complaint "I switched the mode and it still asks for confirmation" is almost always about turning the wrong knob: the kind of work changed while the permissions stayed the same. To mix them is to argue about freedom of action where the question was about the kind of work.
Plan has a documented mechanism worth knowing. The investigation runs read-only, and its result is saved as a Markdown file at the path ~/.devin/plans/plan-<session>.md - the plan can be read, edited and carried into the next session. The keywords megaplan, ultraplan and masterplan in the prompt switch the session into Plan and ask it to plan markedly more thoroughly; and a good plan begins with at least one clarifying question rather than an immediate list of steps.
| Mode | When | Expected output |
|---|---|---|
| Ask | Need to understand, no actions | An answer, code references, risks |
| Plan | Architecture or area unclear | Investigation and an agreed plan |
| Normal | Goal is clear, ready to execute | A diff, commands and verification |
The cost of the wrong mode is asymmetric, and that changes the default strategy. Erring toward Ask or Plan is cheap: you spent a few minutes on reading and agreeing, but the code is untouched, there is nothing to roll back. Erring toward Normal is expensive: the agent has already made edits against a misread goal, and now you must sort out the diff, roll it back and re-explain. When the costs of errors are unequal, it is reasonable to lean to the cheap side until the unknown is resolved.
Hence the natural move - to step up through the modes rather than start at the ceiling. While the area is foggy it is reasonable to begin with Ask or Plan and move to Normal once the goal is defined and the plan agreed. This is not bureaucracy: the saved plan becomes context for execution, and Normal receives not a raw wording but a verified route. Moving in both directions is normal: if already in Normal it surfaces that the area was understood wrongly, it is cheaper to return to Plan and rewrite the route than to fix the consequences of executing against a wrong map. Lowering uncertainty in Plan pays for itself in speed and precision in Normal.
You can check that the mode was chosen correctly by whether the output matches the expectation. From Ask you expect understanding and a list of risks - if a diff appeared instead, the mode was wrong. From Plan - an investigation and a plan, not ready-made edits. From Normal - a diff with commands and verification, not a discourse on approaches. A mismatch between output and mode is the first signal that the task was sent through the wrong door.
The typical failures come down to one thing - impatience. Normal on an unclear task gives a confidently made wrong thing. An eternal Ask on a clear one gives endless discussion instead of a result. Plan with not a single clarifying question gives a beautiful plan past the real goal. The sign of all of them is the same: the mode was chosen by the mood "I want to see code already", not by how much of the task remained unknown. Name the level of uncertainty first, and the mode chooses itself.