A workday with Devin is easy to picture as a chat: you phrase a task, send it to the agent, read the answer, ask for more if needed. While the tasks are small this model holds, and that is exactly why it quietly becomes a habit. But a day assembled from such chats leaves behind not verified work but a stack of dialogues, in each of which the final word was said by the agent, not by the tests. The sign that the day has slipped into this rut is simple: you remember what the agent wrote, but you cannot name the command you checked it with.
The naive move is understandable and logical in its own way: the agent answers coherently and confidently, its message looks like a result, and you want to stop there. From this grows the habit of judging readiness by the text of the answer - "the agent says the tests pass", "the agent says the refactor is safe". One big prompt at the start, a quick glance at the answer at the end, and the task is considered closed. The interface does not discourage this: it shows confident prose where a diff is needed.
It breaks on the distinction between the message and the artifact. The agent's message is a claim about the work, not the work itself; the verifiable state lives in files, in a diff, in a test run and in a branch, not in the chat text. As soon as a task stops being a one-liner, the gap between "the agent said" and "the repository holds" turns into a source of quiet regressions: edits in the wrong branch, unrelated files touched, tests that "pass" in a retelling but were never run.
The professional mechanism closes this gap by unrolling the day into a repeatable ten-step loop, where each step is responsible for one thing. Frame: name the goal, the scope, the acceptance criterion and the acceptable risk. Baseline: fix the starting point - git is clean, build and tests are in a known state, known failures are recorded. Choose: pick a surface - Command, Devin Local, Cloud or ACP. Inspect: remove the unknown through Ask or Plan and get a confirmed cause rather than a guess. Isolate: move the work into a separate branch or worktree with minimal permissions.
The second half of the loop is about execution and its closing. Execute: run the work in small reviewable turns, not in one leap. Verify: check from a targeted test to a broader one and then to a manual scenario. Review: read the diff and run an independent Quick Review, noting residual risks. Integrate: commit or PR under human approval and protected checks. Learn: move useful knowledge into AGENTS.md, a rule or a skill, and clear the rest from the context. The ten steps are not bureaucracy but the same arc that runs through the whole book: name the surface, take the minimal power, prove the result.
Why the loop is exactly this and not shorter. Each of its steps removes one class of error that is otherwise caught at merge or in production. Frame and Baseline keep you from mistaking "it got better" for "it got different". Choose and Isolate bound the radius: a narrow surface and a separate worktree keep the cost of a mistake small. Verify and Review separate the claimed result from the actual one. Learn keeps you from explaining the same thing to the agent twice. Remove any step and its work will have to be done later and at a higher price.
The cost of the loop is discipline and time up front, and it is a fair trade. Frame and Baseline take minutes before the first turn, Isolate requires creating a branch before anything changes. It seems to slow you down; in fact it moves the cost from the end, where you untangle a mixed diff and guess what broke, to the beginning, where everything is still cheap. For a one-line edit the loop collapses to its essence: Frame in one phrase, Command, read the diff, commit. The full unrolling is needed where the task is multi-step and the radius of error is real.
The definition of done fixes how the loop ends. The result is not the agent's message but a verified artifact in a managed branch, with known risks and a reproducible verification command. This definition is deliberately strict: it does not accept "the agent says it is done" for done. Until there is a branch you can show, a command you can repeat, and a list of risks you accepted explicitly, the task is not closed, however confident the last answer sounds.
You should check that the day was lived correctly by the trace it left. Every closed task has a branch or a PR, a reproducible verification command and explicitly accepted risks. The Learn step leaves a separate trace: what you had to explain to the agent either turned into a durable instruction in AGENTS.md or a rule, or into an on-demand skill, or was deliberately discarded. If by the end of the day the context is bloated with one-off explanations that were parked nowhere, tomorrow you will have to give them again.
The typical failures of the loop are recognizable. Judging by the agent's message rather than by the diff and the tests - and taking a retelling for a check. Skipping Baseline - and failing to tell your own regression from someone else's failure that was there before you. Skipping Isolate - and running multi-step work in the active branch, untangling a mixed diff afterward. Skipping Learn - and explaining the same thing in every new session. The sign of all of them is the same: at the end of the task there is no artifact you can show and repeat. Start with Frame and Baseline, end with Verify and Review, and most of these failures will not happen.