who-signs-for-the-code-nobody-wrote.md

2026-10-17 | 10 min read

Who Signs for the Code Nobody Wrote?

AISoftware DeliveryLiabilityContractsEngineering Management

Two paid layers and a merge button. The only line that carries money is still blank.

A rounding bug ships in a payment path. An AI wrote it. An AI reviewer approved it. A human clicked merge, because the diff was green, it was forty files long, and it was Thursday afternoon. Three weeks later the client’s accountant notices the money is short. Now: who pays?

Walk the supply chain upward; the walk is the whole article.

The developer? Followed the process the company gave them. The software house? Signed a contract with warranties and a cap, and will carry it. The AI reviewer? Provided “as is”. The AI that wrote the code? Same, plus a clause telling you not to treat its output as a source of truth. The model provider? Capped at what you paid in the last six or twelve months.

The liability evaporates at every step except the last one — and nobody I talk to has repriced to reflect it.

Now notice who used to sit at that far end of the chain. A contractor. A freelancer, a nearshore team, another software house — the last link, the one actually touching the keyboard. And that link was the most thoroughly covered party in the whole arrangement. They signed back-to-back terms, they carried their own professional indemnity, often because we made it a condition of the purchase order. If they broke something expensive, there was a named company with a contract and a policy behind it.

That is the link AI replaced. It is the first supplier in the history of this industry to sit at the end of the chain and carry nothing at all — and we swapped it in for the one party that was reliably insured.

Every cap upstream is measured in subscription fees. The one at the bottom of the stack is measured in the client's damages — and it is the only one a court will look at.

What a client actually buys

Here is what the “AI makes software cheaper” thesis forgets.

Companies do not outsource software, or buy SaaS, PaaS, IaaS or any XaaS, because they cannot write code. Most employ developers. They do it to buy one sentence:

For this money you get this, working, reliable to this degree — and if it isn’t, that’s on us.

That sentence is what the money is for. Across my career, that transfer of accountability — not the typing — has been the main cost of a software solution.

AI compresses the typing. Dramatically; I use it every day. It does not touch the sentence. So why should the price collapse?

Two paid layers, zero liability transferred

You pay a vendor to generate code, “as is”. You pay a second one to review it, also “as is”. Two paid layers, and the risk that moved off your balance sheet is zero.

Cursor’s terms put it plainly [2]:

“YOU AGREE THAT ANY USE OF SUGGESTIONS FROM OUR SERVICE IS AT YOUR SOLE RISK AND YOU WILL NOT RELY ON ANY SUGGESTION AS A SOURCE OF TRUTH.”

Anthropic’s commercial terms disclaim warranty of any kind on services and outputs, say outputs are not warranted accurate, complete or error-free, and cap liability at twelve months of fees [1]. Cursor’s cap is the greater of six months of fees or $100 [2].

Notice what they do indemnify. Anthropic will defend you against third-party claims that your paid use, or its outputs, infringes intellectual property — and that obligation sits outside the cap [1]. IP risk: covered, potentially uncapped. Functional risk: capped at what you paid.

The industry has decided, contractually, that “this might be somebody else’s code” is worth underwriting and “this might not work” is not.

What a pull request actually was

The objection is that review catches this. But a PR was never a reliable bug filter; bugs got through PRs for thirty years. Anyone claiming theirs caught the serious ones has not read their incident history.

What a PR was is a ritual of ownership. A named person looked, and from that moment the team stood behind it. It converted “the code says so” into “we say so” — an accountability primitive, not a quality one. That is what AI review removes while appearing to replace it.

The PR passed. The accountability didn’t.

The counter-argument, steelmanned

A LinkedIn thread gave me the sharpest possible pushback, paraphrased rather than quoted: guarantees never existed, not even a human is a guarantee, we just personify responsibility so there is someone to look at.

The second half is correct, and it is the problem rather than the answer. We personify responsibility because that is the mechanism, not a bug in it. A named, insurable party is what makes risk priceable. You cannot write a premium against a vibe; you can write one against a team with a process, a review step and an indemnity policy.

Remove the person and you have not removed the risk. You removed the price tag.

Guarantees were never about human infallibility

They were contracts. “Guarantees never existed” only sounds true if you have never read the civil code you invoice from.

