The problem
I work across a lot of domains. One minute I'm building a Next.js feature, the next I'm writing content for a project, then I'm reviewing database security, then I'm planning a sprint. Each context switch means loading different mental models, remembering different best practices, and often making mistakes because I'm not an expert in everything.
Claude Code is brilliant at pair programming, but out of the box it's a generalist. It knows a bit about everything, but it doesn't have the deep, opinionated expertise that comes from specialisation. I wanted Claude to be able to shift into "security architect mode" or "content strategist mode" on demand.
So I built a sub-agent system following Claude's documentation patterns.
What I built
A collection of specialised Claude Code sub-agents organised into 8 categories:
.claude/agents/
├── engineering/
│ ├── frontend-developer.md
│ ├── backend-architect.md
│ ├── mobile-app-builder.md
│ ├── ai-engineer.md
│ ├── devops-automator.md
│ └── rapid-prototyper.md
├── testing/
│ ├── api-tester.md
│ ├── performance-benchmarker.md
│ ├── test-results-analyser.md
│ ├── tool-evaluator.md
│ └── workflow-optimiser.md
├── design/
│ ├── ui-designer.md
│ ├── ux-researcher.md
│ ├── brand-guardian.md
│ ├── visual-storyteller.md
│ └── whimsy-injector.md
├── product/
│ ├── trend-researcher.md
│ ├── feedback-synthesiser.md
│ └── sprint-prioritiser.md
├── marketing/
│ ├── content-creator.md
│ ├── growth-hacker.md
│ ├── app-store-optimiser.md
│ ├── tiktok-strategist.md
│ ├── instagram-curator.md
│ ├── twitter-engager.md
│ ├── reddit-community-builder.md
│ ├── linkedin-strategist.md
│ ├── youtube-strategist.md
│ ├── newsletter-strategist.md
│ └── podcast-strategist.md
├── project-management/
│ ├── experiment-tracker.md
│ ├── project-shipper.md
│ └── studio-producer.md
└── studio-operations/
├── support-responder.md
├── analytics-reporter.md
├── infrastructure-maintainer.md
├── legal-compliance-checker.md
└── finance-tracker.md
Each sub-agent is a markdown file with YAML frontmatter that defines its name, description, available tools, and a detailed system prompt with role-specific expertise.
How it works
When I invoke a sub-agent, Claude adopts that agent's persona and expertise. The backend-architect knows about SQL injection prevention, auth bypass vulnerabilities, and Neon database branching strategies. The whimsy-injector knows about micro-interactions, playful copy, and delightful error messages.
The sub-agents are proactive where it matters. Security-critical agents like backend-architect and legal-compliance-checker are designed to automatically review code after relevant changes. I don't have to remember to run a security check; the system nudges me.
The clever bits
Brand voice consistency. Every sub-agent includes a Writing Style Guidelines section that enforces consistent tone and the NMO Digitals brand voice. This means whether I'm getting help with UX research or writing project content, the output sounds like me.
Tool access by role. Each sub-agent only has access to the tools it needs. Marketing agents get WebSearch and WebFetch for research but don't need Bash. Engineering agents get the full toolkit.
Collaboration chains. Sub-agents are designed to hand off to each other. A typical feature development flow might be: rapid-prototyper → frontend-developer → backend-architect → api-tester. Each agent brings its expertise, then passes the baton.
Delight built in. The whimsy-injector is one of my favourites. It specialises in adding personality to products, with a library of copy examples for empty states, error messages, and loading screens that make apps feel human.
Why this matters
This isn't just about organisation. It's about depth over breadth.
A generalist AI gives you 80% quality across everything. A specialist sub-agent, primed with the right checklists, examples, and guardrails, gives you 95% quality in its domain. Stack specialists together and you've got coverage across your entire workflow without sacrificing quality.
It also changes how I work with Claude. Instead of explaining context at the start of every task, the sub-agents carry that context. I just invoke the right agent and get to work.
What I'm learning
Building this system has been a masterclass in several areas:
Prompt engineering at scale. Writing effective system prompts for different roles taught me how to structure instructions, define scope, and create guardrails that actually work.
Workflow automation. Understanding how to chain agents together and when to trigger proactive checks has sharpened my thinking about process design.
Domain expertise synthesis. Researching best practices for security audits, ASO, content strategy, and UX research to encode into agents has expanded my own knowledge across these fields.
AI tool proficiency. Deep familiarity with Claude Code's capabilities, MCP integrations, and the agent SDK positions me well as AI-assisted development becomes standard practice.
These aren't just nice-to-haves. They're becoming essential skills for modern product development.
What's next
The sub-agents cover my current workflow well, but there's room to grow:
- More platform agents as new channels become relevant
- Project-specific agents that know individual codebases deeply
- Agent chaining so multi-step workflows run automatically
- Better discovery so I can find the right agent faster
For now, though, the system works beautifully. I've got a team of specialists in my terminal, each one ready to bring deep expertise to whatever I'm working on.
The future of AI-assisted development isn't one super-intelligent generalist. It's a constellation of specialists, each brilliant in their domain, working together seamlessly. Building this system is helping me develop the skills to thrive in that future.