I’ve written four opinion pieces in my Lab about how software gets built now, and said a version of this on LinkedIn. Building got cheap. Choosing what to build, checking it and standing behind it didn’t.
I think that changes how a company is organised, from the gates to the hiring to where the money is made. Here’s the list of what I see coming.
1. Decision gates stop being where work waits
I’ve said on LinkedIn that I see organisations choked out at decision gates, with engineering teams trying to contain change. The gate I’d keep is a different one: code for anything a script can decide, a person for anything that cannot be undone, and a model for neither.
Someone has to design that graph: where the gates are, who approves what, and what a run may spend (Who to hire now). A run needs a budget, because a run that can’t stop can spend without limit (What gets cheap, and what doesn’t).
2. “Done” gets defined before anything is built
Before, whoever wrote the code decided when it was done. Now the first skill is writing the checks, then building until code says they pass (Who to hire now).
It’s also what lets work run in parallel: a test suite tells each worker what correct means without asking a neighbour (More people, more agents, same plan).
3. Checking becomes the work, and every check leaves a receipt
Most of a diff may have no colleague behind it now, so read it as if someone else wrote it. Don’t let the model grade itself either. A model asked whether its own work is finished tends to say yes.
Nothing ships through my loop without a receipt for this exact content: a record that a named check passed. In What gets cheap, and what doesn’t I go further. I think receipts are what a guarantee is made of.
4. The SDLC compresses
This one is my view from LinkedIn. The SDLC, its pipelines and its processes are thinning out, and I think they’ll compress far enough that, looking back, they’ll seem to have evaporated.
When the right workflows make fast and steady possible, slow and steady stops being a choice.
5. Work gets partitioned before anyone is added
Fred Brooks argued in 1975 that people and months trade freely only when the work splits into pieces that need no communication. His law: “Adding manpower to a late software project makes it later.” He called it an oversimplification himself.
My claim in More people, more agents, same plan: adding workers, human or AI, speeds a project up only as far as its plan lets the pieces run without talking to each other. The lever is the plan, not the headcount. Cut the work along the seams you want, keep one place that checks the pieces together, then hire.
From More people, more agents, same plan: the same eight made-up tasks, partitioned (done at tick 2) and tangled (done at tick 4, with two pairs editing one file at once).
6. Teams get smaller
Between n workers who all have to stay in step there are n(n−1)/2 paths. Two people have one. Ten have 45. Fifty have 1,225. Agents add paths the same way people do (More people, more agents, same plan).
Vendor data from QSM, which sells estimation tools, found teams of five or more roughly three to four times as costly as teams of four or fewer. Those are finished projects, not an experiment, so I don’t read it as proof that size causes the cost.
The team I’d want is a small pod where both people can hold the whole product in their heads. That’s my recommendation, not an industry standard (Who to hire now).
From More people, more agents, same plan: the paths between n workers, n(n−1)/2. Five people, ten paths.
From Who to hire now: what it does to the team.
7. Memory has to be written down
Before, what a team knew could live in people’s heads. Now an agent starts every session knowing only what’s written down, so writing it down is part of the work (Who to hire now).
The vendor design in Attention is the bottleneck calls long-term memory its main bottleneck after months of running. I haven’t tested that, and it’s the part I’d trust least.
8. Attention becomes the scarce thing, and someone has to guard it
As models need less step-by-step help, the limit moves off the model and onto the people who follow the work (Attention is the bottleneck). A vendor’s design for an always-on agent, from the DeepSeek Harness account on X, has one router talk to people while workers do the work, and interrupts people only for a decision or sign-off.
Asking puts a person on every held call, which is a cost of its own. So the person goes at the step that can’t be undone, and the rest runs without asking.
From Attention is the bottleneck: interrupt people only for a decision.
9. The job becomes deciding what not to build
The cost of writing code used to do the deciding: only the clear cases got built. Now an agent will build almost anything you ask for in an afternoon, so the scarce skill is judgement about what to build. And above all, what not to build (Who to hire now).
I think of it as build versus buy, carried down to every feature, every script and every agent. A company should focus on the core of its business, and attention is the thing it has least of. Spending it on the core is the point (Attention is the bottleneck).
10. Hiring looks for judgement, not output
The six traits I’d hire for are mostly on this list already: write the checks first, read generated work closely, write things down, place the gates, cut the plan, and test a vendor’s claims on your own work (Who to hire now).
The first test I’d put in a hiring loop: a feature request that shouldn’t be built. See whether they say so, and what they’d use instead.
11. Pedigree may become a liability
I think pedigree can be a liability now. Businesses built on software needs were structured around execution being the hard part, and a pedigree earned as a strong executor was proof of strength at exactly that.
The profile in Who to hire now is that structure’s hire. Writing the code was the scarce work, so you hired people who produce a lot of correct code, and to grow the team you added more of them. In More people, more agents, same plan I call the root of that a mistake: measuring work in one number, so that doubling the workers halves the time.
Execution is the part getting cheap. In What gets cheap, and what doesn’t I argue the cost doesn’t vanish, it moves to what stays expensive, and someone still has to be accountable for the work.
So a strong executor isn’t definitely strong in the new way of building. They might be. It just isn’t a given. On LinkedIn I called it a moat of rote knowledge drying up.
I wouldn’t take a strong record of execution as the answer. I’d test the judgement.
From Who to hire now: what mattered before.
12. Managers flip the mindset that execution is the expensive part
My view from LinkedIn: executives and managers who are oriented around execution being the expensive, slow part of the process will have to flip that completely. I honestly wonder how many will manage it.
When execution gets cheap, the cost moves to what stays expensive, and I think that’s guaranteeing the work (What gets cheap, and what doesn’t).
13. A rift opens, and gatekeepers can’t hold the line
Also from LinkedIn, and also my view. A rift is forming between people who seem to get it and people who don’t. I haven’t determined whether that’s a personality or brain difference, or something people can adapt to.
And I don’t think gatekeepers and political empire builders inside organisations will be able to contain the people who command agentic workflows.
14. The margin moves to guaranteeing the work
If building and running the first version gets cheap, the cost doesn’t vanish. It moves to what stays expensive. I think that’s guaranteeing the work, with a contracted SLA, and service contracts for continuous updates and security, and that these become the profit margins (What gets cheap, and what doesn’t).
A model can produce the answer, but someone still has to be accountable for it. Some software stays worth paying a specialist for.
Where I could be wrong
This is my opinion, and I haven’t run an experiment to prove it.
The case for many agents is real. Anthropic reported, about its own research system (vendor data), that a lead agent with parallel subagents beat a single agent by 90.2% on its internal evaluation. It was partitioned first, so I read it as support. You could read it the other way.
My platform-team page collects evidence that AI does not clearly make developers faster. My harness page reports a team that runs with few blocking gates, against my case for them.
Dan Luu argues, in an essay, that cheap building means people can attempt projects they once ruled out. I say build only what’s core; I think cheap building makes that question matter more, not less. And cheap execution could bring the margin down everywhere, or move it somewhere I haven’t listed.







