Use subagents as researchers, not implementers
Subagents that implement directly lose context between sessions. Subagents that research, write their plans to the file system and leave the implementation to the main agent work in production.
Written by
-
Benedikt Stemmildt Founder & Co-CEO
Published: 28 October 2025 Updated: 2 min read
Most developers try subagents once, get frustrated, and never use them again. The reason: they use them as implementers instead of researchers.
The promise is compelling. Specialized agents handle different parts of your codebase: a frontend specialist, a backend specialist, a database architect. Here is what actually happens.
Implementing subagents lose their context
You ask your frontend subagent to build a UI component. It does the work. Perfect.
Then you discover a bug, and you ask Claude Code to fix it. The main agent doesn’t know which files were created. The frontend subagent doesn’t remember what it did in the previous session. Each task is a completely isolated conversation.
You’re not orchestrating a team. You’re playing broken telephone with amnesia patients.
What breaks the process:
- Subagents that implement directly
- No shared memory between sessions
- A main agent blind to what the subagents did
- Debugging conversations that go nowhere
After building agentic systems for production teams at German retailers, I’ve learned there’s a better way. Think of subagents as specialized researchers who propose detailed, vetted implementation plans, not as junior developers who write code.
Phase 1: specialized research
Your subagents don’t implement. They research and plan.
The Vercel AI SDK specialist:
- reads the latest v5 documentation
- analyzes your existing code
- proposes an integration plan with a migration path
- outputs a research file with detailed implementation steps
The Tailwind and shadcn specialist:
- retrieves relevant component examples
- studies your design system
- proposes a UI architecture
- outputs a design specification file
Each subagent writes its research to the file system. That file system becomes your persistent memory.
Phase 2: context coordination
Your orchestrator, the main Claude Code agent, keeps a project context file. Every subagent works through the same steps:
- Read the context file.
- Perform its specialized research.
- Write the research output to the docs folder.
- Update the context file with what was completed.
When the research is complete, the main agent reads all research outputs and combines them into one coherent implementation plan.
Phase 3: focused implementation
Now the main agent implements with complete context:
- all research files are available
- design specifications are documented
- integration plans are validated
- edge cases are identified upfront
Implementation becomes focused work instead of hours of rediscovery.
The orchestrator implements, the subagents research
The old mental model says a subagent is a specialist who codes its domain. The one that works says a subagent is a specialist researcher who proposes validated plans for the main agent to implement.
Your orchestrator is the implementer. Your subagents are the research team.
Improve the subagents after every project
Treat your subagent system prompts like your CLAUDE.md file. After each project, update them based on what you learned. Your subagents get better with every project, just like your team would.
What’s the one subagent specialization your workflow needs most?
Further reading
Written by
-
Benedikt Stemmildt · Founder & Co-CEO
More on Coding agent setup
- One general agent with a skill library beats 47 custom agents Teams cram every procedure into monolithic agent prompts. Agent Skills replace them with one general agent and a composable library that loads knowledge in layers.
- Generic coding agents hit a limit, custom agents go past it Claude Code, Cursor and Gemini CLI are built for the average codebase. Teams that scale with agents move from better agents to more agents to custom agents built for their own domain.
- A swarm of subagents is not throughput Coordinators that fan out to thousands of subagents measure merged pull requests, which is output. The limit on fan-out is how much a team can check well enough that what lands is what customers need.
Scaling needs named owners
Coding agents scale across teams when named people own the platform, the team practice, the guardrails, and the measurement. Rollout & scale is where that ownership is built and handed to internal owners, in your stack.
Training on this topic: Agentic Engineering for Developers and QAWant to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check