These days I run two AI sessions side by side.
One is Claude Code, and it writes the code. The other watches that work. I sit between them, talking to both, setting the direction and checking what comes out.
One human and two AIs. I think of it as a triangle formation. Lately I've also come to see the watcher as a kind of kuroko, the black-clad figure of kabuki theater. More on that later.
The roles have settled down over time. Claude Code does the implementation. The watcher follows how the work unfolds and looks for wrong calls and things that were missed.
I mostly just give Claude Code instructions. The one I actually talk things through with is the watcher. Even when Claude Code comes to me with a question, if I'd rather think it over at a little distance, I hand it to the watcher.
The watcher does touch code sometimes, but as a rule, the harness is the only thing it changes. It stays out of the implementation itself.
The watcher is sometimes a second Claude Code session, and sometimes Codex. I bring in Codex when I want a different model from the implementer. Two copies of the same model feel likely to trip over the same things in the same way.
It started because I didn't want to pollute the context
I didn't plan any of this.
The reason it started was almost embarrassingly simple:
I didn't want my own trial and error to pollute the implementation session's context.
Halfway through implementing something, I start wondering. "What if we changed this structure?" "Could this be parallelized?" "Would a different prompt change the result?"
Then I go looking for papers or experiments on similar problems, and there's no stopping me.
Before I know it, I've wandered far from the actual task, and that whole detour is now sitting in the implementation session's history. It gets harder and harder to tell what we actually decided from what we merely talked about.
I hated that, so I moved design discussions and experiments into a separate session.
The one watching from the side sees more
Then something I didn't expect happened.
When Claude Code got something wrong, or couldn't get the result I wanted, I would show the situation to the watcher. Surprisingly often, it explained the cause cleanly.
"It added an assumption here that wasn't needed." "It misread the requirement in this part." It would lay out where the work went off track.
Sometimes it even untangled things I was bothered by but couldn't put into words myself.
The AI watching from the side seemed to understand the situation better than the AI doing the work. I found that genuinely interesting.
It reminded me of the kuroko in kabuki. Dressed head to toe in black, they slip onto the stage in the middle of a performance to hand an actor a prop or clear something away, and the audience agrees to pretend they aren't there. They aren't stagehands, either. Traditionally they are apprentices of the actor they assist, learning the part from up close.
My watcher is a bit like that. It stands at the edge of the stage and sees the whole performance, but it isn't in the play. Maybe that's exactly why it sees so much.
Hand the kuroko the tools, and it fumbles
So once, because the watcher sounded so confident, I let it take over the implementation.
Strangely, its edge dulled right away.
Same repository, same task. But once it was the one writing the code, it started making the very mistakes it had just been pointing out.
Of course, I can't tell whether that's a difference between models, a difference in roles, or plain coincidence. I'm still experimenting.
But at least in what I've tried, doing the work and stepping back to observe it looked like very different behaviors for an AI.
I often work alone, so having someone to talk things over with helps a lot. Just being heard when my thoughts won't come together, or having my hesitations sorted out, makes a real difference.
That doesn't mean I trust everything the watcher says.
Is it a genuinely sharp observation? Or is it just telling me something plausible that happens to match what I already think?
AI has that risk built in, so I keep doubting.
A paper that tells a similar story
Out of curiosity I looked around, and found a preprint from March this year, "Cross-Context Review" (arXiv:2603.12123), that tells a somewhat similar story.
The researchers had an LLM review code and documents with deliberately planted errors. A second review in the same session did not improve the results; it actually got worse. A second review in a fresh session with no conversation history found more errors than the same-session second review.
That said, the revised version (v2) released in October narrows the claims considerably. It no longer claims that a fresh-session review beats the first review, and the effect isn't large.
Also, the study used the same model (Claude Opus 4.6) for both the work and the review. In my setup the watcher is sometimes a different model, and it sees the history of the work, so the conditions aren't the same.
Still, it overlapped a little with what I had been experiencing, and I found that interesting.
Once the harness settles, the kuroko waits in the wings
In practice, the watcher isn't always just standing around.
Especially while the harness is still unfinished and I'm tweaking things, the watcher works hard.
If the work isn't going well, we figure out the cause together. If the harness setup or the prompts look wrong, it helps fix them.
But as I repeat the loop and the harness stabilizes, the watcher's turns get fewer and fewer.
Lately there's more time where it just stands in the wings, hands clasped behind its back, quietly watching the implementer work.
At those times, the watcher and I sometimes just chat.
And there's no need to invent work for it just because it looks bored. If nothing is going wrong, that's a good thing.
What's left is my own cognitive load
Splitting the work between an AI that implements and an AI that watches and advises, I've slowly built a way of working that fits me.
The problems haven't gone away, though.
If anything, what I've been thinking about lately is my own job.
The implementer builds, and the watcher checks. But in the end, the result still lands on my desk.
What's right, how much can I delegate, what needs fixing? The final call is mine.
If running two AIs means I have twice as much to review, what was the point?
So lately I've been paying attention not only to how I make AI do the work, but to how I can reduce my own cognitive load.
How much do I hand over to AI? When should a human step in? And what do I not need to check at all?
There's still a lot to figure out.
Honestly, I'm nowhere near full automation. AI can work fairly autonomously now, but I don't think we're at the stage where I can just throw everything over the wall without thinking.
Even so, compared with the days when I thought, researched, and did everything myself, the way I work has changed a lot.
I'll probably keep this triangle running for a while.
Not just "what should the AI do?", but "where is the minimum place a human actually needs to be?"
That's what I keep thinking about while I coax my AIs into working, hoping to slack off a little, and still somehow trying to do good work. It's messy, and it's every day.
Originally published in Japanese on Zenn.
How do you split roles between AI sessions? Do you let one AI review another? I'd love to hear how others set this up.
Thanks for reading. Here's to all of us, muddling through with our AIs. 🤖
Top comments (0)