I've joined the Mugiwara: my crew of AI agents

I've finally joined the Mugiwara

For the past few weeks, I've had Nami, Sanji, Zoro, Chopper, Usopp, Robin, Franky, Jimbei, Brook and the whole crew by my side. I'm not talking about going back to One Piece between two projects (though that happens too). I'm literally talking about my development team.

A team of specialized AI agents, each with their own role, running in parallel on my projects. Each has their context, their library, their tools. And together, they form the most effective crew I've ever had.

Welcome to agent orchestration. What changes isn't just my productivity. It's my entire way of building a product.

The classic mistake: wanting one super agent

When you start out with AI agents, the temptation is always the same. You want a single "super agent" that does everything. You throw all the context at it, all the tasks, all the requests. And you hope it works.

It doesn't work.

A generalist agent is like asking Luffy to cook. He can try, he'll put his heart into it, but Sanji will always do better. A team's effectiveness comes from specialization and role distribution. Not from a jack-of-all-trades genius who does everything halfway.

The Mugiwara figured this out a long time ago. Each member has a precise skill, and together they cover the entire value chain of a long-haul ship. I've replicated this logic with my agents.

Meet the crew

Robin: the deep research specialist

Nico Robin is a historian. She digs up buried truths on forgotten islands, where no one can read the inscriptions anymore. On my team, she's the deep research agent.

When I need to understand a new library, analyze dense technical documentation, compare several approaches or dig into the corners of the internet to find a specific example, I delegate to Robin. She comes back with a structured summary, sources included, and no unnecessary noise.

While Robin is searching, I keep moving forward on something else. That's what changes everything.

Nami: the project cartographer (documentation)

Nami is the navigator. Without her maps, the crew gets lost at the first storm. On my team, she handles documentation.

Nami documents as if we were discovering a new island with each feature. How it works, why we did it that way, what pitfalls to avoid, how it fits in with the existing code. Not a generic README thrown together at the end of a sprint. A real map of the territory, continuously updated.

In three months, when I come back to the project, I won't get lost. In six months, when another dev picks up the code, they'll have their map.

Chopper: the ship's doctor (QA and health check)

Tony Tony Chopper is the crew's doctor. He heals wounds, he monitors vital signs, he diagnoses what's wrong before it becomes serious. On my team, he's the QA agent.

He continuously analyzes the app's health. Test coverage, detected vulnerabilities, possible regressions, code quality, performance. After every major change, he gives me a clear health report. Where things are fine, where they need watching, where to intervene before production starts coughing.

A project without Chopper is a ship without a doctor. It holds up for a few stops, then it collapses.

Usopp: the reviewer who sees through the lies

This one is my favorite joke. Usopp is the biggest liar in the world. He tells the most outlandish stories, invents epic battles he never fought, talks his way out of trouble with trickster moves. And precisely. It takes a trickster to spot a trickster.

On my team, Usopp does code review. And he's the best reviewer I've ever had. Because he knows exactly what a developer is trying to sweep under the rug.

The // TODO forgotten three months ago. The error handler that catches everything and logs nothing. The test that asserts on a dummy value just to turn green. The reassuring comment that says "this can't happen" when it's definitely going to happen. The half-renamed variable that breaks another module. The commit message that tells a different story than the diff.

Usopp trolls code with the method of a trickster who recognizes another trickster's tricks. Nothing slips past him.

Zoro and Sanji: the wild devs

Zoro charges straight ahead with his three swords. Sanji has style and serves refined dishes. They heartily hate each other, they bicker, and that's exactly what you want in a dev team.

Zoro is the brutal backend. He writes business logic, database migrations, APIs, async jobs. Direct, efficient, no frills. When I tell him "build this," he builds it.

Sanji is the frontend. The taste, the detail, the animations that land just right, the edge cases no one sees. He crafts components like a chef plates a dish. No half-finished interface.

The two constantly challenge each other. Sanji rejects Zoro's code when it breaks the user experience. Zoro sighs when Sanji asks for yet another API for some tiny visual detail. It's loud, and that's a good thing. The best review is the one from another dev who disagrees with you.

Franky: the carpenter who designs the ship (architecture)

Franky built the Thousand Sunny with his own hands. He thought through every deck, every sail, every cannon, knowing exactly what the crew was going to face. On my team, he's the architect.

When I need to make a structural decision, choose a database, set up modules and their boundaries, define the patterns that will govern all the code to come, Franky is who I consult. He thinks in systems, in flows, in dependencies. He doesn't look at an isolated feature, he looks at how it fits into the complete ship.

