silver-bullet

gsd--brainstorm-phase

Explore multiple approaches before committing to a design

gsd--discuss-phase

Adaptive questioning to surface assumptions and lock decisions before planning

gsd--execute-phase

Execute PLAN.md with atomic commits, deviation handling, and TDD discipline

gsd--codebase-intelligence

Orient in the existing codebase before planning or implementing changes

gsd--plan-phase

Create PLAN.md with task breakdown, requirements mapping, and verification steps

gsd--progress-report

Show current phase status, remaining tasks, and next actions

Code & Development Listed

gsd--fix-code-review-findings

Address code review findings systematically with atomic commits

Code & Development Listed

gsd--code-review

Review changed files for bugs, security issues, and code quality; produce REVIEW.md

gsd--security-review

Security audit of changes; enforce defense in depth and OWASP best practices

gsd--ship-phase-create-pr

Push branch and create PR; refuses to ship without passing verification

gsd--validation-phase

Validate that implementation matches spec and requirements

gsd--verify-work

Execute verification steps from PLAN.md and produce VERIFICATION.md

Show all 64 bundled skills

ai-llm-safety

This skill should be used when designing, planning, implementing, or reviewing any system that involves LLM agents, tool use, prompt construction, or agentic workflows, or when the user asks to "add guardrails", "prevent prompt injection", "sanitize LLM output" — enforces prompt injection defense, tool safety, and context integrity

artifact-review-assessor

This skill should be used to triage artifact reviewer findings into MUST-FIX / NICE-TO-HAVE / DISMISS based on artifact contract -- prevents over-zealous reviews

artifact-reviewer

This skill should be used for framework for artifact review — defines the standard interface, 2-pass loop, state tracking, and audit trail that all SB artifact reviewers implement

devops-quality-gates

This skill should be used to apply 7 IaC-adapted quality dimensions against infrastructure and DevOps changes. Use after /silver:blast-radius and before /gsd:plan-phase in the devops-cycle workflow. Skips usability because IaC has no direct user interface. All dimensions must pass — any ❌ is a hard stop.

devops-skill-router

This skill should be used for context-aware routing table that maps IaC toolchain, cloud provider, and DevOps context to the best available plugin skill. Used by the devops-cycle workflow at contextual trigger points. Not a workflow step — a lookup utility.

extensibility

This skill should be used when designing, planning, implementing, or reviewing any non-trivial change, or when the user asks to "add plugin point", "make this pluggable", "add hooks for X" — enforces open-closed design, plugin architectures, stable interfaces, and versioning so systems grow without breaking existing consumers

finishing-branch

Merge, PR, or cleanup decisions for completing a branch

forge-delegate

Delegate the current phase's implementation work from Claude-SB to a Forge subagent under the parent's existing phase-lock. Spawns `forge -p <envelope>` with SB_PHASE_LOCK_INHERITED=true so the child does not double-claim, then integrates the structured Forge result into the parent phase artifacts.

modularity

This skill should be used when designing, planning, implementing, or reviewing any non-trivial change, or when the user asks to "split this file", "decouple X from Y", "refactor into modules" — enforces small, focused modules so any change fits in context without compaction

progressive-review-loop

Run iterative audit/fix/verify loops for bounded artifact sets by escalating through model and reasoning levels one pair at a time until two consecutive clean passes are achieved at each level. Use when reviewing scripts, prompts, runbooks, configs, or other operational artifacts that need progressive confidence-building reviews.

reliability

This skill should be used when designing, planning, implementing, or reviewing any non-trivial change, or when the user asks to "add retries", "add error handling", "add circuit breaker", "handle failures" — enforces graceful degradation, proper error handling, retry strategies, and fault-tolerant patterns so systems stay up when things go wrong

reusability

This skill should be used when designing, planning, implementing, or reviewing any non-trivial change, or when the user asks to "generalize this", "extract shared util", "deduplicate this" — enforces DRY, well-defined abstractions, and composable components so code is written once and used many times

review-context

