Claude Code Slash Commands · page 7

Validate that vulnerability findings are real, reachable, and exploitable

Web application security scanner (alpha)

One-shot MAXIMAL autonomous pentest — the full scan+validate pipeline PLUS a parallel red-team agent war-game, adversarially verified and stitched into a kill-chain Red Team Report.

Commit what is already staged — runs the commit subagent in the background, following the ATLAS commit convention.

Interview Boss about the project, then reason from first principles to design the ideal ATLAS operating identity/system-prompt for it — free to drop KISS/YAGNI/DRY/clean-architecture entirely when the project (and the LLM's own distribution) calls for a different mindset

Initialize project context — understand the project, configure conventions, and set up project rules

Brainstorm an idea into a clickable multi-screen React prototype — model the mind (Theory of Mind), interview to kill ambiguity, build a no-build CDN-React prototype under misc/prototypes/, run it, iterate until it matches Boss's vision.

Quickly sketch a standalone low-fidelity wireframe as self-contained HTML — gray boxes, dashed borders, no framework. Lighter than /plan:create-phase, static unlike /brainstorm:prototype.

Discover the project's visual identity, prototype 3 HTML design variants for Boss to compare in a browser, iterate, then lock in DESIGN.md (Stitch-format, machine + human readable). The single source of truth AI coding agents read before generating UI.

Show recent git commits with a brief summary and continual context tied to the working directory / staging area.

Stage and commit all working-directory changes — runs the commit subagent in the background until the tree is clean.

Create a development phase the lean way — resolve ambiguity through Q&A, then capture it as a self-contained low-fidelity wireframe HTML document you implement from in plan mode

Guided feature development with codebase understanding and architecture focus

Author human-readable manual test cases (markdown) into docs/living-test-cases/ — the living artifact that /qa:manual-test-run executes

One-shot an app autonomously — free-will the founding fork, build with deliberate decisions at every trigger, then adversarial review and a conscious final pass before delivery

Run the Customer Discovery workflow (research -> JTBD -> opportunities -> problem)

Run the Design Sprint workflow (5-day prototype-and-test arc producing a Decider's build/iterate/pivot/stop call)

Run the Feature Kickoff workflow (problem -> hypothesis -> PRD -> stories)

Run the Foundation Sprint workflow (2-day strategic-alignment arc producing a Founding Hypothesis)

Run the end-to-end Foundation Sprint + Design Sprint workflow with narrative handoff

Run the Post-Launch Learning workflow (instrumentation -> dashboard -> results -> retro -> lessons)

Run the Product Strategy workflow (competitive analysis -> stakeholders -> opportunities -> solution -> ADR)

Run the Sprint Planning workflow (refinement -> stories -> edge cases)

Run the Stakeholder Alignment workflow (stakeholders -> problem -> solution -> launch)

Run the Technical Discovery workflow (spike -> ADR -> design rationale)

Run an ad-hoc ordered chain of pm-skills with shared context (ephemeral; routes to the pm-workflow-orchestrator)

Scout given directories to respond to the user's requests

Bootstrap a new project

Brainstorm a feature

Analyze the current copy issues and enhance it

Analyze and fix the issue [FAST]

Create an immersive design

Implement a feature

Debugging technical issues and providing solutions.

Create immersive interactive 3D designs with Three.js

Describe a design based on screenshot/video

Create a design based on screenshot

Create a design based on video

Analyze the codebase and create initial documentation

Analyze the codebase and update documentation

Analyze the codebase and update documentation

Analyze Github Actions logs and provide a plan to fix the issues

Use subagents to plan and fix hard issues

Analyze logs and fix issues

Debugging technical issues and providing solutions.

Fix type errors

Stage all files and create a commit.

Stage, commit and push all code in the current branch

Implement payment integration with Polar.sh

Research, analyze, and create an implementation plan

Research & create an implementation plan with 2 approaches

Review recent changes and wrap up the work

|

Launch the API documentation specialist for OpenAPI specs

Launch the API development agent for backend implementation

Alternative command for content creation

Debug an error or issue

Alternative command for DevOps deployment tasks

Launch the DevOps specialist for CI/CD and deployment

Generate or update documentation

Launch the frontend development agent for UI implementation

Launch the marketing content specialist

Launch the project planning agent for strategic task decomposition

Launch the product management specialist

Refactor code for better structure and maintainability

Alternative command for requirements gathering

Trigger code review on recent changes

Scan for security vulnerabilities

Launch the ShadCN UI builder agent for component-based UI development

Launch the TDD specialist for test-driven development

Alternative command for TDD specialist focusing on test-first approach

Run tests and fix failures

Launch the ShadCN UI builder agent for interface design and implementation

Run an accessibility audit on the current project for WCAG compliance.

Reverse-engineer a Product Requirements Document from existing code.

Build a competitive analysis matrix comparing products or tools.

Assess financial health of a SaaS business using key metrics.

Apply a focused, minimal-change bugfix with minimal blast radius.

Stage working tree changes and create a Conventional Commit (no push).

Stage, commit, and push the current branch following git governance rules.

Create a pull request from the current branch.

Create or review OKRs (Objectives and Key Results).

Activate a cross-domain persona for the current session.

Design or review a CI/CD pipeline for the current project.

Audit installed plugins, extensions, and dependencies for security and health.

Create a Product Requirements Document from scratch.

Assess overall project health across code quality, tests, docs, and activity.

Run a sprint retrospective with data-driven insights from git history.

Run the local review gate before pushing.

RICE-score features or tasks for prioritization.

Generate a SaaS health dashboard with key business metrics.

Run the security scan gate before pushing.

Run an SEO audit on web content and HTML files.

Check current sprint health and identify risks.

Plan a sprint by analyzing backlog, estimating capacity, and selecting work.

Guide a Test-Driven Development workflow for the current task.

Scan and prioritize technical debt in the codebase.

Create well-structured user stories with acceptance criteria.

Check the daily pipeline's state — last run, today's report files, Sonnet quota, recent failures

Trigger the daily digest now (background via OS scheduler) and monitor until completion