
Mobile-first design thinking and decision-making for iOS and Android apps. Touch interaction, performance patterns, platform conventions. Teaches principles, not fixed values. Use when building React Native, Flutter, or native mobile apps.
--- name: lint-and-validate description: Automatic quality control, linting, and static analysis procedures. Use after every code modification to ensure syntax correctness and project standards. Triggers onKeywords: lint, format, check, validate, types, static analysis. allowed-tools: Read, Glob, Grep, Bash --- # Lint and Validate Skill > **MANDATORY:** Run appropriate validation tools after EVERY code change. Do not finish a task until the code is error-free. ### Procedures by Ecosystem ###
Retroactively audit and fill Nyquist validation gaps for a completed phase
Update GSD to latest version with changelog display
Manage persistent context threads for cross-session work
Create PR, run review, and prepare for merge after verification passes
Generate a session report with token usage estimates, work summary, and outcomes
Retroactively verify threat mitigations for a completed phase
Rapid codebase assessment — lightweight alternative to /gsd-map-codebase
Research how to implement a phase (standalone - usually use /gsd-plan-phase instead)
Execute a quick task with GSD guarantees (atomic commits, state tracking) but skip optional agents
Create a clean PR branch by filtering out .planning/ commits — ready for code review
Capture a forward-looking idea with trigger conditions — surfaces automatically at the right milestone
Create context handoff when pausing work mid-phase
Automatically advance to the next logical step in the GSD workflow
Create an isolated workspace with repo copies and independent .planning/
Generate a comprehensive project summary from milestone artifacts for team onboarding and review
Analyze codebase with parallel mapper agents to produce .planning/codebase/ documents
Interactive command center for managing multiple phases from one terminal
List active GSD workspaces and their status
Join the GSD Discord community
Ingest external plans with conflict detection against project decisions before writing anything.
Execute a trivial task inline — no subagents, no planning overhead
Execute all plans in a phase with wave-based parallelization
Gather phase context through adaptive questioning before planning. Use --auto to skip interactive questions (the agent picks recommended defaults). Use --chain for interactive discuss followed by automatic plan+execute. Use --power for bulk question generation into a file-based UI (answer at your own pace).
Auto-fix issues found by code review in REVIEW.md. Spawns fixer agent, commits each fix atomically, produces REVIEW-FIX.md summary.
Archive accumulated phase directories from completed milestones
Cross-phase audit of all outstanding UAT and verification items
Autonomous audit-to-fix pipeline — find issues, classify, fix, test, commit
Capture idea or task as todo from current conversation context
Game development orchestrator. Routes to platform-specific skills based on project needs.
Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing system design.
Design thinking and decision-making for web UI. Use when designing components, layouts, color schemes, typography, or creating aesthetic interfaces. Teaches principles, not fixed values.
Pragmatic coding standards - concise, direct, no over-engineering, no unnecessary comments
API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination.
Web browser game development principles. Framework selection, WebGPU, optimization, PWA.
Mobile game development principles. Touch input, battery, performance, app stores.
PowerShell Windows patterns. Critical pitfalls, operator syntax, error handling.
Production deployment principles and decision-making. Safe deployment workflows, rollback strategies, and verification. Teaches thinking, not scripts.
Generate a session report with token usage estimates, work summary, and outcomes
Generate developer behavioral profile and create Claude-discoverable artifacts
Execute a quick task with GSD guarantees (atomic commits, state tracking) but skip optional agents
Validate built features through conversational UAT
Gather phase context through adaptive questioning before planning. Use --auto to skip interactive questions (Claude picks recommended defaults). Use --chain for interactive disc...
Initialize a new project with deep context gathering and PROJECT.md
List active GSD workspaces and their status
Retroactively audit and fill Nyquist validation gaps for a completed phase
Multiplayer game development principles. Architecture, networking, synchronization.
Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.
AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). Use to adapt behavior based on task type.
Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.
Red team tactics principles based on MITRE ATT&CK. Attack phases, detection evasion, reporting.
Tailwind CSS v4 principles. CSS-first configuration, container queries, modern patterns, design token architecture.
Test-Driven Development workflow principles. RED-GREEN-REFACTOR cycle.
Code review guidelines covering code quality, security, and best practices.
Socratic questioning protocol + user communication. MANDATORY for complex requests, new features, or unclear requirements. Includes progress reporting and error handling.
Main application building orchestrator. Creates full-stack applications from natural language requests. Determines project type, selects tech stack, coordinates agents.
Generate tests for a completed phase based on UAT criteria and implementation
Add phase to end of current milestone in roadmap
Add an idea to the backlog parking lot (999.x numbering)
Audit milestone completion against original intent before archiving
Analyze phase dependencies and suggest Depends on entries for ROADMAP.md
List pending todos and select one to work on
Run all remaining phases autonomously — discuss→plan→execute per phase
Systematic debugging with persistent state across context resets
Archive completed milestone and prepare for next version
Review source files changed during a phase for bugs, security issues, and code quality problems
Socratic ideation and idea routing — think through ideas before committing to plans
Generate or update project documentation verified against the codebase
Route freeform text to the right GSD command automatically
Show available GSD commands and usage guide
Diagnose planning directory health and optionally repair issues
Post-mortem investigation for failed GSD workflows — analyzes git history, artifacts, and state to diagnose what went wrong
Surface the agent's assumptions about a phase approach before planning
Query, inspect, or refresh codebase intelligence files in .planning/intel/
Initialize a new project with deep context gathering and PROJECT.md
Start a new milestone cycle — update PROJECT.md and route to requirements
Create detailed phase plan (PLAN.md) with verification loop
Create phases to close all gaps identified by milestone audit
Check project progress, show context, and route to next action (execute or plan)
Generate developer behavioral profile and create Claude-discoverable artifacts
Remove a GSD workspace and clean up worktrees
Remove a future phase from roadmap and renumber subsequent phases
Reapply local modifications after a GSD update
Request cross-AI peer review of phase plans from external AI CLIs
Resume work from previous session with full context restoration
Configure GSD workflow toggles and model profile
Switch model profile for GSD agents (quality/balanced/budget/inherit)
Display project statistics — phases, plans, requirements, git metrics, and timeline
Safe git revert. Roll back phase or plan commits using the phase manifest with dependency checks.
Retroactive 6-pillar visual audit of implemented frontend code
Generate UI design contract (UI-SPEC.md) for frontend phases
Automatic agent selection and intelligent task routing. Analyzes user requests and automatically selects the best specialist agent(s) without requiring explicit user mentions.
Manage parallel workstreams — list, create, switch, status, progress, complete, and resume
Validate built features through conversational UAT
React and Next.js performance optimization from Vercel Engineering. Use when building React components, optimizing performance, eliminating waterfalls, reducing bundle size, reviewing code for performance issues, or implementing server/client-side optimizations.
MCP (Model Context Protocol) server building principles. Tool design, resource patterns, best practices.
Master Rust 1.75+ with modern async patterns, advanced type system features, and production-ready systems programming. Expert in the latest Rust ecosystem including Tokio, axum, and cutting-edge crates. Use PROACTIVELY for Rust development, performance optimization, or systems programming.
Performance profiling principles. Measurement, analysis, and optimization techniques.
4-phase systematic debugging methodology with root cause analysis and evidence-based verification. Use when debugging complex issues.
Add phase to end of current milestone in roadmap
Add an idea to the backlog parking lot (999.x numbering)
Web application testing principles. E2E, Playwright, deep audit strategies.
Audit milestone completion against original intent before archiving
Autonomous audit-to-fix pipeline — find issues, classify, fix, test, commit
List pending todos and select one to work on
Run all remaining phases autonomously — discuss→plan→execute per phase
Cross-phase audit of all outstanding UAT and verification items
Systematic debugging with persistent state across context resets
Archive completed milestone and prepare for next version
Review source files changed during a phase for bugs, security issues, and code quality problems
Gather phase context through adaptive questioning before planning. Use --auto to skip interactive questions (the agent picks recommended defaults). Use --chain for interactive discuss followed by automatic plan+execute. Use --power for bulk question generation into a file-based UI (answer at your own pace).
Generate or update project documentation verified against the codebase
Post-mortem investigation for failed GSD workflows — analyzes git history, artifacts, and state to diagnose what went wrong
Ingest external plans with conflict detection against project decisions before writing anything.
Show available GSD commands and usage guide
Diagnose planning directory health and optionally repair issues
Query, inspect, or refresh codebase intelligence files in .planning/intel/
Join the GSD Discord community
Interactive command center for managing multiple phases from one terminal
Start a new milestone cycle — update PROJECT.md and route to requirements
Generate a comprehensive project summary from milestone artifacts for team onboarding and review
Zero-friction idea capture. Append, list, or promote notes to todos.
Automatically advance to the next logical step in the GSD workflow
Create an isolated workspace with repo copies and independent .planning/
Capture a forward-looking idea with trigger conditions — surfaces automatically at the right milestone
Create phases to close all gaps identified by milestone audit
Create a clean PR branch by filtering out .planning/ commits — ready for code review
Check project progress, show context, and route to next action (execute or plan)
Research how to implement a phase (standalone - usually use /gsd-plan-phase instead)
Remove a future phase from roadmap and renumber subsequent phases
Rapid codebase assessment — lightweight alternative to /gsd-map-codebase
Request cross-AI peer review of phase plans from external AI CLIs
Review and promote backlog items to active milestone
Configure GSD workflow toggles and model profile
Switch model profile for GSD agents (quality/balanced/budget/inherit)
Generate a session report with token usage estimates, work summary, and outcomes
Generate UI design contract (UI-SPEC.md) for frontend phases
Manage persistent context threads for cross-session work
Display project statistics — phases, plans, requirements, git metrics, and timeline
Update GSD to latest version with changelog display
Add an idea to the backlog parking lot (999.x numbering)
UI/UX design intelligence with searchable database
Manage parallel workstreams — list, create, switch, status, progress, complete, and resume
Analyze phase dependencies and suggest Depends on entries for ROADMAP.md
Generate tests for a completed phase based on UAT criteria and implementation
Run all remaining phases autonomously — discuss→plan→execute per phase
Cross-phase audit of all outstanding UAT and verification items
Archive completed milestone and prepare for next version
Review source files changed during a phase for bugs, security issues, and code quality problems
Auto-fix issues found by code review in REVIEW.md. Spawns fixer agent, commits each fix atomically, produces REVIEW-FIX.md summary.
Generate or update project documentation verified against the codebase
Socratic ideation and idea routing — think through ideas before committing to plans
Query, inspect, or refresh codebase intelligence files in .planning/intel/
Insert urgent work as decimal phase (e.g., 72.1) between existing phases
Ingest external plans with conflict detection against project decisions before writing anything.
Generate a comprehensive project summary from milestone artifacts for team onboarding and review
Analyze codebase with parallel mapper agents to produce .planning/codebase/ documents
Surface Claude's assumptions about a phase approach before planning
Create an isolated workspace with repo copies and independent .planning/
Start a new milestone cycle — update PROJECT.md and route to requirements
Create context handoff when pausing work mid-phase
Zero-friction idea capture. Append, list, or promote notes to todos.
Automatically advance to the next logical step in the GSD workflow
Generate developer behavioral profile and create Claude-discoverable artifacts
Create a clean PR branch by filtering out .planning/ commits — ready for code review
Create detailed phase plan (PLAN.md) with verification loop
Remove a future phase from roadmap and renumber subsequent phases
Execute a quick task with GSD guarantees (atomic commits, state tracking) but skip optional agents
Check project progress, show context, and route to next action (execute or plan)
Resume work from previous session with full context restoration
Review and promote backlog items to active milestone
Remove a GSD workspace and clean up worktrees
Retroactively verify threat mitigations for a completed phase
Rapid codebase assessment — lightweight alternative to /gsd-map-codebase
Create PR, run review, and prepare for merge after verification passes
Switch model profile for GSD agents (quality/balanced/budget/inherit)
Generate UI design contract (UI-SPEC.md) for frontend phases
Display project statistics — phases, plans, requirements, git metrics, and timeline
Validate built features through conversational UAT
Capture idea or task as todo from current conversation context
Generate tests for a completed phase based on UAT criteria and implementation
Audit milestone completion against original intent before archiving
Autonomous audit-to-fix pipeline — find issues, classify, fix, test, commit
Auto-fix issues found by code review in REVIEW.md. Spawns fixer agent, commits each fix atomically, produces REVIEW-FIX.md summary.
Run all remaining phases autonomously — discuss→plan→execute per phase
Systematic debugging with persistent state across context resets
Archive completed milestone and prepare for next version
Post-mortem investigation for failed GSD workflows — analyzes git history, artifacts, and state to diagnose what went wrong
Generate or update project documentation verified against the codebase
Insert urgent work as decimal phase (e.g., 72.1) between existing phases
Show available GSD commands and usage guide
Analyze codebase with parallel mapper agents to produce .planning/codebase/ documents
Interactive command center for managing multiple phases from one terminal
Join the GSD Discord community
Project scaffolding templates for new applications. Use when creating new projects from scratch. Contains 12 templates for various tech stacks.
Zero-friction idea capture. Append, list, or promote notes to todos.
Diagnose planning directory health and optionally repair issues
Execute a trivial task inline — no subagents, no planning overhead
Generative Engine Optimization for AI search engines (ChatGPT, Claude, Perplexity).
Bash/Linux terminal patterns. Critical commands, piping, error handling, scripting. Use when working on macOS or Linux systems.
Database design principles and decision-making. Schema design, indexing strategy, ORM selection, serverless databases.
Game audio principles. Sound design, music integration, adaptive audio systems.
Insert urgent work as decimal phase (e.g., 72.1) between existing phases
Review and promote backlog items to active milestone
Add phase to end of current milestone in roadmap
Surface the agent's assumptions about a phase approach before planning
Advanced vulnerability analysis principles. OWASP 2025, Supply Chain Security, attack surface mapping, risk prioritization.
PC and console game development principles. Engine selection, platform features, optimization strategies.
Python development principles and decision-making. Framework selection, async patterns, type hints, project structure. Teaches thinking, not copying.
Analyze phase dependencies and suggest Depends on entries for ROADMAP.md
Initialize a new project with deep context gathering and PROJECT.md
Archive accumulated phase directories from completed milestones
Retroactive 6-pillar visual audit of implemented frontend code
Ingest external plans with conflict detection against project decisions before writing anything.
Update GSD to latest version with changelog display
2D game development principles. Sprites, tilemaps, physics, camera.
Structured task planning with clear breakdowns, dependencies, and verification criteria. Use when implementing features, refactoring, or any multi-step work.
Join the GSD Discord community
Gather phase context through adaptive questioning before planning. Use --auto to skip interactive questions (the agent picks recommended defaults). Use --chain for interactive discuss followed by automatic plan+execute. Use --power for bulk question generation into a file-based UI (answer at your own pace).
Review source files changed during a phase for bugs, security issues, and code quality problems
Analyze phase dependencies and suggest Depends on entries for ROADMAP.md
Manage parallel workstreams — list, create, switch, status, progress, complete, and resume
Configure GSD workflow toggles and model profile
Research how to implement a phase (standalone - usually use /gsd-plan-phase instead)
Reapply local modifications after a GSD update
Capture a forward-looking idea with trigger conditions — surfaces automatically at the right milestone
Show available GSD commands and usage guide
Audit milestone completion against original intent before archiving
Systematic debugging with persistent state across context resets
Surface the agent's assumptions about a phase approach before planning
Execute a trivial task inline — no subagents, no planning overhead
Multi-agent orchestration patterns. Use when multiple independent tasks can run with different domain expertise or when comprehensive analysis requires multiple perspectives.
Auto-fix issues found by code review in REVIEW.md. Spawns fixer agent, commits each fix atomically, produces REVIEW-FIX.md summary.
Generate tests for a completed phase based on UAT criteria and implementation
Capture idea or task as todo from current conversation context
Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation.
3D game development principles. Rendering, shaders, physics, cameras.
Game art principles. Visual style selection, asset pipeline, animation workflow.
Game design principles. GDD structure, balancing, player psychology, progression.
VR/AR development principles. Comfort, interaction, performance requirements.
Server management principles and decision-making. Process management, monitoring strategy, and scaling decisions. Teaches thinking, not commands.
List active GSD workspaces and their status
Query, inspect, or refresh codebase intelligence files in .planning/intel/
Diagnose planning directory health and optionally repair issues
Socratic ideation and idea routing — think through ideas before committing to plans
Execute all plans in a phase with wave-based parallelization
Route freeform text to the right GSD command automatically
Archive accumulated phase directories from completed milestones
List pending todos and select one to work on
Cross-phase audit of all outstanding UAT and verification items
Add an idea to the backlog parking lot (999.x numbering)
Safe git revert. Roll back phase or plan commits using the phase manifest with dependency checks.
Manage persistent context threads for cross-session work
Request cross-AI peer review of phase plans from external AI CLIs
Create phases to close all gaps identified by milestone audit
Interactive command center for managing multiple phases from one terminal
Post-mortem investigation for failed GSD workflows — analyzes git history, artifacts, and state to diagnose what went wrong
Execute a trivial task inline — no subagents, no planning overhead
Execute all plans in a phase with wave-based parallelization
Route freeform text to the right GSD command automatically
List pending todos and select one to work on
Autonomous audit-to-fix pipeline — find issues, classify, fix, test, commit
Capture idea or task as todo from current conversation context
Add phase to end of current milestone in roadmap
Retroactively audit and fill Nyquist validation gaps for a completed phase
Safe git revert. Roll back phase or plan commits using the phase manifest with dependency checks.
Retroactive 6-pillar visual audit of implemented frontend code
Create PR, run review, and prepare for merge after verification passes
Retroactively verify threat mitigations for a completed phase
Resume work from previous session with full context restoration
Remove a GSD workspace and clean up worktrees
Reapply local modifications after a GSD update
Create detailed phase plan (PLAN.md) with verification loop
Create context handoff when pausing work mid-phase
Analyze codebase with parallel mapper agents to produce .planning/codebase/ documents
List active GSD workspaces and their status
Insert urgent work as decimal phase (e.g., 72.1) between existing phases
Socratic ideation and idea routing — think through ideas before committing to plans
Execute all plans in a phase with wave-based parallelization
Route freeform text to the right GSD command automatically
Archive accumulated phase directories from completed milestones
Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".
SEO fundamentals, E-E-A-T, Core Web Vitals, and Google algorithm principles.
Testing patterns and principles. Unit, integration, mocking strategies.