I started playing around with a different approach to showing my work: streaming from Claude Code through my dev container as an MCP server, then giving it tasks from Claude Desktop.
The experiment was basically: can I bridge my terminal-based agentic development setup into my chat-based workflow? Can I let Claude Desktop coordinate tasks with the Claude Code instance running in the container?
It's a meta kind of thing. Using Claude to orchestrate Claude. But it kept coming up in my head — if Claude Code can run as a service, and if MCP is the way to connect Claude to external systems, why not wire them together?
I set it up. It mostly worked. The Teams calls where I showed this were less polished than I would've liked, and I realized that streaming live coding while also explaining the infrastructure is harder than it sounds. You're trying to do two things at once: actually use the tools, and help people understand what's happening.
The recording quality was okay. The audio was rougher than I'd like (car rides are not ideal recording studios). But the response was good because people saw the attempt — they saw that this kind of integration was possible, and they started thinking about what else you could wire together.
That's the value of showing work in progress. The polished demos are great, but the experiments are more valuable because they invite people to think differently about what's possible.
Some observations from the experiment:
First, the latency is real. Having Claude Desktop talk to Claude Code in a container adds communication overhead. It's not broken, but it's noticeable. There are tradeoffs between the convenience of the integration and the performance cost.
Second, MCP is genuinely powerful for this kind of thing. But it's also a bit of a puzzle to set up initially. The documentation exists, but there's a learning curve that I had to climb, and it's not obvious from the outside that it's possible until you try it.
Third, the mental model shifts when you have Claude coordinating Claude. You start thinking in terms of delegation. The desktop instance becomes like a manager, and the container instance becomes like a specialist. You write instructions for the manager about how to break down work.
I'm not sure this specific setup is the future. But it pointed at something real: the tools are starting to have enough sophistication that you can build meta-layers on top of them. You can orchestrate. You can delegate. You can build systems rather than just chains of prompts.
That's the evolution I'm watching. Not just better models. Better ways to compose them.