# Best Claude Code Commands for Shipping a SaaS MVP in 2026

> 12 Claude Code custom commands for a solo SaaS founder, a full example .claude/commands/ship.md file, and how commands differ from skills and subagents.

Canonical: https://www.agentickit.co/blog/best-claude-code-commands-examples
Last updated: 2026-10-31

**Short answer:** a Claude Code custom command is a markdown file in `.claude/commands/` — type `/` in a Claude Code session and the filename becomes the command name. Below are 12 commands worth having for a solo SaaS founder, grouped by job, each with what it actually does, plus a full example file for `/ship` and the mistakes that make a command catalog useless.

Claude Code's own docs call these "slash commands," and the on-disk format is identical to Cursor's `.cursor/commands/` convention — same markdown-file-as-prompt model, different folder. If you're also running Cursor, [the 20-command Cursor list](/blog/best-cursor-slash-commands) covers the same ground for that folder; this one is the Claude Code-primary version with Claude Code's own frontmatter options (`argument-hint`, `allowed-tools`, `model`).

## What a Claude Code custom command actually is

```
.claude/commands/
  ship.md          ->  /ship
  build-api.md     ->  /build-api
  release.md       ->  /release
```

The file body is the prompt Claude runs when you type `/name`. Unlike a bare Cursor command, Claude Code commands support YAML frontmatter that constrains how the command runs:

```yaml
---
argument-hint: [feature description]
allowed-tools: Read, Grep, Glob, Edit, Write, Bash(npm test:*)
model: opus
---
```

- **`argument-hint`** — shown in the `/` autocomplete so you remember what to type after the command name.
- **`allowed-tools`** — scopes which tools the command can invoke without a permission prompt. A review command that only needs `Read, Grep, Glob` shouldn't also carry `Edit, Write`.
- **`model`** — pins the command to a specific model (e.g. `opus` for a multi-file feature build, a cheaper model for a mechanical pass) instead of inheriting whatever the session is set to.

None of this is required — a command with no frontmatter at all still works, the body is just the prompt. Frontmatter becomes worth adding once a command does something risky enough (writing files, running shell commands) that you want to scope it.

| Location | Scope | Use it for |
| --- | --- | --- |
| `.claude/commands/` in the repo | This project, committed to git | Commands that reference your stack, folders, or conventions |
| `~/.claude/commands/` | Every project on your machine | Personal habits that don't depend on the repo |

Commit anything you depend on in CI or a headless Claude Code run to the repo's `.claude/commands/` — a run outside your own machine won't see `~/.claude/commands/`.

## 12 best commands for a solo SaaS founder

These are the AgenticKit catalog commands most reached for, each backed by a scoped agent pipeline rather than a single generic prompt.

### Build

**[`/ship`](/commands/ship)** — plan through a working, tested slice for one feature end to end: spec, schema migration, API, UI, tests, docs, in one turn.

**[`/build-api`](/commands/build-api)** — a single route with a typed contract and validation, when the data model already exists.

**[`/build-page`](/commands/build-page)** — a UI view against an API that's already built, instead of relitigating the backend.

**[`/stripe-billing`](/commands/stripe-billing)** — wire up Stripe checkout, webhooks, and subscription state without duplicating logic Stripe already owns.

**[`/auth-system`](/commands/auth-system)** — session handling, protected routes, and the auth tables, built to your stack's conventions instead of a generic tutorial's.

### Verify

**[`/audit`](/commands/audit)** — a pre-release sweep of a folder of routes: security, missing tests, dead code. Not a daily linter — run it before a release, not on every commit.

**[`/qa-pass`](/commands/qa-pass)** — exercise the actual user flows for a feature before it ships, not just the unit tests around it.

**[`/e2e-suite`](/commands/e2e-suite)** — Playwright coverage for a path that touches money or auth, scoped to that path rather than every page in the app.

### Operate

**[`/release`](/commands/release)** — a changelog generated from git history since the last tag, so shipping something doesn't mean no record of it exists.

**[`/pr-description`](/commands/pr-description)** — a PR description written from the actual diff and commit messages, nothing invented.

### Grow

**[`/seo-fix`](/commands/seo-fix)** — fix the specific on-page SEO issues an audit already found (title, canonical, headings, schema) instead of a vague "improve SEO" prompt.

**[`/whats-new`](/commands/whats-new)** — turn a real shipped diff into changelog, email, and social copy, checked against the diff so it doesn't claim features that aren't there.

## Full example: the `/ship` command file

This is the actual shape of `.claude/commands/ship.md` in the AgenticKit catalog — frontmatter plus a prompt that names the pipeline explicitly instead of leaving it to the model to improvise:

```markdown
---
argument-hint: [feature description]
allowed-tools: Read, Grep, Glob, Skill, TodoWrite, Task, Edit, Write, Bash(npm test:*), Bash(npm run build:*), Bash(git status:*), Bash(git diff:*)
model: opus
---

Ship this feature end to end: $ARGUMENTS

1. tech-lead parses the request against CLAUDE.md conventions and writes a short technical spec.
2. backend-architect drafts any schema or migration changes needed.
3. api-engineer implements typed API endpoints with validation.
4. react-specialist builds the UI components and wires them to the API.
5. test-automator writes unit and e2e tests for the new path.
6. technical-writer updates docs and the changelog.

Do not skip the spec step even for a small feature. Do not touch files outside
the feature's scope. Stop and report back if a step reveals the request is
actually two features, not one.
```

