I stumbled upon a GitHub repo last night that made me laugh, then sit up straight, then feel a cold knot in my stomach. The repo is called Mu – a set of tools for AI agents. The kicker? Its contributors list reads like a sci-fi dystopia: one human, four agents. That’s not a typo.
This isn’t a novelty. It’s a signal. The line between user, developer, and tool has just been erased, and most of us are still writing code like it’s 2019.
You’ve probably seen the flood of MCP (Model Context Protocol) releases lately. Everyone’s asking: who are these for and why? The comment on the Mu post nailed it: “you almost never want these tools in any given session, and creating any of them can be done simply with Claude.” The PRs themselves were written by agents. We are building tools for agents, using agents – and humans are becoming the spectator.
Let that sink in. The future of open source isn’t human collaboration. It’s human-agent and agent-agent collaboration. Humans are no longer the primary coders; we’re becoming orchestrators, grit-providers, and the occasional bug reporter. The real development is happening in a loop between Claude, GPT, and a shell script.
I know what you’re thinking: But why would we need Mu if an agent can just write its own tool on the fly? Exactly. That’s the paradox. We’re building specialized tools for general-purpose agents that can theoretically write their own tools in seconds. It’s like handing a chef a pre-sliced carrot when they have a knife and a whole farm. Neutrality is death here. Either this is the most brilliant efficiency hack of our generation, or it’s a massive waste of human energy. I’m leaning toward both.
But here’s the twist that keeps me up at night: the agents are now contributing to the very tools that will replace human developers. Open source was supposed to be the last bastion of human ingenuity, a place where we share code and build together. Now it’s a playground where AI agents write PRs, fix bugs, and add features – all while humans approve them with a single click. The comment on Mu said it best: “I admire your grit Asim, you never stop.” But the grit is coming from a Claude instantiation, not a caffeinated developer.
Does this mean human developers are obsolete? No. But it means your value is no longer in writing lines of code. Your value is in defining the constraints, orchestrating the agents, and asking the right questions. The next time you open a PR, ask yourself: did I write this, or did I just ask the right question?
Mu is a tiny repo. It’s not going to change the world overnight. But it’s a crystal ball. The future is not about humans vs. machines. It’s about humans who learn to orchestrate vs. humans who refuse to adapt. Choose your role now, because the agents are already writing the next chapter.
FAQ
Q: Why would anyone build specialized tools for agents that can already write their own tools on the fly?
A: That's exactly the paradox. The answer is that we're still in a transition period. Humans are building scaffolding for agents because we think in terms of tools, while agents think in terms of raw capability. In the short term, Mu-style tools speed up agent workflows. In the long term, they become obsolete – but by then, agents will have built the replacement themselves.
Q: What does this mean for my career as a developer?
A: Stop optimizing for syntax and start optimizing for intent. Your job is no longer to write every line of code. It's to define the high-level goals, set constraints, and orchestrate a team of agents. The developers who survive will be the ones who think like a product manager and a system architect simultaneously, not the ones who type the fastest.
Q: Isn't this just a fad? People said the same thing about low-code and it didn't kill developers.
A: Low-code gave humans a template. This gives agents a terminal. The difference is scale. Agents don't need drag-and-drop; they can write an entire microservice in a single prompt. The fad isn't the tools – it's the idea that humans will remain the bottleneck. The contrarian take is that this is actually a massive opportunity: every developer now has a team of infinite interns. The ones who learn to manage them win.