This skill should be used for CONTEXT.md artifact reviewer — validates that all discussion points are resolved (locked decision or Claude's Discretion), decisions are specific (not vague), and no contradictions exist between decisions

review-cross-artifact

This skill should be used for cross-artifact consistency reviewer -- validates alignment across SPEC.md, REQUIREMENTS.md, ROADMAP.md, and DESIGN.md. Detects unmapped ACs, orphaned requirements, missing design coverage, and phantom phase requirements.

review-design

This skill should be used for DESIGN.md artifact reviewer — validates design quality against the SB design template: required sections, non-empty screen/component fields, behavior and state tables, and orphaned component detection against SPEC.md

review-ingestion-manifest

This skill should be used for INGESTION_MANIFEST.md artifact reviewer — validates that all source artifacts are listed, statuses are accurate, failed artifacts have corresponding ARTIFACT MISSING blocks in the linked SPEC.md, and the manifest supports resumability

review-requirements

This skill should be used for REQUIREMENTS.md artifact reviewer — validates requirements quality: required sections, REQ-ID format and uniqueness, testable acceptance criteria, priority fields, traceability frontmatter, and SPEC.md criterion coverage

review-research

This skill should be used for RESEARCH.md artifact reviewer — validates that all findings cite evidence, confidence levels are justified, pitfalls are actionable, and recommendations are concrete and implementable

review-roadmap

This skill should be used for ROADMAP.md artifact reviewer — validates roadmap quality: required phase fields, 100% requirement coverage, no phantom requirements, no circular phase dependencies, success criteria derivation, and plans field completeness

review-spec

This skill should be used for SPEC.md artifact reviewer — validates spec quality against the SB spec template: required sections, non-empty overview, user story format, testable acceptance criteria, assumption completeness, and frontmatter fields

review-uat

This skill should be used for UAT.md artifact reviewer — validates that every SPEC.md Acceptance Criterion has a UAT row, evidence is substantive (not 'looks good'), spec-version matches, and all results have pass/fail status with evidence

scalability

This skill should be used when designing, planning, implementing, or reviewing any non-trivial change, or when the user asks to "handle more load", "scale this out", "optimize for throughput" — enforces stateless design, efficient resource usage, and architectural patterns that handle 10x-100x growth without redesign

security

This skill should be used when designing, planning, implementing, or reviewing any non-trivial change, or when the user asks to "harden X", "add auth", "validate input", "check for vulnerabilities", "secure endpoint" — enforces defense in depth, input validation, secure defaults, and OWASP best practices to prevent vulnerabilities before they ship

silveradd

This skill should be used to classify and file any deferred or identified work item to the correct PM destination — GitHub Issues + project board (when issue_tracker=github) or local docs/issues/ markdown (when issue_tracker=gsd or absent) — and return a stable, referenceable ID.

silverblast-radius

This skill should be used to assess the blast radius of a proposed infrastructure or DevOps change before planning. Maps change scope, downstream dependencies, failure scenarios, rollback plan, and change window risk. Required before /devops-quality-gates in the devops-cycle workflow.

silverbugfix

This skill should be used for SB-orchestrated bug investigation and fix: triage → path A/B/C → TDD regression test → plan → execute → review → verify → ship

silverclarify

Turn vague ideas or requirements into a decision-ready brief that merges PM framing and Superpowers brainstorming before handing off to GSD.

silvercreate-release

This skill should be used to generate structured release notes from git history since the last tag, then create a GitHub Release (for GitHub repos) or output notes for manual publishing

DevOps & Infrastructure Listed

silverdevops

This skill should be used for SB-orchestrated infrastructure/CI-CD workflow: intel → silver:blast-radius → devops-skill-router → devops-quality-gates (7 IaC dims) → GSD plan/execute/verify → review → secure → ship

silverensure-docs

This skill should be used to bootstrap, reconcile, and semantically audit complete task-level documentation updates from docs/doc-scheme.md + docs/doc-scheme.json

silverfast

This skill should be used for 3-tier complexity triage: trivial → gsd-fast, medium → gsd-quick with flags, complex → silver:feature escalation.

silverfeature

This skill should be used for full SB-orchestrated feature development workflow: orient → clarify/decide → silver:quality-gates → GSD plan/execute/verify → ship

silverforensics

This skill should be used for root-cause investigation for completed sessions, abandoned sessions, verification failures, or mid-session stalls — classifies failure, walks investigation path, writes report to <project-root>/docs/silver:forensics/

silverhandoff

This skill should be used when ending a session and needing a reusable, project-level handoff prompt for the next session. It summarizes project state, active milestone, key docs, constraints, verification/release status, and open follow-ups without defaulting to task-specific detail unless explicitly requested.

silveringest

This skill should be used for external artifact ingestion: JIRA/Figma/Google Docs to SPEC.md + DESIGN.md via MCP connectors, plus cross-repo spec fetch with version pinning

silverinit

This skill should be used to initialize Silver Bullet enforcement for a project — checks dependencies, auto-detects project, scaffolds silver-bullet.md + config + workflow files, and reconciles any existing project instruction file in place without creating one

silvermigrate

This skill should be used when the user runs `/silver:migrate` or asks to migrate an older Silver Bullet project from retired workflow/doc conventions to current per-instance workflow tracking and Learnings documentation terminology.

silverquality-gates

This skill should be used for dual-mode: design-time checklist (pre-plan) or adversarial audit (pre-ship). Mode auto-detected from artifact state.

silverrelease

This skill should be used for SB-orchestrated milestone release: silver:quality-gates → audit → gap-closure (max 2x) → docs → GSD ship/complete milestone → silver:create-release

silverrem

This skill should be used to capture a knowledge or learnings insight into the correct monthly doc file — appends to docs/knowledge/YYYY-MM.md for project-scoped insights (Architecture Patterns, Known Gotchas, Key Decisions, Recurring Patterns, Open Questions) or docs/learnings/YYYY-MM.md for portable insights (domain:, stack:, practice:, devops:, design:), creating the monthly file with the correct header if it does not yet exist and updating docs/knowledge/INDEX.md when a new monthly file is first created.

silverremove

This skill should be used to remove a tracked work item by ID — closes a GitHub Issue as "not planned" with a removed-by-silver-bullet label (when issue_tracker=github), or marks a local SB-I-N or SB-B-N entry with [REMOVED YYYY-MM-DD] inline in docs/issues/ISSUES.md or docs/issues/BACKLOG.md (when issue_tracker=gsd or absent).

silverresearch

This skill should be used for SB-orchestrated research workflow: clarify → direct research by default, optional MultAI augmentation only when user-requested → clarify → hand off to silver:feature or silver:devops

silverreview-stats

This skill should be used to read .planning/review-analytics.jsonl and produces summary reports showing pass rates, average rounds, and common findings by artifact type

silverscan

This skill should be used to retrospectively scan project session sources for deferred work, unresolved questions, and knowledge or learnings candidates, then file or record approved findings through the scanner helper and project-management paths.

silverspec

This skill should be used for AI-guided Socratic spec elicitation: interactive dialogue producing SPEC.md + REQUIREMENTS.md from scratch or augmenting an existing draft

silverui

This skill should be used for full SB-orchestrated UI/frontend workflow: orient → clarify/decide → testing strategy → gsd-ui-phase → execute+TDD → gsd-ui-review → verify → ship

silverupdate

This skill should be used when the user runs `/silver:update` or asks to update Silver Bullet — checks GitHub for the latest release, shows the changelog since the installed version, and installs the update after confirmation.

silvervalidate

This skill should be used for pre-build gap analysis: validates SPEC.md coverage in PLAN.md, surfaces assumptions, emits machine-readable findings with BLOCK/WARN/INFO severity

silver

This skill should be used to route most non-trivial freeform user intent to the right Silver Bullet workflow or GSD skill automatically

tdd

Internal Silver Bullet enforcement wrapper around superpowers:test-driven-development; enforces Red-Green-Refactor for implementation work

testability

This skill should be used when designing, planning, implementing, or reviewing any non-trivial change, or when the user asks to "make this testable", "add dependency injection", "mock X" — enforces dependency injection, pure functions, observable state, and seam-based design so every component can be tested in isolation

usability

This skill should be used when designing, planning, implementing, or reviewing any non-trivial change, or when the user asks to "improve error messages", "better UX for X", "make this more usable" — enforces intuitive APIs, clear error messages, progressive disclosure, and developer/user experience so the system is a joy to use