simalexan

The flat line problem: why your best engineers keep arguing about process

October 12th 2026. By lunchtime today my Claude Code sessions had run 77 agents, up to 19 of them at the same time. A lot of my day is now writing specs, reviewing what agents built, and deciding what they are allowed to do on their own.

This year we also changed how we build: AI pods. One engineer and one product person, two engineers at most.

Pods make Simon Wardley's pioneers, settlers and town planners easier to set up than ever. They also make one old problem a lot more expensive. I call it the flat line.

Your best engineers keep arguing about how much process is normal. They are both right, and that is exactly the problem.

01Monday, architecture review

One item on the agenda. Your largest customer's AI agents already use your MCP server to look things up. Now the customer wants those agents doing whole jobs inside your product, with nobody watching, and they want a pilot running next month. The renewal depends on it. Nobody in your market has shipped that yet. With Claude Code, one pod could have a first version running by Wednesday.

Four people react. Nobody is wrong, and nobody says no.

“Give me one podand two days.”“Where is thedesign doc?”“The customer needsan answer by Friday.”“My pods all deployin different ways.”?Pod engineerArchitectProduct managerEng managerYouwants to try itwants it provenwants a decisionwants one standard
The meeting Nobody in this room is being difficult. All four are right, about different kinds of work.

Three weeks later the customer has stopped asking. And every pod still deploys its own way.

Two problems in the same room, pointing in opposite directions. The new thing got too many rules. The routine thing got too few.

02So whose fault is it?

It is tempting to read all of this as character. The pod engineer is a cowboy, the manager is a process person, architecture review is slow, and the PM does not understand engineering.

What actually happened: one engineering rulebook was applied to two completely different kinds of work, and a single rulebook can only ever be right about one of them.

Too many rulesJust rightToo few rulesthe agent pilot diesone part of your orgdeploys run on judgement
The whole page One rulebook does all three of these at once, to different parts of the same org. The rest of this page shows which parts, why, and what to do about it.

So we start with the work your engineers actually did this week, then the problems you already have, and only then the idea that explains both.

03Sixteen things your people did this week

Nothing unusual. An ordinary week, sorted the way you already think about it: by who does it.

Product pods

  • Write the spec, then let Claude Code build it
  • Review the agents' pull requests
  • Fix bugs from support tickets, with an agent
  • Deploy through the pipeline

Engineering managers

  • Check delivery numbers and token spend
  • Run planning and the retro
  • Coach engineers on working with agents
  • Staff the pods and the on-call rota

Staff engineers & leadership

  • Design each core service
  • Agree the quarter's bets with product
  • Decide what agents may ship without a human, and why
  • Let customers' agents do whole jobs in the product

Platform pod

  • Build the agent setup every pod shares
  • Let agents run a whole roadmap unattended

SRE & IT

  • Patch servers and rotate secrets
  • Model APIs, cloud accounts, laptops, SSO

Hold on to this list. Everything below uses these sixteen and nothing else.

04Five things that keep happening

Here are five more you have probably said or heard this year.

design doc?

We had a good idea for a new kind of integration, and a pod had a first version working in two days. It went to architecture review, they asked for the design doc, and it quietly disappeared.

Nobody was against it. It still died.
PILOT

That agent workflow one pod built, the one everybody liked? Still that one pod's thing. Six months now.

It works. It just never became the normal way we do things.

Every pod writes its own CLAUDE.md and its own agent rules, and every pod has its own idea of what an agent may ship without a human.

We keep starting over instead of agreeing one way.
v5v1

The deploy pipeline is still being “improved”. It has been rewritten five times, twice by an agent.

Nobody should be thinking about this at all by now.

The same three people review every risky agent pull request and join every incident call, and they are exhausted.

And they are the ones who never complain.

All five have the same cause.

05Sort the same sixteen a different way

