Everything Claude Code Slash Commands: Complete Guide to /plan, /tdd, /verify and More

Everything Claude Code provides 20+ slash commands defined as Markdown files in the commands/ directory, each invoking specialized agents like planner, tdd-guide, or verification-loop to automate software development workflows.

The affaan-m/everything-claude-code repository transforms Claude Code into a structured integrated development environment through declarative slash commands. These commands convert natural language instructions into automated workflows for planning, testing, building, and reviewing code, with each command specification living in version-controlled Markdown files.

Complete List of Everything Claude Code Slash Commands

The repository ships a comprehensive catalog of built-in slash commands located in the commands/ folder. Each *.md file defines a command's purpose, invocation pattern, and associated agent.

Core Development Workflow Commands

• /plan — Restates requirements, assesses risks, and creates step-by-step implementation plans. Invokes the planner agent defined in agents/planner.md.
• /tdd — Enforces test-driven development by scaffolding interfaces, generating failing tests, implementing minimal code, refactoring, and checking coverage. Invokes the tdd-guide agent.
• /code-review — Performs security and quality reviews of uncommitted changes using the code-reviewer agent.
• /build-fix — Incrementally detects and resolves build or type errors with minimal, safe changes via the build-error-resolver agent.
• /verify — Runs a comprehensive verification pipeline including build, type-check, lint, tests, and secret scanning through the verification-loop agent.

Testing and Quality Assurance Commands

• /e2e — Executes Playwright end-to-end test suites for critical user flows using the e2e-runner agent.
• /test-coverage — Runs the test suite with coverage reporting and enforces the 80% minimum threshold, leveraging the tdd-guide agent.
• /quality-gate — Runs the full verification pipeline and determines if code is ready for pull request approval.
• /eval — Defines and executes evaluation loops for capability and regression testing via the eval-harness agent.

Documentation and Knowledge Commands

• /skill-create — Analyzes git history and auto-generates SKILL.md files describing repository patterns. Uses the skill-creator tool.
• /update-docs — Refreshes generated documentation after code changes via the doc-updater agent.
• /update-codemaps — Regenerates internal code-map files that power knowledge-base lookups.
• /learn — Teaches or queries the system about topics by searching the repository and external documentation using the knowledge-retriever agent.

Language-Specific Build and Review Commands

• /gradle-build, /go-build, /rust-build, /kotlin-build — Invoke language-specific build agents and toolchains.
• /python-review, /go-review, /rust-review, /kotlin-review — Execute language-specific code review agents enforcing style, security, and best-practice rules.

Session and Process Management Commands

• /sessions, /save-session, /resume-session — Manage interactive Claude Code sessions with state persistence.
• /loop-start, /loop-status — Run long-running autonomous loops with progress monitoring via the loop-operator agent.
• /pm2 — Manage PM2 process manager tasks including start, stop, and restart operations.

Advanced Workflow Commands

• /orchestrate — Composes multiple commands into higher-level workflows (e.g., plan → tdd → build-fix → code-review).
• /refactor-clean — Performs automated dead-code cleanup and formatting fixes using the refactor-cleaner agent.
• /instinct-import, /instinct-status, /instinct-export — Manage "instinct" files encoding learned patterns for continuous learning.
• /harness-audit — Audits harness configuration for reliability and cost optimization.

How Slash Commands Work in Everything Claude Code

The command system operates through a declarative specification model where Markdown files serve as both documentation and executable configuration.

Command Processing Pipeline

When a user types /command <arguments> in the Claude Code chat interface, the runtime executes the following sequence:

1. File Lookup — The parser searches for commands/<command>.md in the repository root.
2. Front-matter Extraction — The system reads the YAML front-matter (delimited by ---) to extract the command's description and metadata.
3. Agent Resolution — The body of the Markdown file specifies which agent to invoke (e.g., planner, tdd-guide, verification-loop).
4. Context Passing — The runtime instantiates the referenced agent and passes the user's free-form argument string as operational context.
5. Workflow Execution — The agent executes its specialized workflow using the ECC toolbox (Bash, Read, Write, Grep, etc.).
6. Safety Checks — Commands like /plan, /tdd, and /build-fix pause for explicit user confirmation before modifying files.
7. Output Streaming — Results, reports, and artifacts stream back to the chat interface.

