You know that feeling when you open a file, scroll for what feels like an eternity, and realize you have absolutely no idea what’s going on? Now imagine that file is 30,000 lines of TypeScript, it runs the core of GitHub Copilot, and no human being actually wrote it.
Microsoft just spent $120,000 to port Copilot’s runtime to Rust. But they didn’t do it by hand. They did it, to use a horrifying new piece of corporate jargon, “agentically.”
“Agentically” is just corporate speak for “we let the AI touch it, and we pray it works.”
When the story broke, developers immediately zeroed in on the most absurd detail: a single file named session.ts that was over 30,000 lines long and touched every aspect of the runtime. Let’s be brutally honest. No human engineer sits down and writes a 30,000-line TypeScript file. That’s not a coding project; that’s a digital hoarding situation.
But it’s the natural endpoint of the “vibe coding” era we’re living in. Developers aren’t authoring logic anymore; they’re rubber-ducking with AI, accepting massive pull requests, and hoping the tests pass. The AI doesn’t care about clean architecture or separation of concerns. It just generates code until the prompt is satisfied.
A 30,000-line file isn’t a bug. It’s the inevitable output of a workflow where humans are reduced to rubber-ducking machines that type.
So, what happens when you have a 30,000-line monstrosity that no human can comprehend? You can’t refactor it. You can’t safely optimize it. You certainly can’t manually port it to Rust. You have to feed it to another AI. You pay $120K in compute to have an agent translate the spaghetti into a language you probably don’t even know well enough to debug.
This is the dark, hilarious twist of modern software development: The same agentic automation that created the unmanageable mess is now being hailed as the hero for porting the mess to a new language. It’s an ouroboros of tech debt. We aren’t fixing the problem; we’re just translating the monster.
We aren’t fixing technical debt anymore. We’re just changing the language of the monster.
If you use VS Code, you’re already feeling the friction. The comments sections are full of developers complaining about ridiculous “vibe coded” localizations in Visual Studio, Task Manager failing to report CPU usage correctly, and File Explorer getting stuck in infinite loading loops. These aren’t just random bugs. This is what happens when humans review, but don’t truly author, at scale. You lose cognitive ownership of the product.
The real story here isn’t Rust versus TypeScript. It’s not even about the $120K price tag. It’s about the quiet surrender of human agency. When your IDE starts acting weird, when sessions randomly disappear or timestamps break, there’s no human engineer who can just dive in and fix it. The architecture is now alien. The logic is AI-generated, AI-ported, and AI-maintained.
If you’re an engineer, this should send a chill down your spine. Your future isn’t writing elegant, optimized code. Your future is cleaning up the digital droppings of a fleet of agents that don’t sleep, don’t care about your style guides, and leave behind 30,000-line files that only another machine can understand.
The future of engineering isn’t creation. It’s custodial work for code that no human fully understands.
FAQ
Q: Isn't Rust better than TypeScript anyway? Why does it matter how they ported it?
A: Rust's performance benefits are real, but that misses the point. The language doesn't matter if the underlying architecture is an incomprehensible blob generated by a machine. You can't debug or maintain what you don't understand, regardless of the syntax.
Q: What does this mean for my daily dev work?
A: Get ready to debug code you didn't write, using tools that are actively being rewritten by agents in the background. Your IDE will get weirder, bugs will become harder to trace, and your job will shift from authoring logic to reviewing AI pull requests.
Q: Should we just ban AI from touching core architecture?
A: We can't. The codebases have already grown too massive for humans to manually port or refactor. We've built a dependency on the very tools that created the mess, trapping us in a cycle of using AI to fix AI.