A good architect isn't someone who writes complicated code. It's someone who makes the rest of the code simple. Franky does exactly that.

Jimbei: the ocean current that speeds everything up (optimization)

Jimbei is the former fish-man, the one who masters ocean currents better than anyone. He doesn't make the ship move forward by rowing harder. He makes it move forward by finding the right current. On my team, he's the optimization agent.

He goes over the code once it's working and looks for bottlenecks. The SQL query that makes twenty round trips instead of one. The React re-render that fires for no reason. The bundle that ships an entire library just to use one function. The endpoint that loads everything in memory instead of streaming.

Jimbei never breaks existing behavior. He just makes it faster, lighter, leaner. He's the agent that turns code that works into code that flies.

Luffy, the captain, is me

I don't code anymore. Well, not like before. I give direction, I settle trade-offs, I validate the course. The Mugiwara execute.

Like Luffy, my only mission is to make sure we're moving toward the goal, and that every crew member has the context they need to shine in their specialty. I'm no longer the best dev on my project. I'm the captain of a team of specialists whose sum far exceeds what I could do alone.

And that's the real change.

What makes this technically possible

So far, I've told a nice metaphor. But technically, how does it hold up? Two essential building blocks.

RAG: every agent has their library

RAG stands for Retrieval Augmented Generation. In plain terms: before answering, the agent searches a knowledge base that belongs to them.

Each Mugiwara has their own contextual library. Robin has scientific articles, indexed technical docs, previous research. Nami has the complete project history, internal conventions, ADRs (Architecture Decision Records). Chopper has logs, test reports, health metrics. Usopp has code style rules, known anti-patterns, the history of past bugs. Franky has architecture diagrams, flow diagrams, validated technical choices. Jimbei has benchmarks, performance profiles, load reports.

Without RAG, an agent answers with its general knowledge learned during training. With RAG, it answers with your context. The difference between a generalist who guesses and a specialist who knows.

It's this data-driven personalization that turns an LLM into a real crew member.

Orchestration: who does what, and in what order

Orchestrating agents means defining the workflow. Who starts, who takes over, who validates, who documents.

When I request a new feature, the sequence is always the same. Robin does the upfront research if the topic is new. Franky validates the architectural approach and lays the foundations. Zoro or Sanji implement depending on whether it's backend or frontend. Chopper runs health checks on the changes. Usopp reviews the code. Jimbei comes back through to optimize whatever can be optimized. Nami updates the map. And I'm the one who gives the final go.

No one steps on anyone else's toes. Each arrives at the right moment with the right context. And when an agent finishes their work, they hand off cleanly to the next one, like a well-oiled relay.

It's orchestration that turns a collection of agents into a real crew.

Why this changes everything

Before, when I coded alone with a generalist AI assistant, I lost enormous amounts of time re-contextualizing. With every new request, I had to recall the architecture, the conventions, the dependencies, the history of decisions. The AI forgot between sessions, and I started over.

With a specialized crew, context is distributed and persistent. Each agent is an expert in their domain, with their own memory. I go from "asking an AI that knows everything halfway" to "asking the right specialist who knows everything about their subject."

The concrete result? I ship faster, with fewer bugs, and above all with better code quality than I used to produce on my own. Not because the agents are better than me. But because their work layers on top of my vigilance. Where I'd miss a detail while reviewing, Usopp catches it. Where I'd forget to document, Nami handles it. Where I'd take a dubious architectural shortcut, Jimbei slows me down.

Alone I go faster. As a crew, I go further.

Brook, the final word: what about your crew?

One Mugiwara was missing from this story. Brook.

Brook is the musician. The one who plays the violin on the deck at dusk, who sings the old songs so the crew doesn't forget where it comes from, who turns a battle into a legend and an ordinary crossing into an unforgettable memory. Without Brook, the adventure still exists. But it doesn't resonate.

Brook, in my crew, is the role I can't delegate to an agent. It's the conversation with you. It's the moment when I tell you what we're building, and when you tell me what you're building on your side.

So I'll ask you directly. What about your crew? Have you already structured your AI agents like a specialized team, or are you still on a single generalist assistant that does everything? Does your Usopp find things you hadn't seen? Has your Jimbei already cut an API's response time by ten?

Tell me in the comments. The greatest treasure of One Piece wasn't the gold. It was the crew. And the greatest game-changer of AI agents won't be the tech. It will be how we learn to make them work together, by sharing our experiences.

The course is set for Raftel. Shall we raise the sails?