Agent Architecture

Agents are defined in separate Markdown files within the agents/ directory. Key agent specifications include:

• agents/planner.md — Logic for requirement analysis and implementation planning.
• agents/tdd-guide.md — Test-driven development workflow implementation.
• agents/code-reviewer.md — Security and quality check procedures.
• agents/verification-loop.md — Build, type-check, and test verification steps.
• agents/eval-harness.md — Evaluation and regression testing capabilities.

Practical Usage Examples

Planning a New Feature with /plan

Invoke the planner agent to analyze requirements before writing code:

/plan Add real-time notifications when a market resolves

The system reads commands/plan.md, invokes the planner agent, and returns a multi-phase implementation plan covering requirements, risks, and estimated effort. The user must confirm with yes or request modifications before any files are created.

Test-Driven Development with /tdd

Enforce TDD workflows for new functionality:

/tdd Create a function to compute market liquidity score

The tdd-guide agent executes the RED-GREEN-REFACTOR cycle:

1. Scaffolds the interface definition.
2. Writes failing tests (RED phase).
3. Generates minimal implementation (GREEN phase).
4. Refactors for clarity (REFACTOR phase).
5. Runs npm test -- --coverage to verify the 80% coverage threshold.

Pre-PR Verification with /quality-gate

Run the complete verification pipeline before submitting a pull request:

/quality-gate

This invokes the verification-loop agent to execute builds, type-checks, linting, tests, and secret scans. Output includes a pass/fail matrix and a "Ready for PR" status flag.

Automatic Skill Generation

Generate documentation from repository patterns:

/skill-create --commits 150 --output ./skills

The skill-creator tool analyzes the last 150 git commits, detects patterns (conventional commits, folder layouts, testing conventions), and writes a SKILL.md file to ./skills for onboarding new contributors.

Key Source Files and Architecture

Understanding the following files provides insight into the command-to-agent mapping:

File Path	Role
commands/*.md	Declarative specifications for every slash command
commands/plan.md	Definition of the /plan command and planner invocation
commands/tdd.md	TDD workflow specification and agent configuration
commands/verify.md	Verification pipeline command definition
agents/planner.md	Implementation logic for requirement planning
agents/tdd-guide.md	Test-driven development agent workflow
agents/code-reviewer.md	Security and quality review procedures
agents/verification-loop.md	Build and test verification implementation
playwright.config.ts	Playwright configuration for /e2e command
package.json	NPM scripts referenced by build and test commands

Summary

• Everything Claude Code provides 20+ slash commands stored as Markdown files in the commands/ directory, making them self-documenting and version-controlled.
• Each command invokes a specialized agent (e.g., planner, tdd-guide, verification-loop) defined in the agents/ folder to execute specific workflows.
• The /plan, /tdd, and /build-fix commands include safety checkpoints requiring user confirmation before file modifications.
• Language-specific commands like /go-build and /python-review provide tailored toolchain integration for polyglot development.
• The /quality-gate and /verify commands enforce the repository's 80% test coverage requirement and comprehensive validation pipelines.

Frequently Asked Questions

How do I add a custom slash command to Everything Claude Code?

Create a new Markdown file in the commands/ directory following the existing front-matter structure. Define the command's purpose in the YAML header and specify which agent to invoke in the body. The system automatically recognizes the file as a new /command without requiring registration steps.

What is the difference between /verify and /quality-gate?

The /verify command runs the comprehensive verification pipeline (build, type-check, lint, tests, secret scan) and reports results, while /quality-gate performs the same checks but adds a final "Ready for PR" decision gate. Use /verify for quick checks and /quality-gate when preparing to merge code.

Which agent handles the /tdd command workflow?

The tdd-guide agent, defined in agents/tdd-guide.md, manages the complete test-driven development workflow. It orchestrates the RED-GREEN-REFACTOR cycle, enforces the 80% coverage minimum, and ensures tests are written before implementation code.

Can I run slash commands without user confirmation?

Most modification commands like /plan, /tdd, and /build-fix require explicit user confirmation (typing yes) before writing files to prevent unintended changes. Read-only commands like /verify, /code-review, and /learn execute immediately without confirmation prompts.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}