A few days ago I gave an internal talk at Clarity's AI tools Community of Practice about advanced Claude Code usage. It was a live demo, so this is the written, tidied-up version of what I showed, for anyone who wants to come back to it.
This is the companion post to Pi: a Minimal Agent Harness: if that one is about the smallest possible tool and everything you learn because it hides nothing, this one is about squeezing a very complete one for all it's worth.
One heads-up before we start: this is advanced content. It assumes you're already comfortable running Claude in auto mode — that is, you trust the agent enough to let it execute without approving every step. If you're just starting out, do the basic path first — plan mode, iterate, review — and come back later. I say this because almost everything that follows takes that trust for granted.
The normal flow is still 90% of it
Before the flashy stuff, it's worth remembering that the most common flow is still "the usual one", and it's the foundation of everything else:
- Describe the task in plan mode.
- Iterate on the plan until it makes sense.
- Implement/execute the plan.
- Review the changes.
- Open the MR.
That's literally 90% of the time. The one new rule worth internalizing: if you find yourself repeating the same instructions three or more times, turn them into a repo-specific skill. That single habit gives you more leverage than anything else in this post. In the frontend repo we already have several skills (create MR, remove a feature toggle, remove warnings, debug), and the beauty is that they're adapted to the repo, so the agent already knows where to look and which tools to use without you explaining it every time.
Orchestrating agents: serial or parallel
When a task doesn't fit in a single conversation, you can have Claude split it across several agents. There are many ways to orchestrate that, and picking the right one makes all the difference in control and cost. These are the two most basic models I've tried so far:
The first is serial: a resumable loop where you make one change, wait for its MR to be merged, and only then move on to the next. The state lives in a markdown file, so you can close your laptop and pick it up the next day. This is what you want when you have lots of similar changes but need to review each MR before moving on. It's cheap, because only one task runs at a time, and although Claude does most of the work, a human stays in the loop the whole time.
The second is parallel: Claude launches many sub-agents at once to do independent pieces simultaneously. It's for repetitive work with no ordering dependencies — adding return types to every file, increasing test coverage, migrations... — tasks where each sub-agent can work on its own on a file or module. You can ask Claude to orchestrate the sub-agents, have each one work in its own worktree or make its own commit, and let the main agent handle merging everything and opening the MR. It's much faster, but expensive in tokens. Each sub-agent is like an independent conversation, except this time between the orchestrator and the sub-agent, following the plan you defined earlier. To activate it, just ask with words like "fan out" or "spawn agents" when creating the plan: either one tells Opus to put together a parallel orchestration plan.
⚠️ A tip that can genuinely save you money: explicitly tell it to use Sonnet for the sub-agents. If you don't, it may end up running them with Opus or Fable and burn tokens at a terrifying rate (the classic case is Fable spending "like crazy"). The rule is: orchestrate with Opus, execute subtasks with Sonnet.
Commands worth knowing
Beyond orchestration, there are a handful of commands I showed in the demo and use often:
Deep research. Works like Perplexity or Google's deep search: it spawns agents in parallel, searches sources, and compiles a cited report. Very useful for researching new topics, exploring market alternatives, reviewing the literature on a specific problem... Watch the model again: Opus gets better results but costs more; Sonnet is cheaper.
Handoff. You ask Claude to write a plan in markdown with everything needed to continue in a new session. Perfect when you spot a refactor or subtask you don't want to cram into the current MR, or when you're about to run out of context. There's a well-known skill for this, but it's really four lines: you can just ask Claude directly.
/insights. Analyzes all your sessions and generates an HTML report with statistics, the problems you usually trip over, improvement suggestions, and even "moonshots". Great for debugging your own skills, hooks, and agents. Worth running every now and then.
Remote control. Lets you monitor and pilot an active session from your phone or another browser, while the session keeps running in the terminal. It's documented here. It's a bit buggy — sometimes the connection drops and you have to go back to the terminal — but its real value is that it lets you get up from your chair: approve a plan from the kitchen, go out for a walk. One warning, half legal, half health-related: don't use it outside working hours; in Spain that's literally illegal. Which ties into the next point, and this one is serious.
Don't burn out
These flows are fast and highly addictive. Because they move so quickly, you feel like stopping is losing money or time, and that keeps you glued to the screen. That's a recipe for burnout. Take breaks, stand up, and don't have five agents running all the time just because. This isn't a joke — there are plenty of testimonies about it, and if this was already a problem in the profession, it's going to get much worse.
But how did we get here?
If you stop to think about it, the leap is enormous. I've been writing about this on the blog for a few years, and rereading those posts is a bit dizzying:
- In Developing with ChatGPT (April 2023) I told how I asked ChatGPT for code snippets and pasted them by hand, amazed that it would write me a decent Dockerfile or README.
- A year later, in LLMs review, one year on, things already looked like a paradigm shift, although still surrounded by skepticism and without a clear sense of where it was heading.
- And in 2025 review in 'assisted' development (January this year) I was already talking about entire projects done in days instead of months, and about hand-writing code starting to make no sense.
In less than three years we've gone from copy-pasting snippets from a chat to orchestrating swarms of agents that open their own MRs while we review. What I describe in this post — orchestrating sub-agents, letting them run in auto mode, piloting them from your phone — would have sounded like science fiction when I wrote that first post. And I have a feeling that in a year this will also feel dated. That's why I think it's worth leaving these notes as a snapshot of where we are today.
Where to start
If I had to pick three things to try this week:
- Turn an instruction you repeat often into a skill, in a repo you actually work on.
-
Run
/insightsonce and adopt at least one of its suggestions. - Orchestrate a serial batch over a small set of similar tickets, with sub-agents on Sonnet.
As always, you can leave comments on github or write to me on bluesky. And if you set up your own agent orchestration, I'd love to hear how it went.
Top comments (0)