Build the thing that fits

For most of software's history, building was the expensive part. Writing it, wiring it together, keeping it alive — all of it took scarce, costly engineering. So most enterprises didn't build. They bought something generic and then spent years, and fortunes, bending their organisation to fit the tool, or bending the tool to fit their organisation through a standing army of integrators, consultants, customisations, and support contracts. That arithmetic has changed. With AI agents doing the writing, the wiring, and increasingly the maintenance, the thing that used to be prohibitively expensive — software shaped to your exact operation — is now within reach. Which forces an old question back into the open.

What was software ever for — to solve a problem, or to sell a relationship you maintain forever?

The bargain nobody actually chose

Because building was expensive, a bargain formed, and everyone accepted it. You bought a platform built for the median company. It didn't quite fit — it never could — so you bought the integration project to connect it, the customisation to reshape it, the managed service to run it, and the tiers of support to answer for it when it broke. Layer by layer, the software you licensed to solve a problem became a permanent apparatus you had to feed. The tool became a relationship. The relationship became an annuity — for the vendor.

Silos, and the tax on the seams

The clearest symptom is the silo. Every department bought the best tool for its slice, and now the enterprise runs on dozens of systems that don't speak to each other — bridged by spreadsheets, by people re-keying data from one screen into another, by integration middleware that is itself another thing to license and maintain. The connective tissue between systems is the part that actually matters, because your business lives in the seams. It was also always the hardest and most expensive thing to build, so mostly it never got built. Agents change that. Wrapping an API, reconciling two schemas, standing up the workflow that spans four systems: this is exactly the work that has become cheap. The integration tax was a function of build cost, and build cost fell.

Software that manages itself — or that you can

Here is the part that should reset expectations. The L1, L2, L3 support pyramid is not a law of nature. It exists because software is generic, opaque, and not yours: generic, so it does things you never needed in ways you can't change; opaque, so when it misbehaves no one on your side can see why; not yours, so every real fix has to route through someone else's queue. Software built for your operation, observable end to end, and increasingly able to diagnose and repair itself, collapses that pyramid. Most tickets exist only to translate between a generic system and a specific reality. Remove the mismatch and most of them are never filed.

Software you built for you, and that stays with you — not software you rent and forever escalate.

The goal was always to solve the problem

Strip away the industry that grew up around software and the original purpose is almost embarrassingly simple: solve a problem, well enough that it stays solved. Somewhere the incentives drifted, and solved-and-forgotten became a worse business than sold-and-supported. Seats, tiers, professional services, renewals — the machine came to reward software that needs you more over time, not less. Building your own inverts the incentive. When the software is yours, every problem it stops causing is pure gain, not lost revenue. It is allowed, finally, to just work.

What not to build

This is not a case for building everything. Genuine commodities — email, the ledger, the plumbing every company runs the same way — should still be bought; there is no edge in a bespoke inbox. The discipline is knowing the difference. Build the parts that are yours: the workflows that encode how you actually operate, the connective tissue between your systems, the judgement your people have that your tools don't. Buy the parts that are truly the same for everyone. And be honest that building isn't free of maintenance — it changes who holds the wheel. The work doesn't vanish; it moves from feeding a vendor's roadmap to shaping your own, with agents now carrying far more of the load than they used to.

Build, and keep what you build

So: build. Build the thing that fits — that combines your silos, wraps your systems, and becomes something your people actually experience as one. Build it observable, so you can watch how it works. Build it to sit on your stack and learn from your real work, so it improves as it runs. And build it to be yours — software that solves the problem and then stays with you, quietly, instead of joining the queue of things you manage. The cost of building has fallen far enough that this is no longer the ambitious option. It is the obvious one.