Now sort them by how new the thing still is to the world, not by who does it. Left: nobody has really figured it out yet. Right: you buy it and never think about it, like electricity. (If you map, these are Wardley's four stages of evolution.)

1 · Brand new

Nobody knows how yet (genesis)
  • Let customers' agents do whole jobs in the productStaff & leadership
  • Let agents run a whole roadmap unattendedPlatform pod

2 · We build our own

Everyone makes their own version (custom-built)
  • Decide what agents may ship without a human, and whyStaff & leadership
  • Design each core serviceStaff & leadership
  • Agree the quarter's bets with productStaff & leadership
  • Build the agent setup every pod sharesPlatform pod
  • Coach engineers on working with agentsEngineering managers

3 · The proven way

Already solved, so copy it (product)
  • Write the spec, then let Claude Code build itProduct pods
  • Review the agents' pull requestsProduct pods
  • Fix bugs from support tickets, with an agentProduct pods
  • Check delivery numbers and token spendEngineering managers
  • Run planning and the retroEngineering managers
  • Staff the pods and the on-call rotaEngineering managers

4 · Boring and cheap

It should just happen, every time (commodity)
  • Deploy through the pipelineProduct pods
  • Patch servers and rotate secretsSRE & IT
  • Model APIs, cloud accounts, laptops, SSOSRE & IT
brand newboring and cheap

Column 3 does not mean you buy all of it from a vendor. It means the method is already solved. The industry knows how a good review of an agent's pull request goes: an AI reviewer reads it first, and a person reads anything risky. So does your best engineer, and so does every competitor. Your job there is to copy the proven way exactly. (The tools behind it, Claude Code, the AI reviewer, the CI service and the pager, you do literally buy.)

Look at the small grey labels. Your product pods appear in two columns. Staff and leadership work appears in two. So do the platform pod and the managers. Four of your five groups sit in two columns, and the six things in column 3 are most of what your week actually looks like.

One word can sit in three columns at once. Take the word every engineer uses every day:

“Ship this to one customer, this week”

Column 1 · brand new
  • A one-off behind a flag, because of what you want to learn from them.
  • No rulebook can cover it. It is your judgement, and it should be.

“What an agent may ship without a human, and why”

Column 2 · we build our own
  • The framework: which risk level, which paths, who signs off.
  • Written down once, used by every pod, reviewed every quarter.

“Ship it the agreed way, through the pipeline”

Column 4 · boring and cheap
  • Strict and the same every time. Nobody gets an exception.
  • If a deploy needs a meeting, something is badly wrong.

Three different amounts of rulebook, for one word. If your org has a single answer to “how we ship”, it is wrong about two of these three.

06Now compare the two ends

Take one thing from the far left and one from the far right of that list, and ask the same five questions about both.

QuestionLetting agents run a whole roadmap unattendedDeploying through the pipeline
Has anyone done this before?A handful of teamsEvery engineering org there is
Will it look the same in six months?Certainly notIt had better
If it goes wrong on Tuesday?You throw away a branchCustomers notice before you do
Fastest way to make it betterTry five versions, drop fourAgree one way and stop touching it
Fastest way to ruin itAgree one way and stop touching itTry five versions, drop four

Read the last two rows. The same sentence appears on both sides, once as the cure and once as the poison.

07So each column needs a different amount of rules

Here are the four columns again, as four bars, with a few of your sixteen under each. A taller bar means: this needs more rules, more checking, more “do it exactly this way”. Nothing else is being measured.

strict rulesno rulesalmost no rulesone agreed waythe proven standardstrict rules, no surprises1 · Brand new2 · We build our own3 · The proven way4 · Boring and cheapcustomers' agents doing jobsunattended agent roadmapswhat agents may ship alonethe shared agent setupcoaching on agentsspec first, then Claude Codereviewing agent pull requestsdelivery and token numbersdeploying through the pipelinepatching and secretsmodel APIs and laptops
Picture 1 Nobody argues with this on its own. Deploying through the pipeline obviously needs stricter rules than building something nobody has built. The problem starts in the next picture.

08One rulebook, three ways to be wrong

“Our engineering culture” means one way of working for everybody. On the picture, that is one straight line drawn across all four bars.

Wherever a bar pokes above the line, that work has too few rules. Wherever there is empty space between the top of a bar and the line, that work has too many. The striped areas are the mistakes.

striped = the wrong amount of rules · the bigger the stripes, the worse it is for the personA. One loose rulebook: “we move fast, we trust our pods”the rulebookfitstoo few rulestoo few rulestoo few rulesAgents and deploys run on judgement. No two pods ship the same way.B. One middle rulebook: “we are professional, we follow the process”the rulebooktoo many rulesfitstoo few rulestoo few rulesThe comfortable one. New bets slow down, and the deploy pipeline is rewritten a fifth time.C. One strict rulebook: “we are serious, everything gets reviewed”the rulebooktoo many rulestoo many rulestoo many rulesfitsThe agent pilot meets an architecture review asking for the design doc, and dies politely.1 · Brand new2 · We build our own3 · The proven way4 · Boring and cheap
Picture 2 Three different engineering cultures, drawn the same way. In every one of them, one bar out of four fits and the other three are wrong, because the bars form a staircase and a rulebook is a straight line. There is no height that works.

A staircase cannot be covered by one straight line.

You can reorg twice, and the line will still be straight.

09Which is why you need three kinds of people

A person who is brilliant in column 1 will find column 4 suffocating. A person who runs column 4 perfectly will look at column 1 and see a mess.

The SRE who wants a runbook for everything is right, for their column. Mess costs money where they work, usually at 3am. The pod engineer who prototypes everything is right about theirs: mess is where their work happens. Swap them and you will have two difficult employees and no idea why.

Simon Wardley calls the three kinds of people pioneers, settlers and town planners.

Pioneers

Columns 1 and 2
  • Usually: you, on a brand-new bet · the pod engineer who prototypes everything · an R&D pod · the engineer who built their own agent workflow, and it worked
  • Great at: trying what nobody has tried
  • Normal for them: most attempts fail
  • Drives them mad: a template, an approval form, “wait for next planning”
  • Should own: customers' agents doing jobs, unattended agent roadmaps

Settlers

Columns 2 and 3
  • Usually: product pods on a growing product · tech leads · the platform pod · engineering managers
  • Great at: turning a mess into something that works the same way twice
  • Normal for them: version 2 is better than version 1
  • Drives them mad: half-finished things, and being made to freeze too early
  • Should own: what agents may ship alone, service design, the shared agent setup, coaching

Town planners

Columns 3 and 4
  • Usually: SRE · infrastructure and IT · security operations · build and release engineering
  • Great at: making it exact, cheap and invisible
  • Normal for them: the identical result every single time
  • Drives them mad: exceptions, surprises, “we will decide later”
  • Should own: the deploy pipeline, patching and secrets, model APIs and laptops

10Why AI pods make this easier than ever

Simon Wardley ran pioneers, settlers and town planners as small cells back in 2005. Most engineering orgs never did. A team of six or eight engineers held all three kinds of people and worked in all four columns, so changing the rules for one column meant changing them for the whole team.

AI pods change that. Ours are one engineer and one product person, two engineers at most, with agents doing much of the building. A pod is small enough to be one of the three groups: a pioneer pod, a settler pod or a town planner pod, each with the rules its column needs. Your pods probably still mix columns, like any team did. They do not have to.

The pods stay where they are, and the work moves. A pioneer pod finishes a first version. A settler pod takes it and makes it work for everyone. A town planner pod takes it from there and makes it cheap.

A team of eightits work spans every column1 · new2 · own3 · proven4 · boringone set of rules for all of itchange the rules for one column, and you change them for everyoneAI podsone or two engineers, one product person, agents1 · new2 · own3 · proven4 · boringthe work moves, the pods staysolid: a rulebook per columndashed: one rulebook
Picture 3 A team of eight held all four columns, so it got one set of rules. A pod is small enough to be one group in one column. The work moves from pod to pod, and the rulebook can finally be a staircase instead of a line.

Give each pod one column, and each column its own rules.

11And why the flat line costs more than ever

Agents multiply whatever the flat line gets wrong.

  • Too many rules on column 1: a pioneer pod with Claude Code can build three versions of the agent pilot while the architecture review is still waiting for a design doc nobody can write yet.
  • Too few rules on column 4: the same agents push far more changes through the pipeline than a team typing by hand ever did. By lunchtime today I had run up to 19 at the same time, on my own. A loose rulebook that held for people typing does not hold for that.
  • More pods, more mismatches: ten pods instead of two teams means ten places where the line can be wrong, and the rulebook is often the only thing they share.
  • The rules are code now: agent permissions, hooks and required checks. Make one shared settings file strict, and a pioneer pod's agents stop to ask before every command. Make it loose, and a town planner pod's agents can change the deploy pipeline without a single check.

The drift that section 13 shows got faster too. Two years ago, writing code with an agent was column 1. The surveys since then:

October 2025 · Sonar
25%of developers used AI agents regularly
39%more had tried them
State of Code survey, 1,149 developers
May to July 2026 · JetBrains
90%used AI coding agents at work every week
68%used them every day
Developer Ecosystem survey, more than 15,000 developers

Different surveys and different questions, but either way that is column 3.

Running several agents in parallel moved just as fast. I could not find a survey that counts it yet. The closest is a small one, where 65% of 40 engineers use two coding agents every day. Letting them run a whole roadmap unattended is today's column 1.

The model underneath is already column 4. You buy it by the token, like electricity, from a few suppliers big enough that one of them, Anthropic, is getting ready to go public.

12Why the pilot is still a pilot

This is complaint 2 from section 04.

Work moves to the next column when the next pod decides it is ready and takes it. The pod that built it never thinks it is ready, so the next pod has to overrule it.

That is an argument between people who want different things, and an argument is exactly what one shared culture is built to avoid. So it never happens, and the pilot stays a pilot while everyone says nice things about it.

With agents, a pioneer pod can produce a working pilot in days. If nobody owns the handover, pilots pile up faster than anyone can take them.

Three kinds of podswork moves because the next pod takes itPioneertries itSettlermakes it workTown plannermakes it cheaptakestakes“not ready, keep working on it”only an outsider will say thisTwo handovers, and each oneis an argument. On purpose.One culturethe same two handovers, gone“this is how we work here”one set of rules for everythinghandover 1 · gonehandover 2 · gonethe pilot is praised,then quietly left alonethe rules spread backwardsinto the new work, and kill itNobody is blocked. Nothing arrives either.
Picture 4 The difference between the two sides is two arrows. Take away the border between the pods and the work stops moving, because the border was the thing that moved it.

13And every year it gets worse

Your sixteen things do not stay in their columns. They drift to the right, at a speed the industry decides, and agents made that speed a lot higher. A rulebook written into CLAUDE.md files, hooks and required checks does not drift anywhere, and the agents keep following it long after the work has moved.

Each square below is one of the sixteen. Watch them move right while the line stays where it was.

1 · Brand new2 · We build our own3 · The proven way4 · Boring and cheapyour rulebook was written for this sideeverything to the right of the line is run with the wrong rulesToday9 of 16 on the wrong sideIn a year11 of 16 on the wrong sideIn two years13 of 16 on the wrong side
Picture 5 Nothing moved to the left. Nothing ever does. This used to take a decade. Writing code with an agent went from column 1 to column 3 in about two years. The bill comes all at once, usually the year someone turns the thing you built by hand into a service you can buy.

14And it feels wonderful the whole time

One shared culture makes the numbers you already collect look excellent. They are accurate, and they cannot see this problem.

What you measureWhat you seeShows the problem?
Code shipped per engineer, with agentsBetter than everNo
Engineers staying on the teamVery goodNo
Engagement surveyVery goodNo
Arguments in design reviewsAlmost noneNo
People feel safe asking for helpVery goodNo
People feel safe disagreeing out loudLow, and nobody asksYes
Revenue from products you did not have 3 years agoAlmost zeroYes
Pilots that became the normal way of workingNoneYes
Processes and tools you retired last yearZeroYes
How much depends on the same few peopleAlmost everythingYes

When everyone agrees in every review, look for the handover that never happened.

15In practice: the same sixteen things

Back to where we started. The whole idea, applied to your own list.

ColumnYour thingsWho should own itWhat good looks likeWhat kills it
1 · Brand newCustomers' agents doing whole jobs · unattended agent roadmapsPioneer podsThree attempts, two fail, you know within a monthAsking for the design doc
2 · We build our ownWhat agents may ship without a human · each core service's design · the quarter's bets · the shared agent setup · coaching on agentsSettler podsOne version, written down once, used by every podLetting every pod invent its own again
3 · The proven waySpec first, then Claude Code · reviewing agent pull requests · bug fixes · delivery and token numbers · planning and the retro · staffing pods and on-callSettler podsEvery pod does it the same proven way, and stops redesigning itRedesigning review or on-call “because we are special”
4 · Boring and cheapDeploying through the pipeline · patching and secrets · model APIs, cloud accounts, laptops, SSOTown planner podsIt runs, it is cheap, you never think about itStill “improving” it every year

Read the last column down. Three of those four are complaints 1, 3 and 4 from section 04, and each one now has a cause you can do something about.

16What this does for the people

Put someone in the wrong column and you turn a good engineer into a difficult one, and they feel it before you do.

In their own columnPioneer in column 1Settler in column 2Town planner in column 4energy goes into the new betfinishes it, everyone uses itquiet, exact, nothing changesIn somebody else's columnPioneer put on column 4Settler told to freeze at v1Town planner put on column 1the energy goes into fighting the formnever allowed to finish it properlynothing to hold on to, no answer exists
Picture 6 The same three people with the same abilities, in two different placements. Nobody here became lazy, rigid or sloppy. They were put where their instincts are wrong.

Rules take away the one thing pioneers are good at: finding out. Give them a pod in a column where nobody knows the answer yet, and the energy that went into rewriting the deploy pipeline a fifth time goes into the agent pilot instead.

The SRE who wants a runbook for everything is correct, for column 4, where a surprise is an outage. Put them on the agent pilot and they will ask for a design doc nobody can write yet, and they will be miserable doing it.

Pods make this impossible to hide. In a team of eight, one person in the wrong column gets carried by the others. In a pod of two, that person is half the pod.

And the Monday meeting in section 01 stops being about character. So does the engineer who waits for a task and says “Just tell me what to do”. That is the right request in column 4, where the task is known, and the wrong one in column 1, where nobody knows it yet. Show the whole team this page, and the engineer who wants a task and the pioneer who hates being given one will both recognise themselves.

Nobody has to be told they are “resistant to change” or “not detail-oriented” ever again.

↳What to do on Monday

  1. Find out who is who. Before anything else. For each person on your team, which of the three are they? Do not guess from their title. Ask them what a bad week looks like. “Nobody told me what was expected” and “I was not allowed to try anything” are two different people.
  2. Make your own version of section 05. One afternoon with your staff engineers, your managers and your real list of work.
  3. Give each pod one column, and each column its own rules. If a spike for the agent pilot and a change to the deploy pipeline go through the same review, you have one rulebook, whatever the org chart says.
  4. Let the receiving pod say when something is ready. Write down what “ready” means. Expect the pod that built it to complain. Do not settle it by getting everyone to agree.
  5. Write the agents' rules per column too. A pioneer pod's agents can try anything inside a sandbox with no production credentials. A town planner pod's agents get narrow permissions, hooks and required checks before anything reaches production.
  6. Find out who every process runs through. That is complaint 5 from section 04. In any other system you would call it a single point of failure.
  7. Start measuring the bottom five rows of the table in section 14. Especially the first: feeling safe to ask for help and feeling safe to disagree are two different things.

The Honest Assessment

Works best for:

  • Process fights that keep coming back: the same argument about reviews, approvals or RFCs, with the same people on the same sides every quarter.
  • Orgs that already work in small pods: the pod is the unit you place in a column, so the fix is a staffing decision instead of a reorg.
  • Orgs where most of the week is column 3 and 4 work: the few new bets suffocate under rules that were written for the pipeline.
  • Deciding what to stop: it shows which rules to remove, as well as which to add.

Struggles with:

  • Very small companies: when the same three people work in every column, there is nobody to split the work between.
  • On-call in a pod of two: a town planner pod of one or two engineers cannot carry a round-the-clock rota alone. Column 4 needs several pods, or a rota across them.
  • Agents blur the columns: a pioneer pod's prototype can look production-ready on day two. Calling it column 1 anyway takes discipline.
  • Placing the work: the picture assumes you know which column something is in. Agreeing on that is often the hardest conversation of all.
  • What one culture buys: people trust each other faster, new engineers learn quicker, fewer people leave. Those are real. The pictures only draw the price.
  • A class system: the moment pioneer pods look glamorous and town planner pods look like bureaucrats, three groups do more harm than good. All three are equally skilled and equally needed.
  • The bars are a drawing: “how many rules this needs” is not a number you can measure precisely. The bars make an idea visible, and that is all they do.

Before you add or remove a rule, ask which column the work is in.

The four columns (genesis, custom-built, product and commodity), the three kinds of people and the idea that each group takes work from the one before it come from Simon Wardley's work, published under CC BY-SA. The wording, the examples and any mistakes are mine.

Links:


What's your experience? Have you tried AI pods, or giving each column its own rules? Really curious what did work (and what didn't) for others. This landscape is constantly evolving, and I suspect there are and will be better approaches we haven't discovered yet.

Find me on X if you want to share your experiments or challenge my assumptions.