← Back to Guides · CLAUDE CODE
Claude Code Skills vs. Subagents vs. Commands: A Decision Guide for SaaS Founders
Short answer: write a command when you're automating something you'd type by hand every time anyway ("generate a PR description," "run the release checklist") — it's a static .md prompt in .claude/commands/ that runs on demand and shares your main context. Write a subagent when the job needs to happen in isolation — a bounded task with its own context window and a restricted tool list, so a reviewer can't accidentally edit the file it's reviewing. Write a skill when the expertise needs files alongside it — reference docs, scripts, templates — that get loaded only when the task actually calls for them, instead of bloating every prompt. Most founders don't need a flowchart to pick between three abstract categories; they need three questions answered about the one task in front of them.
The one-sentence rule for each primitive
- Commands (
.claude/commands/*.md) are on-demand actions. You type/shipor/pr-description, Claude Code runs that prompt in your current conversation, with your current context. No isolation, no bundled files — just a reusable instruction. - Subagents (
.claude/agents/*.md) are isolated specialists. Invoked via theTasktool, each starts a fresh context window with its own system prompt and a scoped tool list (frontmatter setsname,description,tools). The point isn't speed — it's that acode-reviewersubagent with noEditaccess literally cannot modify what it's reviewing. - Skills (
.claude/skills/*/SKILL.md) are packaged expertise. A skill bundles a markdown instruction file with whatever it needs to do the job right — a Stripe API reference, a SQL migration template, a linting script — and Claude Code loads it only when the task matches, rather than stuffing all of that into your system prompt permanently.
The distinction that actually matters day to day: commands and subagents are about when and where code runs (now vs. isolated, in-context vs. out-of-context); skills are about what reference material ships with the instruction. A command can invoke a subagent. A subagent can use a skill. They compose — the question is never "pick exactly one forever," it's "which one is right for this specific task."
A 3-question decision tree
Answer these in order; stop at the first "yes."
-
Does doing this correctly require files — docs, scripts, or templates — beyond a single prompt? Yes → skill. Example: a Stripe webhook integration needs the raw-body signature-verification snippet, the idempotency-key pattern, and your subscription-state schema sitting next to the instructions, not re-typed into a prompt every time.
-
Does this need to run isolated from your main conversation — its own context, restricted tools, or in parallel with other work? Yes → subagent. Example: an SEO content audit that reads forty pages of markdown shouldn't dump forty files into your main context window; a subagent does that exploration, isolated, and hands back a short report.
-
Is this just "run this exact prompt, in my current context, whenever I ask"? Yes → command. Example: "write a PR description from my current diff" doesn't need isolation or bundled reference files — it needs a reusable prompt you can type as
/pr-description.
If you answered "yes" to more than one, that's not a bug in the tree — it means compose them. A /ship command can be the entry point that delegates bounded subagent reviews partway through, and one of those subagents can lean on a skill for domain-specific reference material. That's exactly how AgenticKit's own /ship command works.
Real SaaS-founder examples
| Task | Primitive | Why |
|---|---|---|
| Verify Stripe webhook signatures and handle events idempotently | Skill (stripe-billing-webhooks) | Needs a bundled raw-body verification snippet and idempotency pattern — reference material, not just an instruction |
| Write a PR description from the current diff | Command (/pr-description) | One-shot prompt, runs in your current context, no isolation needed |
| Audit a page's on-page SEO (title, meta, headings, internal links) | Subagent (seo-auditor) | Bounded, read-heavy exploration you don't want bloating your main thread — isolate it, get back a report |
| Run your release checklist before merging to main | Command (/ship) | A fixed sequence you'd otherwise type by hand every release |
| Review a PR for security issues with read-only tool access | Subagent (security-auditor, tools: Read, Grep, Glob) | The isolation is the safety boundary — this agent literally cannot call Edit |
| Generate on-brand marketing copy using your positioning doc and voice guide | Skill (brand-voice) | The voice guide and example copy are files that need to travel with the instruction |
Common mistakes
Cramming 20 skills into one mega-agent. A subagent that tries to load every skill "just in case" tanks response quality for the same reason a 40-tab browser tanks your laptop — each loaded skill adds to the context the model has to reason over, diluting attention away from the task at hand. Scope skills tightly to the subagent that actually needs them; a backend-architect doesn't need the brand-voice skill loaded, ever.
Writing a subagent when you meant a command. If the "task" is just "run this prompt in my current context," a subagent adds a cold-start isolation cost for no benefit — the delegating prompt has to carry everything the subagent needs since it starts with zero conversation history, and the output still has to get read back into your main thread anyway. That's pure overhead for something a command does in one step.
Writing a command when you meant a skill. If a "command" keeps growing a wall of reference material pasted into the prompt body — API docs, a schema, example payloads — that's a sign the reference material belongs in a skill's bundled files instead, loaded on demand rather than re-sent on every invocation.
Skipping tool restriction on subagents that should have it. A subagent that reviews code but is given full Edit/Write/Bash access isn't actually isolated in the way that matters — the frontmatter tools field is the actual safety boundary, not a formality. If the job is "review, don't touch," the tool list should enforce that, not just the instruction text.
Where this maps to AgenticKit's prebuilt team
AgenticKit installs all three primitives pre-wired rather than making you choose from scratch: 22 engineering and 12 marketing subagents in .claude/agents/*.md with scoped tools per role, a command catalog in .claude/commands/*.md (/ship, /audit, and others — see the full command catalog), and a skills set covering both engineering patterns and the marketing/SEO gap most dev-focused skill roundups skip entirely (see the 11 marketing & SEO skills founders actually need). The roster is split the way it is specifically so you don't have to answer "subagent, skill, or command?" cold for every new task — tech-lead already routes a feature through the right mix, delegating bounded subagent reviews and pulling in skills only when a task matches one. For the deeper distinction between a single subagent and a full parallel Agent Team, see Agent Teams vs. Subagents.
FAQ
Can a command invoke a subagent? Yes — a command is just a prompt, and that prompt can instruct Claude Code to delegate part of the work to a subagent via the Task tool. /ship is a practical example: one command, which fans out to backend-architect, api-engineer, and test-automator as the task requires.
Can a subagent use a skill? Yes. A subagent's system prompt can reference a skill the same way your main conversation can — the subagent just needs the skill's files available in its scoped context.
Do I need all three to get started? No. Most solo founders start with a handful of commands for repeated actions, add subagents once a task genuinely needs isolation (usually a review or audit step), and add skills last, once a recurring task keeps needing the same reference files re-pasted.
What's the actual failure mode of getting this wrong? Not a crash — degraded output. An over-loaded subagent with too many skills gives vaguer, less targeted answers; a subagent used where a command would do adds cold-start overhead and loses your conversation's context for no gain; a command stuffed with reference material that should be a skill gets harder to maintain as that material drifts out of date in multiple places.
Is this the same distinction Cursor makes with its own "skills"? No — Cursor's rules/skills model maps roughly onto Claude Code's skills and commands but isn't a 1:1 mapping, and Cursor doesn't have a direct subagent/Task-tool equivalent with the same isolation guarantees. Treat the two ecosystems' primitives as similar in spirit, not interchangeable in mechanics.
Next steps
If you're staring at a task and not sure which primitive fits, run it through the three questions above in order — most tasks resolve on question one or two without needing the full tree. If you're setting up a new project rather than picking one primitive at a time, the engineering org map and the skills catalog show AgenticKit's prebuilt roster, which is wired so the choice is usually already made for you.
Related Tools & Agents
Not sure which primitive your task needs?
Kit Picker scans your repo and suggests the commands, subagents, and skills to install — so you're not deciding from a blank page.
Try Kit Picker →