Almost every company has a piece of software nobody likes to talk about. The Access database that has planned orders since 2009. The Excel file with macros only one colleague really understands. The program a freelancer built twelve years ago, its source code sitting somewhere on a server. It runs, it is a little annoying every day, and rebuilding it never added up.
That calculation is changing right now.
What GitHub did
In September, Stephen Toub of GitHub described how the runtime behind GitHub Copilot was rewritten. It is the core that powers the Copilot features in VS Code, Visual Studio, Word, Excel and Outlook. Originally written in TypeScript, now entirely in Rust.
- About 430,000 lines of TypeScript went through the port.
- By 21 August the runtime was fully converted: 832,378 lines of Rust, plus 468,689 lines of tests.
- The port took about 14.5 weeks. In that time, 135 versions shipped, more than one a day.
- Most of the work was done by a single developer with AI agents. Toub estimates that without agents it would have taken a whole team one to two years.
- The new runtime is orders of magnitude faster.
Toub sums it up in one line: a rewrite this size was not affordable before agents.
How it worked
That agents write code is old news by now. The instructive part is how Toub used them.
Piece by piece, while running. There was no big switch on a cut-over date. Each change replaced exactly one component, deleted the old one and put the new one into service immediately. The software was shippable in every one of the fourteen weeks, and the rest of the team kept working as usual. Toub started with the simplest parts that already had good tests, to prove the approach. He saved the most complicated part for last.
The tests decide. Every existing test ran against the new code at every step. Anything that broke a test did not get in. By the end, the project had more than half as many lines of tests as lines of code. The more tests there are, the more code you can entrust to an agent.
A person steers. Toub wrote around 2,600 messages to the agents himself during that time. He describes his role as reviewing results, challenging technical decisions, enforcing quality bars and pushing back when an agent treated an intermediate state as finished. His work moved away from writing and towards steering.
What this means for your old software
Your Access database does not have 800,000 lines, and that is exactly why this is good news. If one developer with agents can do in a few months what used to take a team one to two years, rebuilding an internal tool turns into a manageable project instead of a plan for "some day, when there is budget".
GitHub's approach transfers almost one to one:
- First pin down what the old software does. Before a single line is rewritten, tests describe today's behaviour: this input, this result. For an old application these are often real cases from the past year. Agents write these tests quickly today, and they are the foundation for everything else.
- Start small. One report, one form, one calculation. After a few days you know whether the approach holds.
- Run old and new side by side. Piece by piece moves to the new solution, the team keeps working, and nobody has to relearn everything on a cut-over date.
- Let someone steer who knows what good software looks like. The agents write. A person decides what is good enough.
What you end up with is more than a copy of the old software. If you are rebuilding anyway, you can connect it to the ERP, run it in the browser instead of on one office PC, and add the three fields that have been missing for years.
The calculation flips
For many small programs, the question "is a rebuild worth it?" was answered with no for years, so people stuck with what annoyed them. When a rebuild costs a fraction, that calculation flips for a lot of the software running in companies today. To me this is one of the underrated effects of AI agents. Alongside everything new they make possible, replacing the old finally becomes affordable.
If a program like that runs in your business and you want to know what state it is in and what a rebuild would involve: a Software Audit gives you an assessment with a prioritised action plan.
Source
- Stephen Toub, GitHub Blog: Migrating the GitHub Copilot runtime to Rust, using Copilot, 16 September 2026