I built the machine and I direct it

An assistant answers one question at a time and drags the whole previous context along with it. That is fine for a single doubt. It does not stand up a module. I cut the work into phases — survey the ground, fix the contract, write, review, harden — and each phase goes out as a closed assignment to subagents that share no memory with one another. What they share is the only thing that matters: the contract they come in under and the contract they have to leave under.

Splitting it this way buys quality before it buys speed. An agent with a narrow assignment and a fixed output shape is wrong less often than one with permission to do anything. That is exactly the principle behind the tool surface of the PÍDELO agent: eight tools named one by one, each with its own job, and no open console anywhere.

Parallelism arrives afterward, as a consequence. Phases that do not depend on each other go out at once; phases that do take the previous contract as their input. Where that cut falls is mine to decide, and it is the decision that changes the outcome of the whole job more than any other: what enters a phase crooked leaves it crooked several agents later.

A structured output is a schema: the fields the agent has to return, the type of each one, which are required, and what values they accept. It is not a polite request buried in a prompt; it is a shape that gets validated on arrival. Inside my products that is Zod checking what the model answered before any of it reaches a person. Inside the harness it is the same mechanism, pointed at the deliverable of a phase.

Why a validated schema beats a well-written instruction: the instruction is a hope and the schema is a condition. A flawless prompt fails quietly — the agent hands back something that resembles the request, and the mistake surfaces several phases downstream, already braided into other work. A schema fails loudly and fails now, at the edge, while fixing it is still cheap.

When something does not fit, I neither patch it by hand nor wave it through. It goes back to the agent with the validation error as input, and if it misses a second time the conclusion is that the contract is written wrong, not the agent. It usually is: I asked for two things in one field, or left a case unnamed. A field that admits two readings always gets read the wrong way.

An agent reviewing its own work approves it. So every result that matters goes to critics whose only assignment is to refute it: find the case that breaks it, the assumption nobody wrote down, the error path nobody walked. I am not asking them for an opinion. I am asking for an accusation, with evidence and with the exact line where the problem sits.

I run them from stated, different perspectives, because a generic critic files generic complaints. One looks at correctness. One looks at limits and edge cases. One asks whether this survives six months of maintenance. One asks whether it already exists somewhere else in the repository. Each of them ships under the same kind of contract it is reviewing.

Letting the majority decide is not democracy, it is a noise filter. A model on its own hallucinates defects with the same confidence it hallucinates successes; when three different perspectives land on the same line, the odds that it is noise drop sharply. Whatever only one of them flags, I read myself before anything moves: the majority filters the noise, but the final call is not something I hand out.

A principle that does not break the build erodes. Nobody repeals it: it gets skipped once under deadline, copied twice without thinking, and three months later it is the house style. The only way I know to make an architecture decision outlive the month is to turn it into something executable and put it in the path of the build, where nobody gets to negotiate with it.

This site carries its own, and they fail for real. check-rhythm keeps the home page from stacking two bursts back to back. check-dry forbids a class recipe from living outside its single source. check-design-tokens blows up when a raw color shows up where a token belongs. check-translations compares both language branches and refuses a difference in shape. There are more, and every one has a command name.

The side effect is the one I was after. An agent told the rules in prose can forget them; an agent whose work will not compile if it breaks them cannot. A guard is not only quality control: it is how the swarm gets taught without me repeating myself in every assignment. A rule that executes never has to be argued a second time.

A swarm does not decide what to build. It does not know whether the person standing at the counter will read that screen, whether charging commission is worth it, or which part of the product should be killed. Product judgment, the limits of the business, and what I owe the person who will actually use this: I keep all of it, and I hand out none of it.

It is also the wrong tool for the indivisible, thorny piece: a race condition, money math that has to balance to the cent, a migration over live data. There I stop distributing, shut the agents down, and do it by hand and slowly. Spotting that moment early is half the method; the other half is not pretending the swarm was going to solve it.

And the cost is real. Writing the contract takes longer than writing the task, the critics burn tokens and time, and some days reviewing what comes back costs more than having done it once myself. Directing agents is neither free nor automatic. It pays off when the work can be cut apart and when what ships has to survive years in production. When it cannot, it is an expensive detour.