All Forge commands are slash commands in Claude Code. Run any command without arguments to see its options and current context.
These are the commands you'll use most often.
Initialize Forge in your project.
Creates .forge-context/ with starter templates and
context files. Analyzes your project to pre-populate
context, then asks you to confirm before writing.
Run when: Starting Forge in a new project.
Start or continue an effort.
Creates a new effort directory under
.forge-context/efforts/YYYYMM-{slug}/ or resumes
work on an existing effort. Helps you explore a
problem space, capture user stories, and identify
slice candidates.
Subcommands:
new— Create a new effort
Run when: Exploring a problem before committing to a solution.
Start or continue a slice.
Creates a new slice directory under
.forge-context/slices/YYYYMM-{slug}/ or resumes
work on an existing slice. Routes to the right phase
based on what's already been done.
Subcommands:
new— Create a new slicestatus— Show current phase and progress
Run when: Building and delivering focused work.
Ad-hoc changes without slice ceremony.
For quick improvements, fixes, and enhancements that don't need a full slice. Creates a worktree and helps you make and commit a change.
Run when: Making a targeted change that doesn't need requirements or design phases.
Investigate a bug or issue.
Systematically explores a problem, identifies root cause, and produces an investigation report.
Run when: Debugging an issue before deciding how to fix it.
Summarize recent planning activity.
Produces a human-readable summary of recent effort and slice work. Useful for standups, status updates, or just catching up after time away.
Key arguments:
--days N— Summarize last N days (default: 7)--scope effort|slice|all— Limit scope
Restructure commits into atomic, reviewable units.
Takes a messy commit history and reorganizes it into logical, well-described commits that tell a coherent story. Includes suggested human review depth per commit (skim, read, or verify).
Commands for specific phases and workflow steps.
Run the requirements gathering phase.
Guides an AI-assisted conversation to draft a requirements document. Covers summary, success criteria, scope boundaries, and open questions.
Run when: Starting Phase 1 of a slice.
Run the design phase.
Guides an AI-assisted conversation to draft a design document. Covers architecture, component changes, alternatives, testing strategy, and task breakdown.
Run when: Starting Phase 2 of a slice.
Start work on an implementation task.
Sets up working context for a specific task from
tasks.md. Helps track progress and follows
implementation disciplines (TDD, systematic
debugging, verification before complete).
Run when: Starting Phase 3 of a slice.
Capture a process observation without interrupting your current workflow.
Records a correction, gap, or improvement idea to
a retro notes file. Applied later by /forge:improve.
Run when: Noticing something about the workflow that could be better.
Apply retro notes as improvements.
Reviews accumulated retro notes and applies them to the relevant files (templates, context files, guidelines). Each note is presented for review before applying.
Run when: Periodically, to act on retro notes.
Complete a slice phase with a review summary.
Marks a phase as complete by creating a review document and committing it. This is how Forge derives phase state — from git artifacts, not checkbox state.
Run when: Finishing requirements or design and moving to the next phase.
Process PR discussions.
Reads open discussions on a PR and routes them to the right place: applies code changes, updates documents, or marks discussions as resolved.
Run when: Addressing reviewer feedback on a PR.
Commands for health checks and upkeep.
Health checks on work and context.
Audit types:
work— Check slice and effort healthcontext— Check if context files are currentall— Both
Key flags:
--deep— More thorough analysis
Run when: Checking if your Forge setup is healthy, especially after extended time away.