groundwork

Build a feature from description with worktree isolation and TDD. Usage /groundwork:build-unplanned "Add user login"

Verify alignment between code and specs. Usage /groundwork:check-specs-alignment

Generate implementation tasks from architecture document. Usage /groundwork:create-tasks

Start systematic debugging workflow. Usage /groundwork:debug [bug description]

Create architecture design document with decisions and tradeoffs. Usage /groundwork:design-architecture

Create detailed product requirements document (PRD) for a feature. Usage /groundwork:design-product

Validate the Groundwork plugin for common issues. Usage /groundwork:groundwork-check

List all Groundwork commands and skills with descriptions. Usage /groundwork:groundwork-help

Implement a previously planned task. Usage /groundwork:implement-task 4 or /groundwork:implement-task path/to/plan.md

Execute all remaining tasks using agent teams for context isolation. Each task runs in its own session. Usage /groundwork:just-do-it-swarming [--parallel]

Execute all remaining tasks in sequence until completion. Usage /groundwork:just-do-it

Plan a task or feature without implementing. Usage /groundwork:plan-task 4 or /groundwork:plan-task "Add user login"

Review a GitHub PR using multi-agent verification. Usage /groundwork:review-pr [PR number or URL]. Pass --no-interactive to skip all prompts and auto-publish.

Switch to a different project in a monorepo

Configure this repository for Groundwork - detect single-project or monorepo structure

List all available Groundwork skills with descriptions. Usage /groundwork:skills

Synchronize architecture document with codebase changes. Usage /groundwork:source-architecture-from-code

Synchronize PRD with implemented codebase changes. Usage /groundwork:source-product-specs-from-code

Synchronize design system document with codebase changes. Usage /groundwork:source-ux-design-from-code

Convert single-file architecture doc into directory-based format. Usage /groundwork:split-architecture

Convert single-file product specs into directory-based format. Usage /groundwork:split-specs

Start swarm debugging with parallel hypothesis investigation. Usage /groundwork:swarm-debug [bug description]

Design architecture using parallel advocate agents for adversarial technology comparison. Usage /groundwork:swarm-design-architecture

Create design system with foundations, brand identity, and UX patterns. Usage /groundwork:ux-design

Re-run multi-agent verification on current changes. Usage /groundwork:validate

Execute next uncompleted task with full project context (PRD, architecture, tasks). Usage /groundwork:work-on-next-task

Execute task with worktree isolation. Usage /groundwork:work-on 4 or /groundwork:work-on TASK-004

Verifies implementation aligns with architecture decisions, component responsibilities, and technology choices. Use after task implementation.

Validates task list follows architecture decisions. Ensures tasks reference correct components, technologies, and patterns.

Reviews cloud infrastructure-as-code (Terraform, CloudFormation, CDK, Bicep, ARM, Pulumi, Kubernetes, Dockerfiles) for Well-Architected and provider-specific best practices. Use after task implementation.

Reviews code changes for quality, readability, elegance, and test coverage. Use after task implementation to verify code meets quality standards.

Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality. Focuses on recently modified code unless instructed otherwise.

Reviews code changes for violations of project-specific conventions documented in CLAUDE.md files. Use after task implementation.

Verifies design system compliance - tokens, accessibility, and pattern consistency. Use after task implementation to verify design alignment.

Validates UI/frontend tasks follow design system guidelines. Ensures tasks include design tokens, accessibility, and UX patterns.

Reviews that housekeeping tasks are properly updated - task status marked complete, action items checked off, spec/architecture updates, and documentation changes. Use after task implementation.

Reviews code changes for performance issues including algorithmic complexity, memory management, I/O inefficiencies, and resource management. Use after task implementation.

Validates architecture proposals against PRD requirements. Ensures all functional requirements, NFRs, and features have architectural coverage before implementation begins.

Validates task list coverage of PRD requirements. Ensures all EARS requirements are addressed by at least one task.

Researches technologies, frameworks, and patterns BEFORE architecture decisions or task planning. Gathers official docs, ecosystem recommendations, and common pitfalls.

Reviews code changes for security vulnerabilities including OWASP Top 10, input validation, authentication issues, and sensitive data handling. Use after task implementation.

Verifies implementation aligns with task definition, product specs, and EARS requirements. Use after task implementation to ensure spec compliance.

Executes task implementation with worktree isolation and TDD. Use when a task needs to be implemented in an isolated worktree following TDD methodology.

Reviews test quality for structural correctness, coverage completeness, redundancy, and testing best practices. Use after task implementation.

Fixes validation findings from reviewer agents. Applies TDD for behavioral fixes, direct changes for cosmetic fixes. Reports files touched and findings addressed.

This skill should be used when the user asks to design system architecture, make architectural decisions, or translate PRD into technical design

This skill should be used when investigating bugs, unexpected behavior, test failures, or any code that does not work as expected - enforces systematic root cause analysis before any fix

skill to "execute a task", "work on task N", or "implement TASK-NNN" - orchestrates worktree isolation, TDD implementation, validation, and merge.

This skill should be used when the user wants to switch between projects in a monorepo - lists projects from .groundwork.yml and sets the active project

This skill should be used when configuring a repository for groundwork - detects single-project or monorepo structure and creates .groundwork.yml

This skill should be used when converting a single-file architecture doc to directory-based format for better organization of large architecture documents

This skill should be used when converting a single-file spec to directory-based format for better organization of large specifications

Dispatches a planned task/feature to the task-executor agent for worktree-isolated TDD implementation

Plans a task or feature - loads context, optionally clarifies requirements, spawns Plan agent, persists plan to .groundwork-plans/

This skill should be used when the task list is complete to run multi-agent verification ensuring tasks cover PRD, follow architecture, and respect design system

This skill should be used when implementing any feature or bugfix, before writing implementation code

This skill should be used when clarifying feature requests, gathering requirements, or checking for contradictions in proposed changes

This skill should be used when starting feature work that needs isolation from current workspace - creates isolated git worktrees with smart directory selection and safety verification

This skill should be used when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions

This skill should be used when implementation is complete to run multi-agent verification with autonomous fix-and-retry until all agents approve

5 hooks across 4 events