What jumped out at me is not “wow, agents can rewrite large codebases.” It’s that the interesting bit is all the scaffolding around the agents. If you read the piece closely, the headline claim is less “let Claude do a giant rewrite” and more “different teams built very different control systems around the same basic capability.”
That feels right to me. A rewrite is never just a rewrite. It’s a confidence problem. GitHub and Anthropic both used their own agents on major Rust migrations, but the article makes them sound almost like two different philosophies: one more willing to let the agent move faster, the other much more conservative about where the agent is allowed to touch code. I find that split more believable than any sweeping “agents are now good at refactoring” narrative.
The line that sticks with me is the Microsoft engineer’s idea that a rewrite this size wasn’t affordable before agents. I believe that in a narrow sense. Not because the model magically understands a system end to end, but because it can burn through the tedious parts that used to make ambitious rewrites dead on arrival. Still, “affordable” is doing a lot of work there. Cheap isn’t the same as safe, and a rewrite that feels economically possible can still become a maintenance trap if the verification loop is sloppy.
That’s where I’m slightly skeptical of the triumphal mood around these stories. If an agent is producing Rust code, the real question is not whether it can write Rust-shaped text. It’s whether the team can prove the output is correct, stable, and actually worth merging. The article seems to hint that this is the real playbook difference: one team leaned harder on guardrails and constrained execution, while the other accepted a different balance of speed and oversight. That’s the part I’d want to see more of in practice, because the model itself is only half the story.
If I were trying this, I’d care less about “can Claude rewrite the code?” and more about “what did the humans do to keep themselves honest?” Did they build test harnesses first? Did they isolate the agent to small, reviewable units? Did they treat the agent like a power tool or like a junior engineer with infinite stamina? Those answers matter way more than the marketing gloss. Right now, a lot of agent talk still blurs that distinction.
The strongest takeaway for me is almost a warning: these rewrites are not proof that agents can autonomously modernize software. They are proof that teams who already know how to engineer around failure can now attempt larger changes than before. That’s impressive, but it’s not the same claim. And if someone reads this as “great, now we can hand the scary rewrite to Claude and go home,” I think they’ve missed the point.
