Claude Code Skills vs. Subagents vs. Commands: A Decision Guide for SaaS Founders

By Rakshit Yadav (@yadavrakshit60)•Oct 2026•9 min read

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 /ship or /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 the Task tool, each starts a fresh context window with its own system prompt and a scoped tool list (frontmatter sets name, description, tools). The point isn't speed — it's that a code-reviewer subagent with no Edit access 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."

  1. 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.

  2. 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.

  3. 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

TaskPrimitiveWhy
Verify Stripe webhook signatures and handle events idempotentlySkill (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 diffCommand (/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 mainCommand (/ship)A fixed sequence you'd otherwise type by hand every release
Review a PR for security issues with read-only tool accessSubagent (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 guideSkill (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

🛠️ Free Tool: kit-picker🛠️ Free Tool: agent-chain🤖 Agent: tech-lead🤖 Agent: backend-architect🤖 Agent: security-auditor⚡ Command: /ship⚡ Command: /pr-descriptionSkill: project-conventionsSkill: stripe-billing-webhooks

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 →