Czech Civil Code § 2615(1): “Dílo má vadu, neodpovídá-li smlouvě.” A work is defective if it does not conform to the contract [11]. Slovak Commercial Code § 560(1) says the same [12]. The standard is conformity with the contract — not best effort, not “a human looked at it”, not “the AI wrote it”.

A real warranty exists for one reason: somebody declared it. Czech § 2113 makes one arise from the declaration of the party giving it [11]; Slovak § 429 requires a written undertaking [12]. Nobody in the AI supply chain declares one.

It worked because the risk was priceable: people, process, review, insurance. An underwriter could put a number on a team. That is what broke.

Warranty-free in, full warranty out

That is the shape of it, and it is entirely legal. An intermediary can promise more than it received from its own supplier; in B2B that is normal, not exceptional. The problem is economic: the house carries tail risk that nobody below it covers and that neither it nor its insurer can price.

An intermediary may legally promise more than it was given — in B2B that is the norm, not an abuse. The problem is not that it is allowed. The problem is that nobody has priced it.

The asymmetry sharpens once choice of law enters. A US-law tool ToS caps the vendor at six or twelve months of fees, or $100 [1][2]. Slovak § 386(1): a damages claim cannot be waived in advance of the breach it might arise from, and the court may not reduce damages [12]. Czech § 2898 disregards an advance limitation of the duty to compensate where harm is caused intentionally or by gross negligence [11].

Which raises a question I cannot answer: is merging code that nobody competent read gross negligence?

I am asking, not asserting; it has not been litigated as far as I know. But if it ever comes back yes, every liability cap signed in the last two years is worth less than its paper.

The money question the narrative skips

In early 2025 Sam Altman wrote on X: “insane thing: we are currently losing money on openai pro subscriptions! people use it much more than we expected” [3]. In October 2026 Anthropic reported $16.8 billion of Q3 revenue and told investors it had reached profitability in the quarter on an adjusted basis, on an 85% gross margin — adjusted, investor-presentation figures, not audited [4].

The point is not that AI vendors are broke; that is no longer true. The point is that vendor economics moved an enormous distance in eighteen months and the warranty position moved not at all. Whatever the subscription costs next year, the liability it carries is still zero.

So if the cost of generation keeps changing and the cost of accountability does not, which is really the bottleneck in your price?

Volume is not the same as throughput

The 2025 DORA report is the most useful thing I have read here, because it refuses to pick a side. Adoption among software development professionals is at 90%, up 14 points year over year; developers spend a median of two hours a day with AI tools; only 24% report substantial trust in it [6]. The headline finding: “higher AI adoption is associated with an increase in both software delivery throughput and software delivery instability” [5].

Both. At once. Faster and shakier.

Veracode ran 80 coding tasks across 100+ models and found an OWASP Top 10 vulnerability in 45% of the AI-generated samples [7].

One aside on how thin the ground is. The METR trial everybody quoted — experienced developers measured 19% slower with AI — has been retired by its own authors, who say it is outdated and their newer results unreliable [8]. Treat every productivity number you hear, mine included, with suspicion.

What survives: you can produce far more volume with AI on top of developers, but every unit still has to be stood behind by someone. One named person can own a change they understood. Forty? Four hundred? Where does that stop scaling?

The insurers will decide this before the philosophers do

While engineers argue about agency and authorship, the people whose job is pricing risk have started: they cannot price it yet.

Great American, Chubb and W.R. Berkley have asked US regulators to let them exclude AI-related liabilities from corporate policies. AIG was named in the original Financial Times reporting but says it is not pursuing them — which matters, and I will not flatten it. One underwriter called AI model outputs “too much of a black box”. The stated fear is not any single claim but correlated loss: thousands at once when one widely deployed model fails. Regulators had not decided at the time of reporting [9].

Direction of travel, honestly bounded

The EU has moved on one half of the question. Directive (EU) 2024/2853 defines “product” to include software outright, and Recital 13 says a producer of software — “including AI system providers within the meaning of Regulation (EU) 2024/1689” — should be treated as a manufacturer. Transposition is due by 9 December 2026 [10]: seven weeks from today.

