Code Is Free Now
Something fundamental shifted, and most tooling has not caught up to it. AI can generate working code in seconds. The raw material of software, the thing that used to be scarce and expensive and slow, is now effectively free.
That is not a small change. For the entire history of the industry, the constraint was how fast a human could type a correct idea into a file. Every process we built, every workflow, every tool, assumed that writing the code was the hard part and the slow part. Optimize around the scarce resource, and the scarce resource was always the developer.
Take that constraint away and the whole system starts to strain in a new place. When anyone can produce a working change in minutes, the changes stop trickling in. They flood.
Intelligence Is Next
The instinct is to assume that the thing producing all this code is the valuable part. It is not, and the evidence is already in.
Moonshot shipped Kimi K3 on 16 July 2026 and released the weights eleven days later. 2.8 trillion parameters, 104 billion active per token, a one million token context window, and 57 on the Artificial Analysis Intelligence Index. Fourth in the world, behind two proprietary models, and you can download it. It is the largest open model ever released.
Look at the trend rather than the single release. One year ago the best open-weight model on that index scored 22. Today it scores 57, and the gap to the leading proprietary model is four points. Nine of the thirteen models on the intelligence-versus-price frontier are open weights, and every one of the top ten open models comes from a Chinese lab, which means no single vendor or jurisdiction controls the supply.
Read that honestly and the conclusion is uncomfortable for most of the industry. Frontier capability is roughly eleven days and four points from being something anyone can run. Whatever a model can do today, it will do for free next year.
So intelligence follows code. Both go to zero. Nobody's moat is the model, including ours.
Software as a Product Is Dying
Follow the cost curve to the end. When a model can generate a working tool in the moment it is needed, packaging that tool, selling seats, and defending a category stops making sense. The subscription was always a way to charge rent on the gap between what you needed and what somebody had already built. That gap is closing.
Cheap does not mean less. It means more. When steam engines got more efficient, Britain did not burn less coal, it burned far more, because efficiency made coal worth using for things nobody had bothered to use it for. Software runs the same course. Collapse the cost of producing a tool and the world does not end up with fewer tools. It ends up with orders of magnitude more of them, most of them built for one person, for one afternoon, and thrown away after.
Which splits software into two kinds, and only one of them is dying.
The durable kind is infrastructure. It holds state that matters, it is shared across an organization, it has been hardened by a decade of edge cases. Nobody is regenerating a general ledger at runtime, and nobody should.
The ephemeral kind is new. Software created at the moment of need, for one person, for one task, then discarded. If software is infinite, most of it will be ephemeral, because most of what people need software for is specific, immediate, and unrepeatable.
What is actually dead is not software. It is the static, predefined workflow, the assumption that somebody else should decide the steps in advance and ship them to you as a product.
But the World Does Not Run on New Software
Here is where most of the industry stops thinking, and it is the most expensive mistake in the room.
The world does not run on software written this year. It runs on the systems that hold the money, the state, the customer records, and the regulatory history. Those systems are ten and twenty and thirty years old. The real business rules do not live in the documentation, they live in the exceptions, in a conditional somebody added in 2014 for a customer who threatened to leave.
None of that gets regenerated. Not because the idea is unappealing, but because three things block it and none of them are getting easier.
The models cannot do it. Frontier models are extraordinary at the scale of a function, a file, a well-scoped service. They are still weak in exactly the place where the value is locked: a codebase of millions of lines, undocumented, where correctness is defined by behavior nobody wrote down. A million token context window is not the same thing as understanding a system.
The migration cost is not a code cost. It is change management, data migration, retraining, regulatory re-approval, and the risk of being wrong about something that moves money. That bill does not shrink when code gets cheap, because none of it was ever about typing.
And the incentive is not there. Nobody gets promoted for replacing a system that works. They get fired for breaking it.
So software is dying, and the dying takes decades. In the meantime the estate has to keep running, and it has to keep changing, because the business around it keeps changing. That is not a transitional inconvenience. It is the actual condition of the industry for the next twenty years.
Legacy Is Everything You Shipped Last Quarter
Legacy is a bad word because it sounds like mainframes and COBOL, like a shrinking problem waiting for its last maintainer to retire.
That is the wrong definition. Legacy is not old code. Legacy is code nobody holds in their head. The distinction is not age, it is whether a human being can predict what happens when you change it.
By that definition, the pile is not shrinking. It is growing faster than at any point in history, and AI is what is growing it. Every change an agent shipped last quarter is code that no human on the team ever fully read. It runs in production. It has no owner who can tell you what it will do under load. It is legacy the day it merges.
We are producing unowned software at machine speed, and we are producing it into the systems that already carry the most risk.
So the market is not the old estate slowly being retired. It is the old estate plus everything AI is adding to it, compounding. The problem gets bigger every quarter, and it gets bigger fastest at the companies adopting AI most aggressively.
The Bottleneck Is Not Intelligence, It Is Execution
Put those two curves together and the question stops being "can a model write this change" and becomes "how does anyone let it".
To safely change a system nobody fully understands, you need four things, and intelligence is only one of them.
You need the system running. Not the source code in a context window, the actual thing, booted, with its database and its dependencies and its 2009 assumptions intact, in an isolated copy so that ten changes can be in flight without stepping on each other. Every piece of dev tooling ever built assumes one human, one machine, one branch, one port. Run five agents on top of that and they fight for the same state. The infrastructure breaks long before the models do.
You need proof. Reading a diff was already guesswork when a team shipped ten pull requests a week. At a hundred it stops happening, and the quality bar quietly drops to whatever the model felt like doing. The only thing that scales is evidence: the change driven through the real product, end to end, recorded, attached to the pull request. The reviewer stops guessing and starts watching.
You need control. Models are next-token machines, unreliable by design, and no amount of scale has removed that. The review step is not friction to optimize away. It is the safeguard that makes speed survivable. A human decides what lands.
And you need all of it to sit on git. Not out of nostalgia. Git is the most battle-tested infrastructure most companies own, and every CI system, deploy pipeline, audit, and rollback assumes it. The tempting move is to invent a post-git source of truth and push straight from a chat window to production. That is the same trap the vibe coding wave fell into: an app that looks complete to anyone who is not an engineer, with no tests, no deploy story, and no history you can trust underneath it.
The workflow around git needs reinventing. The code staying in git does not.
Everything Goes to Zero Except the Machine
Now stack it up.
Code: free. Intelligence: a commodity, eleven days behind the frontier. Software as a packaged product: ephemeral, generated on demand. Every layer in this industry is deflating at once.
Except one. The machine a change actually runs on does not deflate, because it is bound to physical things: boot time, disk, memory, network, a real process doing real work against real state. When everything above it is free, the thing that is left is the place it runs.
That is the layer we sell, and it is worth being precise about what it is, because "infrastructure" sounds like reselling compute at somebody else's margin. We are not selling compute. We are selling reproducible environments for systems that were never built to be reproducible. Booting an arbitrary customer stack, whatever its age, whatever its dependencies, ten times in parallel, in seconds, identically every time. Nobody undercuts that with cheaper metal. It is years of systems work, and it gets harder in exactly the direction where the value is: older systems, weirder dependencies, higher stakes.
It is also the layer with the right economics. A per-seat tool is a business indexed to human headcount, and AI is not growing human headcount. Consumption of environments is indexed to changes attempted, and changes are going up by orders of magnitude. One of those numbers is flat. The other is the whole thesis.
And it means every model release is a tailwind rather than a threat. Better models mean more changes attempted, more environments booted, less cost per change. We do not need to win the race we are describing. We need the race to happen.
This Is Kosuke
Import your repository, whatever the stack, whatever its age. Kosuke runs the full environment in isolated cloud sandboxes, one per change, so agents work in parallel, each on a real branch, each with a live preview you can click through. Every change is driven end to end through a real browser and the recording is attached to the pull request, so review is watching rather than guessing. The incoming queue is ranked and explained in plain language, so the person accountable for the product decides what ships in minutes instead of drowning in it.
Nothing moves out of git. Same repository, same history, same review, same standards. Trying it costs a team nothing, and no CISO has to approve a new source of truth.
Roughly 80 percent of the AI-generated pull requests that go through this get merged, on real production codebases, reviewed by real teams.
We Will All Be Builders
There is a paradox in how software gets built right now: shipping alone is faster than shipping together. One person, one branch, a fleet of agents, and you move quickly, because nothing you produce has to be reconciled with anyone else. The moment a team is involved, the speed collapses. Merge conflicts. QA that cannot keep up. The overhead of keeping everyone pointed at the same thing. Collaboration, the thing that is supposed to make a team stronger than any individual, turns into the tax that slows it down.
That is backwards, and it is a tooling problem rather than a people problem. The same primitives that let one person run ten agents without them fighting over state are what let ten people run their changes without fighting over each other. An isolated environment per change, so nobody blocks anybody. Every pull request arriving with proof it works, so QA stops being the queue the whole team waits behind. A ranked flow, so the group spends its judgment on what matters instead of on coordinating.
And once collaboration is cheap, who gets to build? Not just engineers. The PM who wrote the spec, the designer who drew the screen, the marketer who needs the landing page changed. They describe what they want, an agent opens a real pull request against the real codebase, and an engineer reviews it like any other. Same repo, same review, same standards. No silos, no tickets sitting for months, no handoff tax.
What We Are Actually Building
Every change that runs through Kosuke leaves something behind that nobody else is collecting: a recording of a real system behaving before and after, tied to a diff, a review, and whether a human chose to merge it. Not a benchmark. Not synthetic data. Evidence of what a change did to a system somebody depends on.
That is the training substrate for the thing that comes after. The world's software estate is not going to be rewritten. It is going to be operated, increasingly by machines, and operating it requires knowing what happens when you touch it. We are building the layer that knows, one merged change at a time.
Code is free. Intelligence is going the same way. Neither one can change a system nobody understands. That takes a machine to run it, proof it still works, and a person who decides. That is the layer that lasts, and that is the whole bet.