The agent runs. The code appears. The feature is not what I wanted.
Not because the model was wrong. Because I was vague.
Speed Was Never the Moat
Before AI could write a single line of code, the best engineers were not the fastest ones.
They were the ones who thought first.
The engineer who paused long enough to understand the system, the constraints, the consequences, consistently shipped better work than the engineer who started typing first.
Speed was the byproduct of clarity.
The ones who skipped the thinking phase did not save time. They silently redirected it into debugging, rework, and escalations nobody had scheduled for.
AI did not change this. It amplified it.
A senior once taught me: Every complex task started with pseudocode that never shipped. By the time coding started, I had already solved the problem I needed to build. Those documents were never the output. The preparation was.
The discipline that managed it was never new.
The Architect Did Not Build. The Architect Made Building Possible.
I picked up a clean refactor not long ago. A couple of backend endpoints that had become legacy over time, god classes built up through delayed maintenance. The project already had rules and instructions in place. Patterns documented, constraints named, architectural decisions recorded.
The refactor ran clean. Manual testing surfaced one issue: a status mismatch on a response from a newly introduced feature that was not yet documented in the code. That was the full extent of the friction.
The difference between that refactor and the React Native incident I described in the previous article, where the agent implemented a plan correctly and the plan itself was wrong, was not capability. It was context. One project had a contract. The other did not.
Every project that shipped well had someone building that context before a decision was locked in. Not the fastest coder. The one who understood the system as a living structure: existing patterns, load-bearing decisions already made, consequences that travel downstream.
The right moment to catch a structural mistake is before the first line of code. Not in a review after the tenth.
That part has a name in this workflow, the first step: Think.
Capability Is Not the Bottleneck. Ambiguity Is.
The agent is not too slow. It is not too limited. It does not lack capability.
It lacks direction.
I noticed the pattern on the tasks that touch the most files. Performance optimisation. A third-party service integration that reflects behaviour across several endpoints. Underperforming routes moved to a Redis cache. The agent did not struggle with any of them. It moved confidently, thoroughly, and in the wrong direction.
Feed an AI agent a vague prompt and it does not return silence. It returns something confident, coherent, and pointed at the wrong target. The agent fills ambiguity with inference. It makes decisions I did not know I was delegating. It assumes the shape of the feature from the words I chose, not from the system I built.
The gap is not between what the agent knows and what I needed. The gap is between what the agent received and what I actually meant.
The interesting question is not "can the agent write this code?" The better question is "have I given the agent something precise enough that it cannot misread the direction?"
Those are not the same question. Most engineers answer the first one and wonder where the week went.
The Architect Persona: Gather Direction, Not Just Code
At the Think phase, the agent takes on a specific role.
Not implementer. Architect.
Its job is not to generate. Its job is to understand.
It reads the codebase. It maps what exists. It surfaces existing patterns so the feature does not reinvent what the system already decided. It separates what I stated from what the codebase implies. It flags what is known and what is not.
It does not proceed on a guess when a decision belongs to me.
By the time Think ends, the agent has not written a single line of production code.
The architect persona is not a mindset I sustain through discipline. It is a structured phase, and it runs as a skill.
What it produces is the brief.
The Brief Is How I Aim the Hammer
The brief is the first artifact of this workflow.
It is not a ticket. It is not a prompt. It is not a description of what I want.
It is a specification of direction, written precisely enough that the agent cannot misread it.
What goes in it.
Intent. Not "add a filter to the dashboard." The outcome the user achieves and the system condition that changes. Vague intent is how the agent builds the right-looking wrong thing.
Constraints. Technical limits and architectural decisions already made upstream. They define the edge of the work before it begins.
What the codebase already knows. If the pattern exists somewhere in the system, the brief names it. The agent does not invent a solution the codebase already has.
Explicit unknowns. Two kinds: assumptions the agent can safely proceed on, and open questions that belong to me, marked blocking or non-blocking. The agent does not guess either way. It surfaces them and waits.
Definition of done. Not a feeling. A condition the agent can verify.
Hammer the exact spot.
A craftsman strikes metal at precisely the right point.
Not harder. Not faster. Exact.
The masterpiece is not a product of force. It is a product of aim.
That is what the brief produces. A single concentrated point of direction. The Think phase does not add steps to the workflow. It removes the steps that appear later when direction was absent.
It hammers the exact spot.
Direction Is Not the Route
The brief tells the agent where to aim. It does not tell the agent the order of the blows.
That belongs to the Plan phase.
The Think phase does not complete when I feel ready. It completes when the brief is specific enough that an agent working from it cannot misread the direction.
That is a higher bar than it sounds. It is also the bar the Plan phase builds on.
A key takeaway:
This is not a template I built for this article. It is the skill I run at the start of every feature.
The
thinkskill classifies the task, separates explicit from implicit requirements, and marks open questions as blocking or non-blocking. It enforces an exit condition before Plan begins and produces the brief as a versioned artifact.Download it, Give it to your agent, Drop it into your first task. Read what it produces before the agent continues.
The brief it generates is proof that Think ran.