Now the honest limit, because this gets overclaimed. Article 6 restricts compensable damage to death or personal injury, property damage except property used exclusively for professional purposes, and corruption of data not used for professional purposes [10]. It will not pay your client’s lost revenue from a broken integration. It signals where the EU is going — software is a product, AI providers are manufacturers — for harm to people. It does not touch the B2B gap.

The real question

Nobody is asking whether someone is accountable. Someone is. The question is whether they know it, and whether it’s in the price.

What happens after the first large damages

My expectation, stated as expectation and not fact: there won’t be an ethics debate. There will be contract amendments.

Carve-outs for AI-generated code in delivery contracts. Exclusions or premium loadings for AI-assisted delivery in indemnity policies. Clients demanding disclosure of AI use in a supplier’s process. Repricing of the deals that look most attractive today — fixed-price and warranty-heavy. None of it needs new law; it needs one expensive loss and a renewal date.

What to do Monday morning

Audit the gap between what you sign and what you can verify. If verification shrank this year while your warranties did not, you moved your risk position without deciding to.
Ask your insurer, in writing, whether AI-generated code is covered. In writing, because a phone call is not a coverage position. Before renewal, not after an incident.
Make human review a named, priced accountability step, not a rubber stamp after the AI reviewer. A person, a scope they can hold, and the time to hold it.
Price AI-assisted risk explicitly. Pass productivity gains 1:1 into lower prices and you converted margin into uninsured liability and called it competitiveness.
Volunteer transparency about AI use before someone demands it. A clause you wrote beats one your underwriter writes for you.

Meanwhile, in the hole in the ground

There is one more party in this supply chain, and it is the quietest: the people who write the rules.

What I see from them is groundbreaking ceremonies. A minister in a borrowed hard hat, a shovel, a pit that will one day be a datacenter, a press release with a gigawatt figure and a jobs number in it. Those photographs are easy to take. Everybody in the frame is on the right side of progress and nobody has to answer anything.

The questions underneath are harder, and nobody is queuing up to be photographed answering them. Who is liable when the output of a statistical model lands in a payment path? Does an advance liability cap survive conduct a court might later call gross negligence? Is a supplier obliged to disclose that a deliverable was machine-generated? If the insurers now asking to exclude AI from corporate policies get their way, who carries that risk — the supplier, the client, or nobody at all until a court decides?

The EU answered one half of one of these, and credit where it is due: software is a product, AI providers are manufacturers, harm to people is compensable. It took years, and it stops at the factory gate of the commercial contract. Everything a B2B client actually loses money on sits outside it.

Here is the part that bothers me most. We are pouring concrete for the compute and nobody has priced the liability of what the compute produces. That is the sequence the whole industry has agreed to run: build first, and let the accountability question resolve itself retroactively, in court, after somebody’s loss. It is reckless gambling on the output of a mathematical model, dressed as infrastructure policy, and the invoice for it will not arrive at a ministry. It will arrive at a software house.

So we will find out the way industries always find out — one loss big enough to litigate, then rules written in a hurry by people who have never signed a delivery contract in their lives. I would much rather it happened in the other order. I do not expect it to.

Conclusion

I am not anti-AI. I build with it every day and would not go back. This is about pricing risk, not rejecting tools.

Accountability does not disappear. It becomes unpriced. And unpriced risk always gets repriced eventually — usually at the worst possible moment, by someone who is not you.

So: how does your contract handle AI-generated code today? Have you asked your insurer?

I am not writing this from a solved position. We handle it — there is wording in the contract, there is a review step with a name attached, and somebody owns every delivery. I still would not claim we have it right. We are working this out in the open like everyone else: re-reading our own terms, asking questions we did not have to ask three years ago, and changing the answer when it turns out to be wrong. My day job is WANTED.solutions, a platform and DevOps partner, which means we sign the sentence at the top of this article for a living. It is not a thought experiment for us.

What I would genuinely like is to hear how you handle it — especially if you have already had the conversation with an underwriter, or already lost the argument with a client. Tell me what you learned and I will update what I think.

I am an engineer and the owner of a software company — the party that signs these contracts, not the party that charges you to read them. The CZ, SK and EU references above are pointers for a conversation with someone qualified; your jurisdiction, choice of law and contract wording decide what actually applies to you.

References

← cd ../blog/