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

> Discover how slash commands in the agent-skills repo streamline the development lifecycle, mapping directly to each phase from definition to deployment.

- Repository: [Addy Osmani/agent-skills](https://github.com/addyosmani/agent-skills)
- Tags: how-to-guide
- Published: 2026-04-16

---

**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`](https://github.com/addyosmani/agent-skills/blob/main/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`](https://github.com/addyosmani/agent-skills/blob/main/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`](https://github.com/addyosmani/agent-skills/blob/main/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`](https://github.com/addyosmani/agent-skills/blob/main/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:

```text
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:

```text
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)

```markdown
/spec

```

*Triggers* `spec-driven-development` → Creates [`SPEC.md`](https://github.com/addyosmani/agent-skills/blob/main/SPEC.md) and establishes the **DEFINE** phase.

```markdown
/plan

```

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

```markdown
/build

```

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

```markdown
/test

```

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

```markdown
/review

```

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

```markdown
/ship

```

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

### Implicit Lifecycle with OpenCode (No Slash Commands)

```text
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`](https://github.com/addyosmani/agent-skills/blob/main/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`](https://github.com/addyosmani/agent-skills/blob/main/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`](https://github.com/addyosmani/agent-skills/blob/main/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`](https://github.com/addyosmani/agent-skills/blob/main/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`](https://github.com/addyosmani/agent-skills/blob/main/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`](https://github.com/addyosmani/agent-skills/blob/main/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`](https://github.com/addyosmani/agent-skills/blob/main/README.md) lines 20-30, while the OpenCode-specific behavior regarding slash command replacement is documented in [`docs/opencode-setup.md`](https://github.com/addyosmani/agent-skills/blob/main/docs/opencode-setup.md) lines 84-88.