Something remarkable happened to software in the last few years: the marginal cost of producing it collapsed. A working demo that once took a team a quarter now takes an afternoon. Anyone can build. The industry is still deciding what this means; institutions are already finding out.
Because here is what we see when ungoverned, AI-generated systems arrive for review — polished interfaces, plausible flows, genuinely impressive velocity — and underneath the paint, the same five absences, nearly every time:
- No row-level security — any authenticated user can read any record, including every citizen’s.
- No field-level control — identifiers, salaries and medical fields exposed to whoever can see the row.
- No audit trail — actions leave no evidence behind, which in an institution means they officially never happened.
- Secrets in the source — credentials shipped in plain sight, sometimes committed to public repositories.
- No architecture — a one-off nobody can maintain, extend, or in some cases even redeploy.
None of this is the model’s fault. Generation optimises for the visible — the screen, the flow, the demo. Governance is precisely the part of a system that does not appear on screen. It is what stops the screen from showing the wrong thing to the wrong person, and nobody claps for that in a demo.
The false choice
So institutions are being offered two paths. The old one: build it the slow way — twenty months, millions per system, locked to the vendor, obsolete on arrival. The new one: generate it the fast way — twenty minutes to a demo, no governance model, security as an afterthought, broken behind the paint. A risk for a business; a liability for a government.
The mistake is treating speed and governance as a trade-off. They are only a trade-off when governance is something a developer must remember to add — because anything that depends on remembering will eventually be forgotten, and generation forgets at scale.
Governance has to be a property, not a practice
The way out is architectural. Put a kernel beneath everything — row- and field-level security, audit, and a compiler boundary that only admits governed queries — and make generation target that kernel. Then AI can draft as fast as it likes: whatever it produces compiles through the same boundary as human work, inherits the same security, lands on the same audit trail. You cannot ship an ungoverned app, not because a policy forbids it, but because the platform has no path that produces one.
That inversion — from “governance as diligence” to “governance as construction” — is what lets an institution take the speed without taking the liability. Modern speed, engineered governance. Both, or neither; the era has made the middle disappear.