Meta has thrown its hat into the AI coding ring with Muse Code, an agent pitched specifically at large, complex codebases. That's the interesting bit. Copilot, Cursor, Devin and the rest have mostly proven themselves on greenfield projects and tidy little functions. The real test — the one that separates a good demo from a useful tool — is whether any of this works on a fifteen-year-old system with three architectural eras stacked on top of each other, half-documented business logic, and a test suite that lies to you.
I've been writing code since 1986. I've watched at least four generations of "this changes everything" tooling come through — CASE tools, UML code generation, low-code platforms, and now agents. Some of it stuck. Most of it didn't survive contact with a real production codebase. So forgive the raised eyebrow.
Why large codebases are the actual hard problem
Small codebases are easy for AI because context is cheap. You can fit the whole thing, or close to it, into a model's working memory, and the agent doesn't need to guess much about intent — the code mostly speaks for itself.
Large codebases are hard for exactly the opposite reason. Context is expensive and incomplete. Nobody, human or machine, can hold the whole system in their head. The skill that separates a senior engineer from a junior one isn't typing speed or syntax knowledge, it's the judgement to know which ten files out of ten thousand actually matter for the change you're about to make, and what's going to break three services downstream that you can't see from where you're standing.
That's a retrieval and reasoning problem, not a code-generation problem. Meta clearly knows this — you don't build a dedicated large-codebase agent unless you've hit the wall that everyone else has hit, which is that generic coding agents fall apart once the repo gets past a certain size and age. The question is whether Muse Code has actually solved the retrieval and reasoning problem, or whether it's just got a bigger context window and better marketing.
What I actually want to know before I trust it
Demos are cheap. What I care about, running production SaaS with AI baked into the pipeline, is a short list of unglamorous questions:
- Does it understand why code is the way it is, not just what it does? Legacy code is full of decisions that look wrong until you learn about the outage they were fixing.
- Does it know when to stop and ask, rather than confidently "fixing" something it's misunderstood? Confident wrongness is the most expensive failure mode in this whole category.
- Can it navigate cross-service and cross-language boundaries, or does it quietly assume everything lives in one repo, one language, one deploy pipeline?
- What happens to review load? If it produces changes fast but every one needs a careful senior review, you haven't saved time, you've moved the bottleneck.
None of these show up well in a launch video. They show up three months in, when the agent has been let loose on your actual backlog.
Where this fits with tools like mine
I build automation SaaS for a living — RSSMasher, MarketMasher, Article2Video and the rest all lean hard on AI to turn raw input into something useful without a human doing the grinding by hand. So I'm not an AI sceptic. I'm an AI pragmatist. The lesson from building those products is that AI is brilliant at the parts of a job that are mechanical but tedious, and it needs tight guardrails everywhere the job requires judgement.
Coding on a large legacy system is mostly judgement. Renaming a variable across a codebase is mechanical. Deciding whether a "duplicate" bit of logic is actually a duplicate, or a subtly different business rule that someone will notice missing in Q3, is judgement. Agents are getting good at the first category. The second is where the real value sits, and it's still where humans earn their keep.
My honest prediction
Muse Code, and its inevitable successors, will genuinely help — as a fast, tireless pair programmer that handles the grunt work: refactors, test scaffolding, dependency upgrades, the archaeology of "what does this function actually do." That's real value, not hype. What it won't do, not this year and probably not next, is replace the person who understands why the system is shaped the way it is. Codebases are gold once you understand the crude ore they were smelted from. Right now these agents are very good at polishing what's already there. The judgement about what to keep, what to melt down, and what to throw away is still ours.
Worth watching. Not worth panicking about.
— Wayne