Nobody who puts up a house smelts their own aluminium. They don't cure the concrete in the garden either, or wire the alarm, or run the pipes. They pick from a catalogue, compare certificates, haggle price against spec, and hire someone who knows how to fit it all together without it coming down. The bigger and more delicate the building, the more different hands come in: architect, clerk of works, the services engineer, the fire engineer, the inspector.

Well, that, more and more, is the shape of software. And AI doesn't contradict it: it speeds it up.

The programmer who banged out everything from scratch died a while back, though nobody ran an obituary. Nobody writes their own encryption anymore, or their own template engine, or their own password system. npm, PyPI, Maven: supplier catalogues, by that name and that function. Any project bolts together a few hundred parts made by others, nearly all by strangers, nearly all free. What AI does isn't manufacture new materials. It sinks the price of assembly. The line item that collapses isn't the brick: it's the hand that lays it. And when the cost of building falls in a trade, everything else rearranges itself around that.

They say AI turns anyone into a programmer. It's a poor description. What it does is put an infinitely cheap contractor in your hand. And you, standing in front of him, are not the bricklayer or the architect. You're the developer.

The developer has an awkward catch: he can order whatever he likes, but what he gets back is worth exactly what the two things he can't delegate are worth. Knowing what to ask for. And knowing whether what they hand him stands up. Without those two, a cheap contractor isn't an advantage: it's a fast, cheap way to build something expensive and useless.

So the bottleneck moves. It used to be labour that was scarce, writing the code; now it's judgment. AI isn't a floor that lifts us all equally. It's a multiplier. On good judgment, it compounds. On bad judgment, it lets you go wrong faster and with an immaculate README. So the gap between the one who knows and the one who doesn't, instead of closing, widens. Exactly the opposite of what the democratization brochure promised.

And here it's worth stopping, because every good comparison has a limit, and this one has it in a spot that explains almost everything. On site, gravity rules. What's miscalculated falls, and falls soon, and is seen to fall: physics runs you a merciless integration test the same day. In software there's no gravity. A dreadful architecture can hold up for five years and bill beautifully all the while, and the cost arrives later, diffuse, charged to someone else's budget and probably another team's.

That's the crux of it. Construction became a serious trade because its errors killed people visibly, with a first and last name. Software never quite got there, because its errors are almost never seen and can't be pinned on anyone, however enormous the total bill.

And for that very reason, with the code AI writes today, you have to be honest: it's too early to pass sentence. It's been standing a year, two at most, and its real bill, the one that in software always arrives late, hasn't come due yet. I wouldn't call it a win just yet. I want to see that code five years on, after a few migrations, with the one who knew how it worked already at another company.

And on top of that, a house gets finished and software doesn't. A building decays slowly and politely: the physics of concrete doesn't ship a new version every season. Software rots because what's around it changes: a dependency that breaks, a hole that shows up, an API that shuts, a system that drops support. It's a house put up in a city where they revise the laws of physics every six months. Maintenance isn't a small line in the budget: it's the line, and it never ends.

And what do you do when the client asks you to move the kitchen up to the third floor with the concrete already set? On site, you tell him to get lost. In software it's asked every Tuesday, and rightly: it's a feature, not a defect. The client discovers what they need exactly when they see what they asked for up and running. AI makes that change cheaper still. Which pushes the trade away from the closed project, not toward it. Anyone who tries to import the discipline of the signed blueprint without getting this will repeat, to the letter, the failure of the old waterfall.

And one more, the one that keeps anyone who looks closely up at night. A bad batch of beams messes up the sites that bought it. A flaw in a widely used library blows up every building on the planet at once. Log4Shell, the xz backdoor. Construction has a redundancy that saves it, because nobody trucks concrete a thousand kilometres; software leans the other way, toward monoculture, one same foundation under half the world, often held up by two volunteers who don't earn a penny.

And who wins out of all this? The one who verifies. When banging out the code costs next to nothing, my hunch is the real work starts afterwards: proving the thing works and doesn't blow up when nobody's watching. Reviewing what someone else wrote and finding the test that breaks it stops being second-rate work. There's also tracing where each part came from. It's the clerk of works, the one who certifies that what got built matches what was drawn, and he moves to the centre of the site. It's exactly where I left you last time: arming the reader.

And the architect rises too, more than it looks, though with a wrinkle of the trade. In software the architecture almost never gets designed right up front: it's discovered by building. So the architect worth having isn't the one who signs a complete blueprint. It's the one who knows when to demolish: when what works has stopped being the right shape and has to be redone before the cost turns structural. That's another skill, hard to teach and pretty scarce.

One weak doubt remains: if AI generates bespoke code, why keep pulling in third-party parts? Because the value of a dependency was never the code. It was the shared maintenance and the audited trust. A certified brick is worth more than an identical uncertified one, and the open source to come will compete on reliability and traceability, not on features.

(There's also a rung we're sawing off without noticing: the apprentice's, the junior who came up banging out the boring work the machine now does. But that's a story of its own, and I owe it to you another day.)

The most important thing is still missing, and it isn't technology. Construction didn't become a serious trade just by learning to size beams: it needed insurance, inspectors, mandatory codes by level of risk, and, above all, a name to point at when the beam came down. Software never had any of that. Every licence, from the MIT to the seven-figure ERP contract, carries the same clause in capitals: AS IS. Just so. No warranty. No liability. The most critical industry of the modern economy went up saying that, if the thing burned, it was nobody's fault. In capitals, mind.

And it's starting to crack, not because the trade suddenly grew a conscience, but because the EU Cyber Resilience Act forces the maker to show their face. With the obligation comes the bill of materials: the certificate for the batch of concrete, carried over to software. CE marking for code. What began as a handy metaphor is turning literal by way of the official gazette.

Because when the labourer who laid the brick is a statistical model, the question of who answers stops swallowing the reply the industry has been giving in capitals for fifty years. The gravity that physics gave the building site, the law is starting to give software. And I reckon you can already see who's going to have to sign. About time.