The five archetypes of AI engineering

Watch an AI coding agent work and you notice it has exactly one speed. It writes the first version of everything with the same confidence, whether you asked it to sketch a throwaway idea or harden the code that takes payments. It rarely asks what you meant. It almost never stops to confirm the thing it just wrote actually runs. That single default setting is wrong far more often than it is right, and it is worth understanding why.

Boris Cherny, who built Claude Code, has a frame that makes the problem legible. He argues the old job titles are dissolving. Product, engineering, design, and data science are collapsing into five archetypes of building, and a strong team flows between them depending on what the moment needs. In his words:

As engineering, product, design, DS, etc. melt into a new kind of role... when I look at the Claude Code team I see what I think is five archetypes: Prototyper, Builder, Sweeper, Grower, and Maintainer.

Boris Cherny, creator of Claude Code

Each one is a genuinely different job, so it is worth stating them plainly:

• The Prototyper churns out brand-new ideas, lots of them, and most never ship. That is the point. Speed and coverage beat correctness, because the goal is to find the one idea worth building, not to build it well.
• The Builder takes a promising prototype and makes it real: production-grade product, real infrastructure, the parts that have to hold up when a stranger relies on them.
• The Sweeper cleans up. It simplifies the code, tightens the UI, unships features that never earned their place, and makes the slow thing fast. It deletes as readily as it adds.
• The Grower takes a built product and pushes it toward fit, iterating on what real users actually do until the product is the one people want.
• The Maintainer keeps a mature system secure, reliable, fast, and cheap to run at scale, long after the launch buzz is gone.

Cherny's second point is the part people skip, and it is about mix. A product before fit wants Prototypers, Builders, and Sweepers: explore hard, build the bets that survive, keep it lean. A product finding its market shifts to Builders, Sweepers, and Growers, with a Maintainer starting to matter. A product with strong fit leans on Sweepers, Growers, and Maintainers, with enough Builder left to keep shipping. The archetype is not welded to your job function. It is a response to where the work is.

An archetype is a value function, not a skill

Here is the move that makes this map so cleanly onto AI coding agents. An archetype is not really a skill. It is three things stacked together: a value function that decides what counts as good, a definition of done that decides when to stop, and a list of forbidden moves that says what you must not do even when you easily could.

A Prototyper's value function rewards speed and coverage. Done means the idea is clear enough to judge. The forbidden move is polishing something you are about to throw away. A Builder's value function rewards correctness and durability. Done means it runs, you have proven it, and someone else could depend on it. The forbidden move is shipping the first draft you typed without checking it. A Sweeper's value function rewards subtraction. Done means there is less of it and it still works. The forbidden move is adding a feature. Same person, same keyboard, completely different work, because the value function changed underneath it.

Your AI coding agent runs one value function, and it picked the wrong one

Now the diagnosis. Today's AI coding agents run a single implicit value function, and nobody chose it on purpose. Out of the box, an agent optimizes for producing output. It guesses what you meant instead of asking. It writes the most complete-looking version instead of the smallest one that works. It calls the job done the moment the code exists, before a single line has been run. It reaches for an abstraction, a config layer, a new dependency, where one plain line would have done the job.

Read that list again. Those are a Prototyper's instincts wearing a Builder's job. Fast, broad, never throws anything away, treats the first draft as the finished product. A degenerate Prototyper pretending to be a Builder is the exact recipe for slop: the gradient text, the eleven near-identical card components, the helper that wraps a native input for no reason, the cheerful "this should work" with nothing actually run. None of that is the model being stupid. It is the model running the wrong value function for the moment it is in.

This is also why "just add more agents" does not fix it. Ten agents all running the Prototyper value function give you ten times the slop, faster. Volume was never the bottleneck. Aim was.

The skill is matching the archetype to the moment

The unlock is not a bigger swarm of bots. It is telling the agent which archetype it is in, then holding it to that archetype's rules.

Explore like a Prototyper when the real question is what the thing should even be. Let it be fast, broad, and a little wrong. Generate five versions and throw four away on purpose. This is the one mode where the default behavior is actually correct, so use it deliberately instead of by accident.

Then switch. Commit like a Builder once you have picked the bet. A Builder asks before it assumes. It makes the smallest change that genuinely works, not the most impressive one it can imagine. It proves the thing runs, with its own eyes, before it says done. And it refuses to ship code that looks AI-made, because looking generated is a Builder failure, not a cosmetic afterthought.

Then sweep. When the build starts to bloat, become a Sweeper: delete the speculative abstraction, inline the helper used in exactly one place, cut fifty lines down to five. Less code that still works is the whole win.

That is the real skill of AI engineering. Not prompting harder, not running one mode forever and blaming the model for the mess that follows. It is knowing which archetype the moment calls for, and switching between them cleanly.

Building the Builder in

This is the bet behind kitstarter. The default agent is a Prototyper with no off switch, so we make it a Builder by default: ask before you build, make the smallest change that works, prove it runs, and don't look AI-made. Those are the rules a good Builder already carries in their head, written down where the agent will actually read them. When you genuinely want to explore, you still can. The difference is that the floor is now a Builder, instead of a Prototyper that forgot to stop.

The five archetypes are a sharp map of where building is heading. The people who get the most out of AI coding agents will be the ones who stop asking the agent to do every job in one mode, and start telling it which mode it is in.