What happens when you give Claude Code more than just a prompt? When it has a clear way of working, knows when to delegate, understands which model to use for each job, and has rules for checking its own work?
I wanted to find out.
So I gave it a fairly ambitious task: build a B2B billing service, close enough to production to be a meaningful test. Subscriptions, usage metering, invoices with VAT and reverse charge, webhooks, dunning, credit notes, a double-entry ledger. The whole thing.
Then I asked it to introduce 16 realistic bugs, each with a hidden test designed to catch it.
One request. One instruction: use the crew.
Two hours later, the result was:
- A 22,000-line project, half of it tests.
- 948 passing tests.
- All 16 seeded bugs correctly identified by their hidden tests.
- Seven Sonnet agents spent 91% of the tokens. Opus, coordinating, spent 9%.
- All of it in 85% of a single Pro session.
The interesting part wasn't just what got built. It was how.
Opus led. The agents did the work.
Instead of trying to do everything itself, Opus broke the project into stages, assigned work to specialized agents, and kept track of the bigger picture.
The agents handled implementation, several of them in parallel, each working within a clearly defined scope. Opus coordinated dependencies, reviewed the results, and ran the full test suite between stages, five times throughout the build.
It didn't simply trust an agent when it said "done". It checked.
The whole process required just two questions from me. I mostly watched it work.
That's the idea behind CLAW: let the models do what they're good at, while giving the overall process enough structure to stay reliable.
And then came the real test
The billing service wasn't just a demo. I used it as a benchmark.
I turned the 16 seeded bugs into 16 tickets, handed them to CLAW in a single prompt, and let it work. It fixed all 16, in both runs, passing the hidden tests that the agents had never seen.
That's the part I found most interesting: the same setup that built the project could also navigate its deliberately introduced mistakes and fix them.
So, what is CLAW?
Claude Code is already a capable coding agent. But every new session still has to figure out a lot of things for itself:
How should it approach the task? When should it delegate? Which model should handle which job? What does "done" actually mean? What should it change, and what should it leave alone?
On a small task, these decisions are usually straightforward. On a large project, they add up. And inconsistency becomes expensive.
CLAW gives Claude Code a consistent way of working across sessions and projects.
It brings three things together:
1. A shared working method
A set of practical rules for how work should be approached, delegated and verified. Things like staying strictly within scope, never making a failing test pass by weakening it, and backing up every claim of completion with actual evidence.
2. A team of specialized agents
Different agents for different jobs, with models chosen according to what each task requires. Opus can focus on planning and reviewing, while Sonnet and Haiku handle implementation, exploration, testing and other focused tasks. You only install the agents you actually need.
3. Project memory
Persistent project notes and status files keep track of decisions, progress and unfinished work. A new session doesn't have to start from scratch or rediscover what happened yesterday.
All of this is configurable and reusable, rather than something you have to explain to Claude every time you open a session.
Give Claude Code a better way to work.
CLAW is designed for the kind of work where a task spans multiple files, several agents and more than one session, where coordination and verification matter just as much as writing code.
For a one-line fix, plain Claude Code is probably all you need.
But for everything bigger, it's worth giving it a crew and a method.
Try CLAW
In Claude Code, add the marketplace and install the plugin:
/plugin marketplace add 290990-collab/CLAW
/plugin install claw@claw
Then, inside your project, run:
/claw install
It walks you through a few setup questions and shows you the files before creating them.
No external services, no accounts, no additional packages. Just Python 3.11 and the standard library.
Repository: https://github.com/290990-collab/CLAW
Questions, ideas or a task you'd like to see it try? Open a thread in Discussions or leave a comment here.
Top comments (0)