How Slash Commands Map to the Development Lifecycle in the Agent-Skills Repository

Slash commands in the agent-skills repository serve as human-readable shortcuts that trigger specific skills corresponding to distinct phases of the software development lifecycle, from definition through deployment.

The addyosmani/agent-skills repository encodes a complete software-development workflow as a set of reusable skills. In the original Claude Code environment, developers invoke these skills through simple slash commands like /spec, /plan, and /build. Each command maps directly to a specific lifecycle phase and activates the corresponding skill logic that enforces process standards, required checks, and evidence collection.

The One-to-One Mapping Between Slash Commands and Lifecycle Phases

According to the repository documentation in README.md lines 20-30, seven primary slash commands align with six distinct lifecycle phases. The following table shows the explicit relationship between the command you type, the phase it represents, and the underlying skill that executes:

Slash Command	Lifecycle Phase	Skill Triggered
/spec	DEFINE	spec-driven-development
/plan	PLAN	planning-and-task-breakdown
/build	BUILD	incremental-implementation + test-driven-development
/test	VERIFY	debugging-and-error-recovery
/review	REVIEW	code-review-and-quality
/code-simplify	REVIEW	code-simplification
/ship	SHIP	shipping-and-launch

This mapping is not merely cosmetic. As documented in AGENTS.md lines 32-44, each slash command acts as a façade that instantiates the corresponding skill with the proper context, ensuring that the workflow progresses through the correct lifecycle gates.

How Each Slash Command Activates Specific Skills

The relationship between slash commands and the development lifecycle becomes clearer when examining how specific commands trigger skill execution and enforce phase requirements.

/spec and the DEFINE Phase

When you enter /spec, the system invokes the spec-driven-development skill. This command initializes the DEFINE phase by creating a SPEC.md file that documents requirements, scope, and acceptance criteria. The skill enforces that no code is written until the specification is complete, establishing the foundation for the entire lifecycle.

/plan and the PLAN Phase

The /plan command triggers planning-and-task-breakdown, which decomposes the specification into atomic tasks stored in a tasks/ directory. Each task includes specific acceptance criteria, creating a verifiable roadmap that guides subsequent implementation phases.

/build and the BUILD Phase

Entering /build activates both incremental-implementation and test-driven-development skills. This command moves the lifecycle into the BUILD phase, where the agent produces vertical slices of code, commits them incrementally, and runs initial tests to validate each slice against the acceptance criteria defined earlier.

/test and the VERIFY Phase

The /test command explicitly targets the VERIFY phase by invoking debugging-and-error-recovery. This skill runs the full test suite, validates results against expectations, and records proof of correctness. It handles failure scenarios through systematic reproduction, localization, and resolution of issues.

/review and the REVIEW Phase

Both /review and /code-simplify map to the REVIEW phase, but they trigger different quality skills. The /review command activates code-review-and-quality, which performs a five-axis review covering correctness, security, performance, maintainability, and testing coverage. The /code-simplify command specifically targets readability and complexity reduction through the code-simplification skill.

/ship and the SHIP Phase

Finally, /ship triggers shipping-and-launch, which executes launch checklists, verifies deployment readiness, and manages the transition from development to production. This command ensures all previous lifecycle phases have produced required artifacts and evidence before deployment proceeds.

From Explicit Commands to Intent-Driven Execution

While slash commands provide explicit control in Claude Code, the repository also supports OpenCode integration, which preserves the same lifecycle flow while removing the need for explicit command syntax.

As documented in docs/opencode-setup.md lines 84-88, OpenCode "replaces slash commands like /spec, /plan, etc." with automatic intent-driven skill selection. Instead of typing /spec, you simply describe your goal:

User: "Add OAuth login to the app"

The agent analyzes the natural language request, detects that this is a new feature requiring specification, and automatically selects spec-driven-development. It then proceeds through planning-and-task-breakdown, incremental-implementation, test-driven-development, and finally shipping-and-launch without explicit human intervention at each transition.

Similarly, for debugging scenarios:

User: "Fix the 500 error on /api/users"

The agent recognizes this as a bug report and immediately invokes debugging-and-error-recovery, skipping directly to the VERIFY phase to reproduce, localize, and resolve the issue.

Code Examples: Executing the Development Lifecycle

The following examples demonstrate how slash commands translate to skill execution and lifecycle progression.

Explicit Command Sequence (Claude Code Style)

/spec

Triggers spec-driven-development → Creates SPEC.md and establishes the DEFINE phase.

/plan

Triggers planning-and-task-breakdown → Generates atomic tasks in tasks/ directory with acceptance criteria (PLAN phase).

/build

Triggers incremental-implementation and test-driven-development → Produces vertical code slices with commits and initial tests (BUILD phase).

/test

Triggers debugging-and-error-recovery → Runs test suite and validates results (VERIFY phase).

/review

Triggers code-review-and-quality → Performs five-axis quality review before merge (REVIEW phase).

/ship

Triggers shipping-and-launch → Executes launch checklist and deploys to production (SHIP phase).

Implicit Lifecycle with OpenCode (No Slash Commands)

User: "Refactor the payment module to reduce cyclomatic complexity"

Agent reasoning → Detects code improvement intent → selects code-simplification (REVIEW phase) → analyzes complexity, applies refactorings, runs tests to verify behavior preservation.

These examples illustrate how the slash commands provide a manual interface to the lifecycle, while OpenCode achieves identical outcomes through automatic intent recognition.

Summary

• Slash commands are direct mappings to software development lifecycle phases (DEFINE, PLAN, BUILD, VERIFY, REVIEW, SHIP) as defined in README.md lines 20-30.
• Each command triggers specific skills that enforce process requirements, evidence collection, and quality gates for their respective phases.
• AGENTS.md lines 32-44 documents the core rule set and lifecycle-to-skill relationship, including the explicit mapping that binds commands to phases.
• OpenCode integration (documented in docs/opencode-setup.md lines 84-88) replaces explicit slash commands with automatic intent detection while preserving the same underlying lifecycle flow.
• The repository supports both explicit and implicit execution modes, allowing developers to manually progress through phases with slash commands or allow the agent to manage lifecycle transitions automatically based on natural language requests.

Frequently Asked Questions

What slash commands are available in the agent-skills repository?

The repository defines seven primary slash commands: /spec, /plan, /build, /test, /review, /code-simplify, and /ship. These commands are listed in README.md lines 20-30 and correspond to the six phases of the development lifecycle: DEFINE, PLAN, BUILD, VERIFY, REVIEW, and SHIP.

How does the /build command differ from the /test command in the development lifecycle?

The /build command activates the BUILD phase by triggering both incremental-implementation and test-driven-development skills to write code incrementally. In contrast, the /test command targets the VERIFY phase by invoking debugging-and-error-recovery to run existing tests, validate functionality, and resolve failures. While /build creates code with tests, /test validates existing code against requirements.

Can I use slash commands with OpenCode, or are they only for Claude Code?

Slash commands are explicitly designed for the Claude Code environment. According to docs/opencode-setup.md lines 84-88, OpenCode does not support slash commands directly; instead, it replaces them with automatic intent-driven skill selection. You describe your goal in natural language, and OpenCode determines which lifecycle phase and skills to activate without requiring explicit /spec or /plan syntax.

Where is the lifecycle-to-skill mapping defined in the source code?

The authoritative mapping between lifecycle phases and skills is defined in AGENTS.md lines 32-44, which explains how the development lifecycle is encoded implicitly within the skill system. The visual representation and command list appear in README.md lines 20-30, while the OpenCode-specific behavior regarding slash command replacement is documented in docs/opencode-setup.md lines 84-88.

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