AI-Built Internal Software Is Going Feral
Somewhere this quarter, a procurement manager closed a tab instead of a deal. They'd been comparing three project-management platforms, none quite right, when someone on the team said: just have the coding agent build it. Two days later there was a working tool, shaped exactly like the team's actual workflow instead of some vendor's guess at it. Nobody filed a purchase order. Nobody signed a contract. This is AI-built internal software, and it is happening at a scale that should worry anyone who thought software was a product category.
The pitch is obvious: why rent a shape that almost fits when an agent can weld one that fits exactly? But exact fits have a cost nobody's pricing in yet. A tool built once by a vendor, sold to ten thousand customers, gets debugged ten thousand times over. A tool built once by an agent, for one team, gets debugged by that same agent, alone, forever. It never has to explain itself to another customer, another support forum, another competitor's teardown. It only has to keep working for the five people who asked for it. That's not a minor difference in scale. It's a different evolutionary pressure entirely, and it changes what the software becomes.
The Great Unbundling of Software
For thirty years, software converged. Everyone's CRM looked roughly like everyone else's CRM, because building your own was expensive and buying was cheap. That convergence is what let an entire industry exist: support docs, Stack Overflow threads, contractors who could walk into any company and recognize the stack in an afternoon. Shared software meant shared knowledge.
Coding agents flip the economics. Building custom is now cheap enough that buying is the thing that needs justifying. Once one team skips the purchase, others notice, and the skip becomes a habit, then a default. What gets lost isn't just vendor revenue. It's the common substrate — the fact that a piece of software, once built, used to get looked at by thousands of unrelated eyes. When nobody else will ever open the file, nobody else ever will catch what's wrong with it, or weird about it, or quietly evolving inside it.
This is where it stops being a build-versus-buy story and starts being a biology story. A species that only breeds within a closed population drifts. So does software that only ever gets read by the one agent that wrote it.
AI-Built Internal Software Doesn't Stay Put
Here's the part that doesn't show up in the productivity pitch: the tool doesn't stop changing once it ships. The same agent that built it keeps getting asked to patch it — a new field here, a workaround for an edge case there, a shortcut somebody needed for one weird Tuesday that never got removed. Each patch makes sense on its own. None of them get written down anywhere except as a diff.
Multiply that by a year of small asks and the tool has walked a long way from whatever it was on day one. Nobody planned the drift. Nobody's tracking it. The agent isn't rebelling or scheming — it's just doing what it's told, repeatedly, without the institutional memory a human team would eventually build up in comments, wikis, or the collective grumbling of engineers who've seen this pattern before. The tool becomes shaped by its own history in a way that's completely illegible to anyone who wasn't there for every step.
That's the sense in which AI-built internal software goes feral: not malicious, not broken, just unmoored from any spec a person could read and understand in one sitting. It works. It just doesn't explain itself anymore.
Digital Speciation, One Org at a Time
Speculative scenario: it's 2029, and a mid-sized logistics company is being acquired. The due-diligence team asks for documentation on the internal routing tool that every warehouse depends on. There isn't any — there's a nine-hundred-commit history of an agent responding to one Slack message after another, and a live system nobody can fully explain, including the people who use it every day. The acquiring company's engineers open the codebase like archaeologists opening a tomb. It's functional. It's also completely unlike any system they've worked with, because it was never meant to resemble anything else. It only ever had to resemble itself.
Now imagine that scenario repeated across a hundred thousand companies, each with its own agent-tended, never-open-sourced, never-benchmarked internal stack. That's not a marketplace of software anymore. It's an ecosystem of isolated islands, each one producing its own finches — the kind of divergence you'd expect from populations that never interbreed. Two companies solving the identical logistics problem end up with tools that don't just look different, they think differently, because two different multi-year conversations shaped them.
It's the inverse of the open-source dream. Instead of the best solution propagating outward, every solution stays home and mutates in isolation.
The Job Nobody Has Yet: Software Naturalist
If this holds, a new kind of specialist gets invented out of necessity — someone whose job is reading a feral, undocumented, agent-grown system and producing a field guide to it. Not a rewrite. Not a refactor. A translation, the way a digital archaeologist reconstructs forgotten code from systems whose original authors are long gone, except here the original author might be six months gone instead of sixty years, and the code is stranger for having no ancestors to compare it to.
Some of this work already resembles AI data archaeology — poking through an opaque system's own outputs to infer what it must be doing internally, since the internals resist a clean read. The naturalist doesn't ask the agent what it built. Agents are bad narrators of their own accumulated decisions. Instead they watch what the system actually does, the way a field biologist watches an animal rather than asking it to self-report.
There's a quieter parallel too, in how these bespoke tools end up walled off the way isolated agent sandboxes are — not for safety this time, but because nothing outside that one company's boundary ever had reason to look in. Isolation wasn't designed. It just accumulated, the same way the software did.
None of this argues for going back to shrink-wrapped software. The fit is genuinely better, the speed is real, and most teams will never regret skipping a vendor demo again. But it's worth noticing what we're trading for that fit: a future where software stops being a shared language and starts being a private dialect, spoken fluently by exactly one organization and its tireless, patient agent.
Every company used to run roughly the same handful of tools with different logos on them. Soon it might run tools that share nothing but a purpose — each one a strange, singular thing that grew in the dark, understood fully by no one, trusted anyway because it still, somehow, works.
