For fifty years, building software required software developers. That constraint shaped everything: which projects got funded, how long they took, who had a say in the design, and — most importantly — what never got built at all because the cost was too high or the timeline too long.
That constraint is lifting. Not gradually — discontinuously. The shift isn't that development is getting 20% cheaper. It's that entire categories of software that were never worth commissioning can now be built in hours by people who don't write code.
A CFO who needs a board-ready reporting dashboard. An operations lead who needs a workflow tool. A founder with a product idea and a weekend. These people have always known what they needed. They've never had a viable path to getting it built — until now.
The question that matters
The natural first question — "can AI build software?" — has been answered. It can. The proof points are abundant and growing. The more interesting question is the second one:
Can it build software that's safe to deploy, honest about its limitations, and better next time than it was this time?
This is the question of governance. Not governance as bureaucracy — nobody wants approval committees for a two-hour build. Governance as a structural property: does the system verify what it produced? Does it grade itself honestly? Does it learn from its own work?
These questions matter because the people who will benefit most from autonomous development are the ones least equipped to evaluate the output themselves. A developer can read the code and spot the security vulnerability. A CFO reading the same output sees a working dashboard and assumes it's safe. The governance layer exists to protect that CFO.
What compounds
The most interesting property of governed autonomous development isn't the speed — though the speed is real. It's the compounding.
Every build produces lessons alongside the software: failure patterns that are tracked and avoided next time, domain-specific insights that accumulate across projects, architectural decisions that become institutional knowledge. After fifty builds, the platform has 174 learned patterns. The fifty-first build benefits from all of them.
This changes the economics in a way that's worth understanding. Traditional software development has roughly constant marginal cost — the hundredth feature costs about the same as the first. A learning platform has decreasing marginal cost: each build makes the platform more capable, which makes the next build cheaper, faster, and more architecturally sound.
The data corpus that accumulates through governed builds — the patterns, the failure modes, the domain insights — is the asset. Not the code. The code is the output. The intelligence is the infrastructure.
Intent as input
We've been exploring what happens when the barrier to input drops as far as it can go.
A 300-word description of a personal health intelligence concept — no technical specification, no design brief, no wireframes — produced 4,161 lines of working code in 41 minutes. The platform chose the technology stack, designed the analytical engine, generated realistic test data, and produced a user interface. It drew on biomedical domain knowledge autonomously: correlating medication timing with vital sign changes, evaluating supplement efficacy against actual lab markers.
A detailed 992-line specification — written collaboratively, with explicit acceptance criteria — produced a 26,669-line production application in two overnight builds. Complete with row-level security, audit trail, and 11 integrated modules.
Both approaches work. The governance layer — quality verification, failure tracking, transparent grading — operates the same way regardless of input detail. That's what makes the shorter input safe. It's not reckless when the system catches its own mistakes.
What we're building toward
The endpoint is not "faster coding." The endpoint is: anyone who can describe what they need can get production-quality software built for them, with the same quality controls that a senior engineering team would provide.
That's a large claim. We're not there yet. But we've shipped 100s of builds across multiple (often deeply technical) domains — all autonomously, all with zero human-written code, all governed by quality gates and honest grading.
The platform gets better with every build. The governance gets tighter. The domain knowledge deepens. And the people who can access production-grade software — people who couldn't before, because the cost was too high or the process was too complex — that group grows.
That's what we think matters.
Oscar is the founder of orch.build. oscar@interstice-advisory.com