Sell the tailoring, not the suit

If a tailored suit cost the same as one off the peg, you would never buy off the peg. Why would you? One is cut to your shape. The other is cut for the average person, and you wear the bad fit.

Business software has always worked the other way round. Bespoke cost ten times the package, so companies bought the package and bent their business to fit it. The rules that made them different, the edge they had earned, got sanded down to match somebody else’s idea of their industry.

Agentic coding is ending that trade. The price gap between bespoke and packaged software is collapsing. When the tailored suit costs the same as the rack, the rack loses.

That much is becoming received wisdom. The interesting part is what it does to the people selling the suits.

The buyer’s side is the crowded take

The evidence that buyers have noticed is everywhere. Retool’s 2026 build versus buy report found that 35% of teams have already replaced SaaS tools with custom AI-built software, with every category under pressure. Klarna cut over 1,200 SaaS applications and built its own tools instead. Satya Nadella has predicted that business applications as a category collapse in the agent era.

So the buyer’s side is well covered. If bespoke is affordable, buy bespoke and keep your edge. I agree, and half the industry is writing that post.

The seller’s side is where the ground is actually moving, and almost nobody is writing about that.

The equation that kept services small

The standard playbook for a scalable software business goes like this. Find an unsolved niche, build a package, sell it many times. The marginal copy is nearly free. That is the whole appeal.

Services businesses, the firms that build bespoke, were the opposite. Revenue scaled with headcount, one to one. Every new project needed new engineers. Margins were capped by salaries and growth was capped by hiring. Conventional wisdom said you could build a good services firm, but never a scalable one.

That equation rested on one assumption. The cost of delivering software is the cost of engineering time, and that time is roughly constant per unit of software. Agentic coding just broke the assumption.

What we measured

We can speak to this directly, because we have measured it on paid client work.

Across a multi-phase build for an enterprise software client, delivered under a fixed day-rate MSA, our build work ran at three to four times conventional throughput. Not estimated. Measured, against monthly timesheets the client had already received and paid. One piece of work a conventional team would estimate at fifteen to twenty days was billed at under five.

The more interesting number is the second one. Coordination-bound work, the joint design sessions, sign-offs, and security reviews, compressed at only around 1.5 times. Meetings do not compress the way code does.

That second multiplier matters more than the first, because it tells you where the constraint went. Delivery is no longer paced by engineering hours. It is paced by human judgment, review, and coordination. We now size build plans in units of human verification, not developer effort, because verification is the scarce thing.

Pricing the multiplier

Measurement changes what you can promise.

On the next programme for the same client, we calibrated every estimate to the measured velocity rather than to conventional team estimating. Then we put our money behind it. Each phase is priced as an estimate plus a cap, billed on the days actually worked, with overrun beyond the cap absorbed by us. The caps are figures we know we can build to. The estimate is a statement of confidence, not a discount.

Read that commercial shape carefully, because it is the moment a services business starts to behave like a product business. We are underwriting bespoke delivery. You can only do that if the delivery model is measured, repeatable, and yours. The velocity is not a happy accident on one project. It is a priced asset.

But is it just one good consultant

There’s an obvious objection. One excellent consultant on one engagement is a talent story, not a scaling story. Services firms have always had a star. Stars do not replicate, and that is exactly why services never scaled.

That’s a fair challenge, but not accurate.

Three of our consultants now deliver at this velocity. They work inside the same machinery, the design records, the gated pipelines, the security checks and code review that run on every push. But the evidence I keep coming back to is not a consultant at all.

One of our clients hired a summer intern, a university student in the early stages of an IT degree, and asked us to mentor him and involve him in our projects for them. He is a special talent, inexperienced but sharp, curious, and quick, the kind of person any engineering team would want. We taught him the process. At the start of the summer I wrote detailed specs, he built them, and I verified everything before merge. By the end of the summer he designs, I review the design, and for small changes he merges to staging himself. Larger changes still go through a pull request, and the gate between staging and production is the same one our senior engineers pass through. He has shipped a real engagement layer for a production expert system at the same velocity as the rest of us.

Talent explains how fast he learned. It does not explain how someone with no production experience shipped safely from week one, because that came from the machinery around him, the gates, the reviews, the staged trust. A star cannot be replicated. A process that carries even a gifted newcomer to senior delivery velocity in one summer is, by definition, replicable. The velocity does not live in the person. It lives in the process.

The tailoring is the product

Put the pieces together. Buyers are moving to bespoke because the price gap has closed. Sellers can now measure their velocity, price it, underwrite it, and teach it. Revenue no longer scales one to one with headcount. The old reason services could not scale is gone.

So what is the scalable software product of the next decade? Not another package. The delivery process itself. The design records, the gates, the calibrated estimates, the staged trust that lets a newcomer earn autonomy on evidence. Lovable and Replit built the surface layer, prompt in, app out. The governed middle, the process that lets a business trust what got built, is wide open.

The package era sold software the way the high street sells suits, cut for the average person, and businesses wore the bad fit for decades. That era is closing. The code is becoming the cheap part. What stays scarce, and what the winners will sell, is the fitting, a delivery process that is measured, priced, and proven.

Sell the tailoring, not the suit.