Everyone has been using agents wrong.

Every few months there is a new way to use agents properly. A workflow. A methodology. A rule file. A team of agents with job titles. A loop that runs through the night. An approval prompt at every step.

Look closely, and they all do the same thing. Each one puts a procedure where a single question should be: what do you actually want?

"We write tests first. Now — what are you building?"

No agent says it that plainly, but most of them work in that order. The method is fixed before you say a word: when the tests are written, how the work is split, how many agents are spawned. Then your request arrives, and it is cut to fit. What fits is built. What does not fit is dropped, and no one notices it is gone.

The agent is not the problem

Agents already know how to work. They read a codebase, find their way around it, run the tests, and fix what breaks.

What has not changed is how they fail. They build what no one asked for. They settle questions no one asked you. They report work as done when it is not. You ask for an explanation, and your code has changed. You ask for a pricing page, and it comes with a free tier nobody mentioned. You ask whether it is finished, and it says yes, with half of it missing.

None of this comes from a lack of intelligence. A stronger model makes the same moves. The agent knows how to work. What it does not have is your intent, and no model upgrade will give it that. Your intent lives with you.

Process where a question should be

When you do not know what someone wants, you ask. The industry built process instead. Process is easy to ship: it runs the same way on every project, and it always looks like work is happening.

The questionnaire

Questions became a step in the procedure: a fixed list, asked in order, whatever the work.

Ask for a checkout flow. The agent asks which framework you use and which database, both answered by package.json. It does not ask what happens to a payment that fails halfway, or who is owed a refund. Those are not on the list. So the decision is made in silence, and you hear about it from a customer. The most dangerous question is the one never asked.

Test-first as law

Test-first puts the same ceremony on a config file and a payment rule.

A test is intent written as code. If the intent is wrong, writing the test first only writes it wrong twice. When one agent writes both the test and the code, the test proves only that the code does what the agent believed. A green run means the agent agrees with itself. And when a test will not pass, some agents simply rewrite the test.

Tests matter. A payment rule needs rigor; a config file does not. The work should decide which is which, not a rule written before the work existed.

The swarm

A PM agent writes the spec. An architect agent designs it. A developer agent builds it. A QA agent reviews it. It looks like a company. It is one model wearing four hats.

Not one of them knows what you want. Each guesses an unstated intent, and then they review each other's guesses. The tokens multiply, and the bill is reported as progress. Somewhere along the way, token burn became a number to be proud of.

Parallel work has its place. When the work genuinely splits, it is faster. Agents spawned to look busy are something else.

Approve, approve, approve

Agents ask in one of two ways: never, or about everything.

Never is how you get the free tier nobody asked for. Everything was meant to fix that. Now every file edit, every command, every plan, and every change to the plan waits on a prompt.

You read the first few. By the twentieth, you approve without reading. Almost no one reads a 300-line plan to the end before accepting it. At that point the prompts no longer protect you. When something breaks, all they leave behind is proof that you said yes. An agent that never asked would at least have left you someone to blame.

A question is read only when it is rare. Ask only what the user alone can decide, and the user will stop and think.

Process ages faster than models

These methods share one more thing. They were written before anyone saw your work, for whichever model was current at the time.

Weak models did better when the work was cut into steps, so it was cut into steps. They made mistakes, so rules were added. Every mistake became another line in the rule file, until the file was a record of old failures.

Then the next model arrives. Steps written for the last one start to get in the way, and the stronger model behaves worse. The model takes the blame. The setup is torn down and rebuilt. Then the next model arrives, and it happens again.

The workflow you run today becomes legacy the day the next model ships.

The method is not wrong. The order is.

This is not an argument against process. Tests, parallel work, human review, and written specs all have their place. What goes wrong is choosing them first.

Your intent should decide the method. Instead, the method decides your intent.

Once the intent is clear, the method follows from it. A payment rule calls for tests. A broad investigation calls for parallel agents. A decision that cannot be undone calls for a human. Fixing the method first is not rigor. It only means no one listened first.

Let the agent go, and it fails the other way. It fills every gap with a plausible guess and decides for itself what you meant. Three months later, no one can say why the code is the way it is. Hold it too tight, and you get process. Let it go, and you get guesses. Either way, your intent is lost.

The answer lies between the two. What the agent can find out, it finds out without asking. What is yours to decide, it never guesses. When the only alternative is a guess, it stops and asks, because the decision belongs to you, not because a procedure has a step for questions.

Using agents well

Agents will keep getting faster, and they will build more in less time. But no model, however capable, will know what you should be building. That stays with you. The faster the agent, the faster it builds the wrong thing.

More process will not fix that. What fixes it is an agent that asks you only what is yours to decide, and carries everything else to the end on its own. Then the result does not need second-guessing. Every decision that mattered was yours.

Using agents well comes down to one thing: making them ask the right question.