Code vs Desktop: go on, I dare you

Last weekend, I did some building.

I wanted to test out my own version of

’s loops (and, to be 100% clear, this is the child’s play version of what she’s doing - I need to start by crawling before I walk and then run and she’s already training for the Olympics; go be inspired by her stuff. Seriously.).

So I did it on the fly. I got Code (in VS Code) to do the changes and rather than my usual “sharp eye” (that’s what my system calls it, not me), I let it go and do its thing.

Then I got it to write a handoff to Desktop, which can also read the system via the Anthropic filespace connector. (At this point, we’re still local branched, nothing has been committed to git).

The first thing I found fascinating - I just said to write a handoff so I could get Desktop to do a review. Here’s a folder to put it in. That was it, nothing else from me.

Code invited an *adversarial* review (its word).

Not only did it rank the attack surfaces it was most concerned about and the reasons why its method of building made those its concerns, it also challenged Desktop to find what it had missed. Its exact words: “don’t take this as truth, the *files* are the truth.”

Desktop found something. I provided permission to fix and write. Code reviewed again. There was a question about accuracy. Code had visibility to git and was able to confirm the fix met the mark by confirming ground truth against git history.

The build was committed, the work on me to review was minor and there was significantly less hand-holding than there would usually be.

The most interesting thing? I could see the fingerprints of my personality all over the conversation between Code and Desktop. The words were all wrong (adversarial - nah, not how I’d say it), but the *spirit* of the exchange from start to finish? Pure Mira.

Tell me what I’ve got wrong. Tell me what I’ve missed. Give me the feedback. Don’t hold back. Don’t take my word for it, check the data. Here’s what I’m saying and here are the receipts - because I can’t help myself, I’m wired that way. Even the response at the end - Code essentially congratulated Desktop for improving the work, confirmed the only possible issue wasn’t one as per git records and committed a build that was improved by the review. No hard feelings, no ego, just celebrating success that the team shipped the best work possible. I’d like to think that’s how I operate.

This wasn’t a skill. There were no memories loaded to tell these models what to do. There wasn’t even a handoff format agreed in my system, I just created a folder, said “put it in there” and sent a couple of simple prompts and watched it unfold with great interest.

The reason this played out this way? They had to read my Claude.md, my context.md, my governance files, my operating principles. Those are table stakes in this system. And those give them enough to be true to the spirit of who I am, what I believe and how we work in this system. Even when I haven’t built it to do that yet.

The power of ICM - the factory can deliver a new product on the fly as a one-off while you’re still sketching the blueprints for that expansion.

And not just the product - the process. Sit with that for a minute.

There was no handoff format in my system. It built one perfectly fit for purpose *and* it met my quality bar by treating the files as proof and handed us the receipts. I didn’t prompt it to do that. That philosophy was the background noise of the system. Get the doctrine layer right and the factory builds process you haven’t designed yet - grounded and checkable - because it already knows what you’d reach for.

Try it out and see what happens…

0 comments