The `$ARGUMENTS` placeholder is what you type after `/ship` — e.g. `/ship add CSV export for the invoices table` — and the "do not" lines exist because without them the model happily widens scope mid-task.

## How commands differ from skills and subagents

A command only runs when you type it. A **skill** (`SKILL.md`) is loaded by the model on its own when its description matches what you're doing — no typing required, and it can bundle reference files a single command file can't. A **subagent** is a separate context the model delegates to with its own scoped tool access, usually invoked from inside a command or skill rather than directly by you.

The three-way distinction, and where hooks fit in as the fourth, event-triggered mechanism, is covered in more depth in [Rules vs Skills vs Commands vs Hooks](/blog/rules-vs-skills-vs-commands-vs-hooks) (written for Cursor's rule format but the commands/skills/hooks split applies identically to Claude Code). If the question is specifically about running agents in parallel versus delegating to one at a time, [Claude Code Agent Teams vs. Subagents](/blog/claude-code-agent-teams-vs-subagents) has the decision table for that.

## Arguments and context: making a command take input

Most of the commands above take an argument — the thing after the command name. `$ARGUMENTS` in the file body is replaced with whatever you typed, so `/build-api add a refund endpoint` and `/build-api add a webhook receiver` run the same pipeline against two different specs without you editing the file. If a command needs more structure than one freeform string — say, a target file plus a description — reference named positional args (`$1`, `$2`) the same way a shell script would, and document the expected order in `argument-hint` so the autocomplete reminds you.

A command can also read files directly rather than relying on what you paste in: a line like "read the schema at `prisma/schema.prisma` before proposing a migration" inside the prompt body works, because the prompt is just instructions the model follows with its normal tool access — scoped by whatever `allowed-tools` permits.

## Common mistakes: commands that should be skills instead

- **A command you keep forgetting to type.** If `/code-review` only runs when you remember to type it before merging, and you forget half the time, that's a sign the review should be a skill the model loads automatically on a matching task, not a command waiting for you.
- **One command, five jobs.** A `/ship` that also runs the security audit, writes the changelog, and drafts a tweet will do all four worse than four separate commands would. Split by job: `/ship`, `/audit`, `/release`, `/whats-new`.
- **No "do not" line.** "Write tests" invites the model to also refactor the function under test while it's in there. "Write tests, do not change production code" closes that door — every command above should have at least one explicit boundary like it.
- **Grow commands with no brand voice doc behind them.** `/whats-new` and `/seo-fix` assume positioning and tone are already written down somewhere. If they aren't, the command either stalls asking, or invents a voice nobody approved.
- **Relying on `~/.claude/commands/` for something CI needs.** That folder lives on your machine only. A headless Claude Code run in CI won't see it — commit anything load-bearing to `.claude/commands/` in the repo.

## FAQ

**What is a Claude Code custom command?** A markdown file in `.claude/commands/` (or `~/.claude/commands/` for global) whose filename becomes the `/name` you type. The file body is the prompt; optional YAML frontmatter can set `argument-hint`, `allowed-tools`, and `model`.

**Do Claude Code commands need frontmatter?** No — a bare prompt file works. Frontmatter is worth adding once a command does something that should be scoped, like writing files or running shell commands.

**How many commands should I start with?** The 5-6 you'd actually type this week beat 12 installed and unused: `/ship`, `/audit`, `/release`, plus whichever of `/build-api`, `/stripe-billing`, or `/auth-system` matches what you're building right now.

**What's the difference between a command and a skill in Claude Code?** A command runs only when you type it. A skill is loaded by the model automatically when its description matches the task — no typing needed. If you keep forgetting to invoke something, make it a skill.

**Can I use the same command file in Cursor and Claude Code?** The format (frontmatter + markdown prompt) is similar but the folders differ: `.claude/commands/` for Claude Code, `.cursor/commands/` for Cursor. AgenticKit installs matching copies into both.

## Get all of them in one install

AgenticKit installs the full command catalog — including every one named above — with the agents and skills behind them, into `.claude/` and `.cursor/`. Browse the full [commands catalog](/commands).

```bash
npx agentickit-cursor init --target claude
```

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


## Related
- [slash-prompt](https://www.agentickit.co/tools/slash-prompt)
- [agent-chain](https://www.agentickit.co/tools/agent-chain)
- [tech-lead](https://www.agentickit.co/agents/tech-lead)
- [code-reviewer](https://www.agentickit.co/agents/code-reviewer)
- [backend-architect](https://www.agentickit.co/agents/backend-architect)
- [project-conventions](https://www.agentickit.co/skills/project-conventions)
- [prompt-engineering](https://www.agentickit.co/skills/prompt-engineering)
- [/ship](https://www.agentickit.co/commands/ship)
- [/audit](https://www.agentickit.co/commands/audit)
- [/release](https://www.agentickit.co/commands/release)
