# 20 Best Claude Code Subagents for SaaS Founders in 2026 (Ranked)

> 20 Claude Code subagents ranked for solo SaaS founders, with the trigger, tool grant, and model for each — plus the Explore-Plan-Code pattern and Agent Teams vs. subagents explained.

Canonical: https://www.agentickit.co/blog/best-claude-code-subagents-2026
Last updated: 2026-10-30

**Short answer:** for a solo founder shipping SaaS in Claude Code, the subagents worth running are the ones scoped to a single responsibility with tool access that matches the job — a [code reviewer](#the-ranked-list) that can't edit, a [security auditor](#the-ranked-list) that can't write code, a [billing engineer](#the-ranked-list) that never touches your marketing copy. Below are 20 real subagent roles ranked by how often a solo founder actually needs them, each with the trigger that should invoke it and the tool grant it needs — not a generic "AI agent" list, but the actual shape of [AgenticKit's 34-agent setup](/agents), which we audited on our own repo and wrote up [separately](/blog/subagent-setup-audit-fixes).

## Why most subagent setups fail

The default way people build a Claude Code subagent is to write one giant system prompt — "you are a full-stack engineer, handle everything" — and give it every tool: `Read`, `Write`, `Edit`, `Bash`, the works. That setup works for a demo and falls apart in a real repo for two reasons.

First, **no tool scoping means no safety boundary.** A subagent whose entire job is to review a diff and say PASS/FAIL doesn't need `Edit` access, and if it has it, the model will eventually use it — not because it "decided" to overstep, but because the tool is sitting there during a review turn and the model reaches for whatever's available. We hit this directly: our own `code-reviewer` agent occasionally produced a diff instead of a verdict until we removed edit access from its definition entirely. Removing the tool fixed it; rewriting the prompt to say "don't edit" had not.

Second, **one giant agent means no routing.** Claude Code decides which subagent to invoke based on the description text in that agent's frontmatter. If one agent's description is "handle backend work" it will get routed to for schema changes, API routes, caching, and background jobs alike — and you lose the ability to say "this agent owns contracts, that one owns implementation." A flat list of specialist names hides this; the fix is explicit "do not" boundaries in each agent file, not longer descriptions. We cover the mechanics of that fix in [our subagent audit post](/blog/subagent-setup-audit-fixes).

The list below ranks subagents by how a solo founder actually uses Claude Code day to day — shipping a feature, fixing a bug, auditing security, writing the launch copy — not by novelty.

## The ranked list

| # | Agent | Trigger | Tools it needs | Model |
|---|---|---|---|---|
| 1 | [tech-lead](#1-tech-lead) | Starting a multi-file feature or a refactor | Read, Glob, Grep, Skill, Bash, TodoWrite | Opus |
| 2 | [code-reviewer](#2-code-reviewer) | Before every merge | Read, Glob, Grep, Skill, Bash, TodoWrite (no Edit) | — |
| 3 | [security-auditor](#3-security-auditor) | Before shipping anything touching auth, payments, or user data | Read, Glob, Grep, Skill, Bash, WebFetch, WebSearch | — |
| 4 | [backend-architect](#4-backend-architect) | Designing an API contract or data model before code exists | Read, Glob, Grep, Skill, Bash, TodoWrite (no Write/Edit) | — |
| 5 | [api-engineer](#5-api-engineer) | Implementing a route or integration against an existing contract | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 6 | [postgres-pro](#6-postgres-pro) | Schema changes, migrations, index tuning | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 7 | [debugger](#7-debugger) | A bug report with no obvious cause | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 8 | [test-automator](#8-test-automator) | After a feature ships, before the next one starts | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 9 | [billing-engineer](#9-billing-engineer) | Stripe webhooks, dunning, subscription state changes | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 10 | [devops-engineer](#10-devops-engineer) | CI/CD pipeline changes, deploy config | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 11 | [react-specialist](#11-react-specialist) | Any React 19 / Next.js component work | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 12 | [integration-engineer](#12-integration-engineer) | Wiring a third-party API or webhook consumer | Read, Write, Edit, Glob, Grep, Skill, Bash, WebFetch | — |
| 13 | [compliance-engineer](#13-compliance-engineer) | SOC2 prep, data-retention policy, audit trail work | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 14 | [sre-engineer](#14-sre-engineer) | Production incident, latency regression, uptime work | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 15 | [cloud-architect](#15-cloud-architect) | Infrastructure topology, scaling decisions | Read, Glob, Grep, Skill, Bash (no Write/Edit) | — |
| 16 | [onboarding-engineer](#16-onboarding-engineer) | Activation flow, first-run UX | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 17 | [support-engineer](#17-support-engineer) | Triaging a batch of customer tickets | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 18 | [seo-specialist](#18-seo-specialist) | New page, metadata, sitemap work | Read, Write, Edit, Glob, Grep, Skill, WebFetch, WebSearch | — |
| 19 | [technical-writer](#19-technical-writer) | API docs, changelogs, `/write-docs` runs | Read, Write, Edit, Glob, Grep, Skill, Bash | — |
| 20 | [qa-explorer](#20-qa-explorer) | Exploratory testing before a release | Read, Write, Glob, Grep, Skill, Bash (no Edit) | — |

### 1. tech-lead

The agent that decides *how* a feature gets decomposed before anyone writes code — architecture review, module boundaries, breaking a feature into safe PRs. Runs on `opus` because the job is judgment, not typing, and it deliberately has no `Write`/`Edit` grant: a tech lead that can also implement will approve its own design.

### 2. code-reviewer

Reads a diff, returns PASS/FAIL with reasoning, and nothing else. The single highest-leverage tool restriction in a 34-agent setup is dropping `Edit` from this one agent — see [the audit](/blog/subagent-setup-audit-fixes) for what happened before we did.

### 3. security-auditor

Scoped to read-only plus web access (`WebFetch`, `WebSearch` for checking a CVE or a library advisory) and explicitly no `Write`/`Edit` — it finds the problem, it doesn't fix it. That separation matters for the same reason code-reviewer's does: a security review that can also patch the code it's reviewing stops being an independent check.

### 4. backend-architect

Owns the contract — what an endpoint returns, how a schema is shaped — without touching the route file or writing the Zod validator. We learned the hard way that `backend-architect` and `api-engineer` overlapping on "design and implement backend logic" caused Claude to route the same task to either one inconsistently across runs; the fix was an explicit "do not implement" line in `backend-architect`'s file, not a longer description.

### 5. api-engineer

Implements the route file and request validation against a contract `backend-architect` already defined — and says so, rather than inventing a contract, if one doesn't exist yet. This is the half of the split that actually touches `Edit`.

### 6. postgres-pro

Schema design, indexing, migrations, RLS policy — and nothing about the route logic that sits on top of the table it's shaping. Full read/write access is appropriate here because the blast radius (a migration file) is narrow and reviewable.

### 7. debugger

Root-cause investigation: reproduce, isolate, fix. Needs the same tool set as a general implementer (`Read`, `Write`, `Edit`, `Bash`) because fixing the bug it finds is the job, not a separate hand-off.

### 8. test-automator

Writes and maintains the test suite — distinct from `qa-explorer` below, which does exploratory manual-style testing rather than writing durable specs. Run this right after a feature ships, before starting the next one, or test debt compounds the same way it does without an agent.

### 9. billing-engineer

Stripe webhook handlers, subscription state transitions, dunning logic — the one domain where a solo founder can least afford a subagent guessing. Pair this with [the stripe-billing-webhooks skill](/skills/stripe-billing-webhooks) for the actual webhook-handling conventions; the agent decides when billing logic needs touching, the skill constrains how.

### 10. devops-engineer

CI/CD config, deploy pipelines, environment variables — full read/write since the files it touches (workflow YAML, Dockerfiles) are small and diffable, unlike a production database.

### 11. react-specialist

Component work on React 19 / Next.js — the agent you want routed to for anything UI, so `backend-architect` and `postgres-pro` never touch a `.tsx` file by accident.

### 12. integration-engineer

Third-party API clients and webhook consumers specifically — not your own schema. The explicit boundary ("never your own schema") is what keeps it from overlapping with `postgres-pro`, the same overlap problem we found between `backend-architect` and `api-engineer`.

### 13. compliance-engineer

SOC2 evidence, data-retention policy, audit-trail requirements — a domain most solo founders ignore until a customer's security questionnaire forces the issue. Having a dedicated agent means the question "do we log this" gets asked before a feature ships, not during due diligence.

### 14. sre-engineer

Incident response and reliability work — paged at 2am territory, not feature work. Keep this agent's scope to "why did this break and how do we stop it recurring," distinct from `devops-engineer`'s "how is this deployed."

### 15. cloud-architect

Infrastructure topology and scaling decisions, read-only by design — it recommends, `devops-engineer` or `sre-engineer` implements. Mirrors the `tech-lead` pattern of judgment without edit access.

### 16. onboarding-engineer

First-run UX and activation flow — the part of the product most founders under-invest in because it's not a "feature" in the backlog sense. A dedicated agent keeps it from getting deprioritized against whatever's loudest that week.

### 17. support-engineer

Triages customer tickets and drafts fixes or responses — useful specifically when you're fielding support solo and need a first pass before you read the raw ticket queue yourself.

### 18. seo-specialist

Metadata, sitemap entries, new page structure — scoped with `WebFetch`/`WebSearch` so it can check what's actually ranking before writing another "best X" page, not just generate one from a template.

### 19. technical-writer

Docs and changelogs — and the agent we demoted from a standalone subagent to a step inside `/write-docs` in our own setup, because it never benefited from an isolated context window when it only ever ran at the tail of a chain that already had the code in context. Worth running as a true subagent only for a cold `/write-docs` call with nothing else loaded.

### 20. qa-explorer

Exploratory, interactive-style testing before a release — no `Edit` access, because its job is to find what's broken, not patch it, the same reviewer/implementer split as `code-reviewer` and `security-auditor`.

## The Explore → Plan → Code pattern, and when a subagent earns its slot

Most tasks in Claude Code don't need a subagent at all — the main thread with Explore (read-only search), a plan, then code is the default, and it's faster because there's no context-isolation overhead. Reach for a dedicated subagent only when one of two things is true:

- **The task needs a different permission boundary than the main thread.** A reviewer that structurally cannot edit, a security auditor that structurally cannot patch — the isolation is the point, not a convenience.
- **The task needs a distinct persona with its own required skills that would clutter the main thread's context if loaded inline.** `billing-engineer` pulling in Stripe-specific conventions on every invocation is useful when billing work is the task; it's dead weight loaded into a React component review.

If neither is true — the job only ever runs as the last step of a chain that already has the relevant context, the way `technical-writer` did for us — it's a skill or a command step, not a subagent. Isolating it just means re-reading what the chain already had.

## Agent Teams vs. subagents: what's actually different

"Agent Teams" and "subagents" get used interchangeably in a lot of 2026 writing on Claude Code, but they describe different things. A **subagent** is a single named agent definition — tech-lead, code-reviewer, billing-engineer — that Claude routes to for a specific task, runs in its own isolated context window, and returns a result to the calling thread. An **agent team**, as the term is generally used, is a *command or workflow* that orchestrates several subagents in a deliberate sequence or with explicit hand-offs — `/ship` invoking `tech-lead` to plan, then `backend-architect` and `api-engineer` to implement, then `code-reviewer` to check, then `test-automator` to cover it.

The distinction matters because the failure mode is different at each layer. A subagent fails when its own scope or tool grant is wrong (the overlap and over-permissioning problems above). A command/workflow fails when the *sequence* is wrong — the reviewer runs before the implementer finishes, or two agents claim the same step. Fixing a bad subagent means editing one agent file; fixing a bad team means editing the command chain that calls them in order.

## How to wire 20 subagents into a repo in one command

Writing 20 well-scoped agent files by hand — each with the right tool grant, the right explicit "do not" boundary, and a description specific enough that Claude's routing doesn't collide with another agent — is itself a multi-hour task before you write a line of product code. AgenticKit installs the engineering half of this list (22 agents total) with one command:

```
npx agentickit init --kit engineering
```

or `--kit both` if you also want the 12 marketing agents (positioning, SEO, copywriting) that pair with `seo-specialist` above. The [Kit Picker](/tools/kit-picker) maps a specific priority — "I need to ship billing this week," "I need to pass a security review" — to the exact agents and skills that cover it, rather than installing all 34 at once and loading context you don't need yet.

## FAQ

**How many subagents should a solo founder actually run?** There's no fixed number, but the signal to watch for is whether two agents' descriptions could plausibly claim the same task — if they can, you have one too many regardless of the total. We run 34 split into 22 engineering and 12 marketing, installed separately so a founder who only ships code never loads the marketing dozen into context.

**What's the single highest-leverage subagent to set up first?** `code-reviewer` without edit access. It's the cheapest to configure correctly and the one most likely to be mis-scoped by default, since most starter agent definitions give every agent every tool.

**Do subagents replace writing tests?** No — `test-automator` writes and maintains the suite, but a subagent recommending a fix is not the same guarantee as a passing test. Treat subagent output the way you'd treat a human reviewer's: useful, not infallible.

**Is a subagent the same as an MCP server?** No. An MCP server gives an agent new tools and live external access — a real Stripe API call, a real database query. A subagent is a role boundary and a context window; it uses whatever tools (including MCP-provided ones) its definition grants. See [our MCP server ranking](/blog/best-mcp-servers-claude-code-saas-founders) for the access-layer half of this stack.

**Should I use subagents in Cursor instead of Claude Code?** Cursor doesn't have the same named-subagent routing model as Claude Code; the closest equivalent is a Cursor rule scoped to a file pattern plus a custom command. If you're on Cursor, [our Cursor rules guide](/blog/best-cursor-rules-2026) covers the closest analog to the boundary-setting described here.

**What actually makes Claude Code auto-delegate to one of these agents instead of me naming it?** The phrasing of the agent's `description` field — "use proactively" plus a concrete trigger condition routes far more reliably than a role summary. See [Claude Code Subagents Best Practices](/blog/claude-code-subagents-best-practices) for the trigger-phrase mechanics and what each agent actually inherits from `CLAUDE.md`.

## Sources

- AgenticKit's own [agents directory](/agents), audited directly for tool grants and scope boundaries as of 2026-10-29 (first-party)
- [We Audited Our Own 34-Agent Claude Code Setup](/blog/subagent-setup-audit-fixes) — the overlap and over-permissioning findings this list is built on
- [How I Structured 34 AI Agents](/blog/how-i-structured-34-ai-agents) — the original engineering/marketing kit split

## Next steps

Start with `code-reviewer` scoped correctly (no edit access), add `security-auditor` before anything touching auth or payments, and only add the rest of the list as the work in front of you actually needs that persona. If you're deciding what to install first, [the Kit Picker](/tools/kit-picker) matches this week's priority to the agents and skills that cover it, and [the Agent Chain tool](/tools/agent-chain) shows which subagents would actually run, in order, before you commit to a 21st. The marketing-side agents (`seo-specialist`, `content-marketer`, `positioning-strategist`, `growth-strategist`) pair with the skill set covered in [Best Claude Code Skills for Solo Founder Marketing & SEO in 2026](/blog/best-claude-code-skills-marketing-seo-2026), and the full 20-role marketing roster is ranked separately in [20 Claude Code Agent Teams for Marketing, SEO, and Growth](/blog/claude-code-marketing-agent-team-2026).

_Written by Rakshit Yadav. Published 2026-10-30, last updated 2026-10-30._


## Related
- [agent-chain](https://www.agentickit.co/tools/agent-chain)
- [kit-picker](https://www.agentickit.co/tools/kit-picker)
- [tech-lead](https://www.agentickit.co/agents/tech-lead)
- [code-reviewer](https://www.agentickit.co/agents/code-reviewer)
- [security-auditor](https://www.agentickit.co/agents/security-auditor)
- [backend-architect](https://www.agentickit.co/agents/backend-architect)
- [api-engineer](https://www.agentickit.co/agents/api-engineer)
- [billing-engineer](https://www.agentickit.co/agents/billing-engineer)
- [project-conventions](https://www.agentickit.co/skills/project-conventions)
- [stripe-billing-webhooks](https://www.agentickit.co/skills/stripe-billing-webhooks)
- [/ship](https://www.agentickit.co/commands/ship)
- [/write-docs](https://www.agentickit.co/commands/write-docs)
