You're Not Losing Money on the Build. You're Losing It on the Estimate.

If you run a software agency, here is a number you already feel in your gut even if you have never put it on a spreadsheet: the difference between your good projects and your bad ones was usually decided before anyone opened an editor. Not in the build. In the estimate, the scope, and the agreement. Or the lack of one.

This is worth saying plainly because the entire industry conversation right now is about making the build faster, and for an agency, the build was rarely where the margin went to die.

Where the margin leaks

Walk the money backwards on a project that lost you margin, and it almost never traces to slow coding. It traces to a handful of upstream failures that are so familiar they've come to feel like the cost of doing business.

• You underquoted. The estimate was assembled under time pressure by someone senior who was guessing.
• The scope was ambiguous. What the client thought they were buying and what you thought you were selling quietly diverged.
• Requirements got reinterpreted somewhere between the person who sold the work and the person who built it.
• The change was never charged. The client asked for "just one more thing", and catching it, pricing it and having the awkward conversation was more friction than absorbing it.
• Analysis was done twice. Your developers redid work from the sales conversation, because none of it was written down in a form they could use.

Every one of those is a margin leak that happened upstream of the first commit.

AI coding tools do nothing for any of this. They speed up the one part that was already improving, and leave every upstream leak exactly where it was. You can generate the build at ten times the speed and still lose money on the project, because the project was underpriced, the scope was soft, and the change was never charged.

The estimate is a promise nobody kept a record of

Think about what an estimate is. It's the first version of the agreement between you and the client: a statement of what will be built, for how much, within what boundary. And in most agencies, it's produced once, in a proposal document, and then abandoned. The moment the project starts, the estimate stops being a living reference and becomes a PDF nobody opens again. Delivery works from tickets, the client works from memory, and the careful boundary you drew in the proposal is no longer anywhere the work can be held against.

So when scope creeps, and it always creeps, there's nothing to compare the creep against. The request to "also add SSO" doesn't register as out-of-scope, because the scope isn't present anywhere in the room where the work happens. It just becomes more work, absorbed silently, unpriced. Multiply that across a project and across a year and it is, quietly, most of your lost margin.

What it looks like when the agreement stays live

Now imagine the estimate didn't die at the proposal. Imagine it stayed connected to the delivery: the same boundary, the same scope, present and referenceable while the work happens. The client says, "we also need SSO." And instead of that vanishing into absorbed effort, the answer is immediate and specific: SSO wasn't in the approved scope; estimated impact three and a half days, twenty-one hundred euros; shall we raise a change request?

That single interaction is the difference between an agency that protects its margin and one that donates it. Not because anyone worked harder, but because the agreement was still alive at the moment the scope changed, so the change was visible, priceable, and chargeable instead of invisible and free. The change request stopped being an awkward conversation you avoid and became a normal, evidenced part of the work.

Estimate better. Win faster. Build from what was agreed.

This is the whole proposition for a software house, and it has almost nothing to do with the fashionable conversation about AI writing code. It's about the economics of your projects. Estimate more accurately and consistently, so you stop underquoting. Turn proposals around faster, so your senior people stop burning billable days assembling them by hand. Carry the agreed scope forward into delivery, so requirements don't get silently reinterpreted and rework doesn't quietly eat your hours. And catch every change against that scope, so the work you do gets paid for.

AI made the build cheaper. That helped your competitors exactly as much as it helped you, which means it helped nobody's margin in relative terms. The margin was always upstream: in the estimate, the scope, and the agreement. That's the part AI left untouched, and the part that decides whether a project makes you money. Fix the upstream, and the build getting cheaper finally shows up where you want it: in your margin, not just your velocity.