One model per role, with just enough intelligence
Spec-driven development with less human in the loop: each step becomes a role, served by the minimum intelligence that does the job. The developer becomes product owner and settles early who validates what.
- Category
- Note
- Published
- Reading time
- 4 min read
- Topics
- Software engineering
- Tags
- #agents#llm#models#governance#specs
TranslationTranslated by AI from the original in French.Read the original
Competition between freelancers and client expectations push for more output. A freelancer doesn't have to bend to AI: they can make it converge on their own practices and know-how. To reduce the human's share of the loop, the first step is to copy the stages of continuous development: specify, break down, code, test, review, decide, maintain. What changes is who holds each stage.
If agents are the developers, the natural framework is spec-driven development. You discuss the specs at length, add the context of the domain, the partnerships and the methods, then derive the user stories, tasks and tests from them. The developer no longer types every line, but spots vague requirements and missed cases: they become a product owner with an engineering background. This orchestrator stance keeps what makes the job enjoyable: understanding the problem, deciding, building.
Addy Osmani sums up the split: agents can own the inner loop, where you investigate, code, test and report, but humans keep the outer loop, the one of decisions and accountability. A single expensive model for everything costs too much; a single cheap model misses what takes thinking.
Each role gets the cheapest model that does the job correctly.
Each step becomes a roleLink to this section
The loop works through the tasks one by one, runs some in parallel, and waits when it has to. Claude Code already chains a good part of this work within a single session; separating the roles is the harness's job, the topic of the next post.
Three tiers of models, and a decision modelLink to this section
I think in three tiers, valid with any provider, or mixing them: frontier models, second-tier models, and lighter models. At Anthropic, today these are Fable, Opus and Sonnet; the names will change, the logic won't.
Roles that take thinking, such as writing the specs or reviewing the code, benefit from a frontier model, with a high rather than maximum reasoning effort. The code can go to a cheaper second-tier model. For small, well-defined tasks, a lighter model is enough.
Decisions don't need text. Choosing what comes next, judging a risk, accepting or rejecting: a decision model such as Jev, from TypeSafe, returns a typed choice with a confidence score directly, without going through an LLM that generates JSON. A general-purpose AI coordinates the agents, under human supervision.
Compliance sometimes narrows the choice: if the client requires an attested service, as in the post on verification, what's left is mostly open models.
A long loop that runs without the developerLink to this section
An agent loop takes time. The developer checks in on it without waiting for a slow model to finish its answer, and the developer experience has to follow that pace.
With my subscription, I use Claude Code cloud sessions, and other providers offer the equivalent. Claude clones the repository into its own VM, takes ownership of the code, contributes and commits. On a client's code, that VM at the provider needs the same client consent as any LLM. I follow it and steer it from the mobile app.
These agents need the relevant knowledge and the session history, with nothing local: the computer must be able to shut down. Rather than handing them my own credentials while I sleep, a secrets manager issues them, per task, short-lived access scoped to the data they need.
From my machine, I steer these agents through a main agent: costs, permissions, shared credentials. Giving each agent its own account, a programmable wallet with spending caps or a decentralised identity, allows fine-grained control over its permissions and budget.
Who decides whatLink to this section
The level of validation depends on the severity of a potential problem and the impact of the change.
These classes are defined early: you identify where a check is needed, set its level with the client, then enforce it in code, with permissions, credentials and merge rights. A rule that exists only in a document relies on everyone's goodwill.
Osmani proposes an "accountability contract" per codebase: the checks agreed for a change, the evidence the decision rests on, and the person who answers for it. That is what the client must be able to review. The classes also address what he calls the orchestration tax: human attention doesn't scale with the agents. The more precise they are, the less the developer reviews what doesn't need it, and the less cognitive debt they accumulate.
Classes of changes in the repositoryLink to this section
Without a fleet of agents, I start by listing the project's types of change and, for each, who validates: the agent alone, me, or the client. A CODEOWNERS file records them in the repository:
# .github/CODEOWNERS
* @me
/infra/ @client/ops
/src/payments/ @client/tech-leads
A protected branch that requires code owner review enforces it. It's a basic solution: it only covers code review, file by file. A real project usually needs a more complete permission system, on the data itself: who, human or agent, can read or modify what, and with what validation, as in the post on context.
Next post: the harness, and why it's better not to overdo it.