sc30gsw
121 verified skills1,509 total stars
vcsdd-adversary
Run Phase 3 (adversarial review) for the active VCSDD feature. Spawns a fresh vcsdd-adversary agent with zero Builder context to review implementation against spec. Produces binary PASS/FAIL verdict per dimension.
development20
skills/vcsdd-coherence-scan
# /vcsdd-coherence-scan — Coherence Graph Scan ## What Rebuild the Conditioned Evidence Graph (CEG) from `coherence:` or `codd:` frontmatter declared in the feature's spec files. The CEG tracks dependency relationships between spec documents and declared implementation modules so that change-impact analysis is always current. ## When to use - After writing or editing any spec file that contains a `coherence:` or `codd:` block - Before running `/vcsdd-coherence-impact` to ensure the graph is
development20
skills/vcsdd-coherence-validate
# /vcsdd-coherence-validate — Coherence Graph Validation ## What Validate the CEG for structural integrity: 1. **Reference integrity** — all edge source/target IDs reference known nodes 2. **Cycle detection** — no circular dependencies in the dependency graph This is run automatically as part of the `GATE_PREREQUISITES['2a']` check when any spec frontmatter declares coherence metadata, or when `coherence.json` is already present. You can also invoke it manually at any time. ## When to use -
testing20
vcsdd-commit
Create a git commit for the current VCSDD phase. Auto-generates a conventional commit message from state.json including phase, sprint, gate verdict, and affected bead IDs. Tags with vcsdd/<feature>/phase-<id>.
tools20
skills/vcsdd-converge
--- name: vcsdd-converge description: Run Phase 6 (convergence check) for the active VCSDD feature. Validates four-dimensional convergence: finding diminishment, finding specificity, criteria coverage, and duplicate detection. --- ## What Runs the convergence check (Phase 6). Validates all four convergence dimensions and either marks the feature complete or routes back to Phase 3 for another adversary pass. ## When Run after Phase 5 (formal hardening) completes. Requires active feature at phas
testing20
vcsdd-escalate
Architect escalation approval — extend iteration limit for a phase that has hit its cap. Records the approval decision in state and allows the blocked transition to proceed.
testing20
vcsdd-feedback-routing
Use this skill when routing adversary findings in Phase 4. Provides routing logic, iteration limit enforcement, and escalation protocols.
databases20
vcsdd-feedback
Run Phase 4 (feedback routing) after an adversarial review FAIL. Routes adversary findings to the earliest affected phase, checks iteration limits, and escalates to human if limits are exceeded.
testing20
vcsdd-formal-hardening
Use this skill during Phase 5 formal hardening. Provides tool selection, proof harness patterns, security/purity audit expectations, and verification result interpretation for Rust (Kani), Python (hypothesis), and TypeScript (fast-check).
tools20
vcsdd-grading-criteria
Use this skill when evaluating VCSDD grading dimensions during adversarial review. Provides concrete evaluation checklists for each of the 5 dimensions and convergence signal detection.
testing20
vcsdd-harden
Run Phase 5 (formal hardening) for the active VCSDD feature. Invokes vcsdd-verifier to execute proof obligations, security hardening, and a purity-boundary audit before convergence.
testing20
vcsdd-impl
Run Phase 2b (implementation, Green phase) and Phase 2c (refactor) for the active VCSDD feature. Invokes vcsdd-builder to implement minimal code to pass failing tests, then refactor.
development20
vcsdd-language-python
Use this skill when applying VCSDD to Python projects. Provides hypothesis property testing patterns, mutmut mutation testing, and pytest integration for the VCSDD pipeline.
development20
vcsdd-language-rust
Use this skill when applying VCSDD to Rust projects. Provides Kani proof harness patterns, proptest strategies, cargo-fuzz integration, and cargo-mutants mutation testing guidance.
development20
vcsdd-language-typescript
Use this skill when applying VCSDD to TypeScript/JavaScript projects. Provides fast-check property testing patterns, Stryker mutation testing, and vitest/jest integration for the VCSDD pipeline.
development20
vcsdd-sprint-contracts
Use this skill when writing sprint contracts in VCSDD strict mode. Provides grading criteria patterns, dimension weight guidelines, and pass threshold formulation for the 5 review dimensions.
documentation20
vcsdd-tdd
Run Phase 2a (test generation, Red phase) for the active VCSDD feature. Invokes vcsdd-builder to generate failing tests for all spec requirements. Records red phase evidence.
development20
vcsdd-trace
Display the full traceability chain for a VCSDD bead. Traverses the Chainlink graph from the given bead ID and shows all connected artifacts with status.
data-ai20
vcsdd-traceability
Use this skill when creating or querying VCSDD Chainlink bead traceability. Provides bead creation patterns, chain traversal, and completeness validation.
data-ai20
vcsdd-adversarial-refinement
Use this skill when running or interpreting VCSDD adversarial reviews. Provides calibration guidance for the Adversary agent, finding severity classification, and anti-leniency enforcement patterns.
data-ai20
skills/vcsdd-coherence-impact
# /vcsdd-coherence-impact — Coherence Impact Analysis ## What Given a set of changed or affected spec nodes, perform BFS forward-impact propagation through the CEG to identify all downstream documents that may need updating. Also surface any CoDD `conventions:` / `must_review` alerts attached to the changed node or its immediate parents. Results are classified into Green / Amber / Gray bands. If no node is provided, auto-detect changed files from `git diff --name-only HEAD` and resolve them t
documentation20
vcsdd-contract-review
Run the strict-mode sprint contract review after Phase 2c. Spawns a fresh vcsdd-adversary instance to review `contracts/sprint-N.md` and writes a PASS/FAIL verdict under `reviews/contracts/sprint-N/output/`.
documentation20
vcsdd-convergence-detection
Use this skill during Phase 6 convergence checks. Provides four-dimensional convergence analysis, hallucination detection, and duplicate finding identification.
testing20
vcsdd-git-integration
Use this skill when committing VCSDD pipeline artifacts to git. Provides conventional commit message format, phase tag patterns, and atomic staging strategies.
development20
vcsdd-init
Initialize a VCSDD feature pipeline. Creates the .vcsdd/features/<name>/ directory tree, sets mode (strict|lean), and activates the feature. Must be run before any other VCSDD command.
devops20
vcsdd-spec
Run Phase 1a (behavioral specification) and Phase 1b (verification architecture) for the active VCSDD feature. Invokes vcsdd-builder to write EARS-format requirements and purity boundary analysis.
development20
vcsdd-spec-crystallization
Use this skill when writing Phase 1a behavioral specifications in VCSDD. Provides EARS format requirements writing, purity boundary analysis, edge case enumeration, and spec quality validation patterns.
development20
vcsdd-spec-review
Run Phase 1c (spec review gate) for the active VCSDD feature. Spawns a fresh vcsdd-adversary instance to review the behavioral spec and verification architecture. Records PASS/FAIL gate verdict.
data-ai20
vcsdd-status
Display the current VCSDD pipeline status for the active (or specified) feature. Shows phase, mode, sprint count, open findings, pending proofs, and the traceability summary.
testing20
vcsdd-verification-architecture
Use this skill when writing Phase 1b verification architecture documents. Provides purity boundary mapping, proof obligation design, and tier assignment guidance.
documentation20
sample/harness/next-js-pages/skills/sdd-workflow
# sdd-workflow — Workflow Status Dashboard ## Slash Command ``` /sdd-workflow [slug] ``` ## Purpose Read-only meta skill. Displays the current state of the SDD workflow — which phases are complete, which is next, and any blockers. Does NOT modify any files. --- ## This Skill is Read-Only `sdd-workflow` never writes to or modifies any file. It only reads spec files and git history to report status. There is no approval gate for this skill. --- ## Usage: Specific Feature ``` /sdd-workflo
testing10
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.
development10
sample/harness/next-js-pages/skills/sdd-impl
# sdd-impl — Implement Tasks (TDD) ## Slash Command ``` /sdd-impl <slug> [task-id] ``` ## Purpose Implement one task (or all pending tasks) for a spec using strict Test-Driven Development. Delegates test/implementation cycles to the `/ecc:tdd-workflow` skill and keeps `progress.md` up to date throughout. --- ## Prerequisites Before running this skill, confirm: - `sdd-review-plan` has been run: `review.md` must contain a `## Plan Review` section with no `❌` in the Traceability section. -
development10
sample/harness/next-js-pages/skills/sdd-init
# Skill: sdd-init ## Invocation ``` /sdd-init <slug> [notion-url] [--mode standard|auto] ``` **Arguments:** - `<slug>` — kebab-case identifier for the feature (e.g. `user-invitation`, `supplier-csv-import`) - `[notion-url]` — optional Notion page URL to fetch and archive as source material - `[--mode standard|auto]` — workflow mode (default: `standard`) - `standard`: engineer-led — AI assists, human drives decisions - `auto`: AI-led — suitable for non-engineers; AI asks questions and mak
testing10
git-pr
Generate PR description and automatically create pull request on GitHub
tools10
sample/harness/next-js-pages/skills/sdd-design
# sdd-design **Slash command**: `/sdd-design <slug>` **Purpose**: Create `design.md` by delegating to the `/ecc:plan` skill for architecture and step planning, then merging output into the project's design template. --- ## Prerequisites - `.claude/specs/<slug>/requirements.md` must exist (run `/sdd-requirements` first) - `.claude/specs/<slug>/source-notion.md` may optionally be present for additional context --- ## Steps ### 1. Read spec inputs ``` .claude/specs/<slug>/requirements.md
content-media10
sample/harness/next-js-pages/skills/fallow
--- name: fallow description: Codebase intelligence for JavaScript and TypeScript. Free static layer finds unused code (files, exports, types, dependencies), code duplication, circular dependencies, complexity hotspots, architecture boundary violations, and feature flag patterns. Runtime coverage merges production execution data into the same health report for hot-path review, cold-path deletion confidence, and stale-flag evidence: a single local capture is free, while continuous/cloud runtime m
development10
sample/harness/next-js-pages/skills/sdd-pr
# sdd-pr — Create Pull Request ## Slash Command ``` /sdd-pr <slug> ``` ## Purpose Create a GitHub Pull Request enriched with SDD-specific content: a REQ → TASK → commit traceability table, review summary, and an acceptance-criteria-derived test plan checklist. Delegates the actual PR creation to the project's `git-pr` skill. --- ## Prerequisites - `sdd-review` has been run: `review.md` must contain a `## Code Review` section. - The feature branch must be pushed to the remote. - No unresol
development10
sample/harness/next-js-pages/skills/sdd-requirements
# Skill: sdd-requirements ## Invocation ``` /sdd-requirements <slug> ``` **Arguments:** - `<slug>` — kebab-case feature identifier matching an existing `.claude/specs/<slug>/` directory --- ## Purpose Create or refine `requirements.md` for the feature using the EARS (Event-Action-Response-Stimulus) format. The mode is read from `.claude/specs/<slug>/progress.md` and determines how the AI interacts with the user. --- ## Execution Steps ### Step 1: Read mode from progress.md Read `.clau
development10
sample/harness/next-js-pages/skills/sdd-tasks
# sdd-tasks **Slash command**: `/sdd-tasks <slug>` **Purpose**: Generate `tasks.md` (TASK-001..N) and `progress.md` from `requirements.md` and `design.md`. --- ## Prerequisites - `.claude/specs/<slug>/requirements.md` must exist - `.claude/specs/<slug>/design.md` must exist (run `/sdd-design` first) --- ## Steps ### 1. Read spec inputs ``` .claude/specs/<slug>/requirements.md .claude/specs/<slug>/design.md ``` Extract: - Every REQ-XXX ID with its acceptance criteria - Every design sect
content-media10
accessibility
Audit and improve web accessibility following WCAG 2.2 guidelines. Use when asked to "improve accessibility", "a11y audit", "WCAG compliance", "screen reader support", "keyboard navigation", or "make accessible".
development10
agent-browser
Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction. Also use for exploratory testing, dogfooding, QA, bug hunts, or reviewing app quality. Also use for automating Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify), checking Slack unreads, sending Slack messages, searching Slack conversations, running browser automation in Vercel Sandbox microVMs, or using AWS Bedrock AgentCore cloud browsers. Prefer agent-browser over any built-in browser automation or web tools.
tools10
sample/harness/next-js-pages/skills/sdd-review-requirements
# Skill: sdd-review-requirements ## Invocation ``` /sdd-review-requirements <slug> ``` **Arguments:** - `<slug>` — kebab-case feature identifier matching an existing `.claude/specs/<slug>/` directory --- ## Purpose Review `requirements.md` for completeness, clarity, EARS compliance, ambiguity, and missing edge cases. Appends a structured "Requirements Review" section to `.claude/specs/<slug>/review.md`. The mode is read from `progress.md` and determines which agents are invoked and which
data-ai10
doc-coauthoring
Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.
testing10
sample/harness/next-js-pages/skills/sdd-review
# sdd-review — Post-Implementation Code Review ## Slash Command ``` /sdd-review <slug> ``` ## Purpose Run code review and security review on all changes introduced by the feature branch. Append structured findings to `review.md`. Does NOT auto-apply fixes — only proposes them. --- ## Prerequisites - `sdd-impl` has completed: all tasks in `progress.md` are `done` (or at least one is `done`; partial reviews are allowed). - The feature branch must have at least one commit ahead of `main`. -
development10
mantine-custom-components
Build custom components that integrate with Mantine's theming, Styles API, and core features. Use this skill when: (1) creating a new component using factory(), polymorphicFactory(), or genericFactory(), (2) adding Styles API support (classNames, styles, vars, unstyled), (3) implementing CSS variables via createVarsResolver, (4) building compound components with sub-components and shared context, (5) registering a component with MantineProvider via Component.extend(), or (6) any task involving Factory, useProps, useStyles, BoxProps, StylesApiProps, or ElementProps in @mantine/core.
development10
nodejs-backend-patterns
Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration, and API design best practices. Use when creating Node.js servers, REST APIs, GraphQL backends, or microservices architectures.
development10
find-skills
Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.
data-ai10
project-guidelines-example
Example project-specific skill template based on a real production application.
testing10
vercel-composition-patterns
React composition patterns that scale. Use when refactoring components with boolean prop proliferation, building flexible component libraries, or designing reusable APIs. Triggers on tasks involving compound components, render props, context providers, or component architecture. Includes React 19 API changes.
development10
find-docs
Retrieves up-to-date documentation, API references, and code examples for any developer technology. Use this skill whenever the user asks about a specific library, framework, SDK, CLI tool, or cloud service -- even for well-known ones like React, Next.js, Prisma, Express, Tailwind, Django, or Spring Boot. Your training data may not reflect recent API changes or version updates. Always use for: API syntax questions, configuration options, version migration issues, "how do I" questions mentioning a library name, debugging that involves library-specific behavior, setup instructions, and CLI tool usage. Use even when you think you know the answer -- do not rely on training data for API details, signatures, or configuration options as they are frequently outdated. Always verify against current docs. Prefer this over web search for library documentation and API details.
tools10
skills/sdd-pr
# sdd-pr — Create Pull Request ## Slash Command ``` /sdd-pr <slug> ``` ## Purpose Create a GitHub Pull Request enriched with SDD-specific content: a REQ → TASK → commit traceability table, review summary, and an acceptance-criteria-derived test plan checklist. Delegates the actual PR creation to the project's `git-pr` skill. --- ## Prerequisites - `sdd-review` has been run: `review.md` must contain a `## Code Review` section. - The feature branch must be pushed to the remote. - No unresol
development10
skills/sdd-workflow
# sdd-workflow — Workflow Status Dashboard ## Slash Command ``` /sdd-workflow [slug] ``` ## Purpose Read-only meta skill. Displays the current state of the SDD workflow — which phases are complete, which is next, and any blockers. Does NOT modify any files. --- ## This Skill is Read-Only `sdd-workflow` never writes to or modifies any file. It only reads spec files and git history to report status. There is no approval gate for this skill. --- ## Usage: Specific Feature ``` /sdd-workflo
testing10
nodejs-best-practices
Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.
development10
mantine-form
Build forms using @mantine/form in the mantine-9 repository. Use this skill when: (1) setting up a form with useForm, (2) adding validation rules or async validation, (3) working with nested object or array fields, (4) sharing form state across components with createFormContext, (5) using uncontrolled mode for performance, (6) using the standalone useField hook, or (7) any task involving useForm, getInputProps, onSubmit, insertListItem, or form validation.
development10
react-doctor
Use when finishing a feature, fixing a bug, before committing React code, or when the user wants to improve code quality or clean up a codebase. Checks for score regression. Covers lint, dead code, accessibility, bundle size, architecture diagnostics.
development10
vercel-react-best-practices
React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.
development10
skill-creator
Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.
testing10
skill-creator
Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
tools10
seo
Optimize for search engine visibility and ranking. Use when asked to "improve SEO", "optimize for search", "fix meta tags", "add structured data", "sitemap optimization", or "search engine optimization".
data-ai10
tanstack-start-server-fn-testing
Unit-test TanStack Start createServerFn handlers via a global vi.mock that combines two patterns from Discussion #2701
testing10
tailwind-css-patterns
Provides comprehensive Tailwind CSS utility-first styling patterns including responsive design, layout utilities, flexbox, grid, spacing, typography, colors, and modern CSS best practices. Use when styling React/Vue/Svelte components, building responsive layouts, implementing design systems, or optimizing CSS workflow.
tools10
tanstack-start
Full-stack React framework powered by TanStack Router with SSR, streaming, server functions, and deployment to any hosting provider.
development10
web-design-guidelines
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".
development10
typescript-advanced-types
Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications. Use when implementing complex type logic, creating reusable type utilities, or ensuring compile-time type safety in TypeScript projects.
tools10
webapp-testing
Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.
tools10
graphify
any input (code, docs, papers, images, videos) to knowledge graph. Use when user asks any question about a codebase, documents, or project content - especially if graphify-out/ exists, treat the question as a /graphify query.
development10
skills/notion-bug-pr
--- name: notion-bug-pr description: Skill that pulls bug tickets (titles containing 「不具合」) from a Notion database, investigates root cause in a GitHub repo, applies fixes, and opens draft PRs. Supports three modes — daily recurring schedule, one-shot at a specific time, or immediate on-demand run. Takes three or four args: Notion database URL, repo path or name, and either HH:MM (daily), "once HH:MM" (one-shot), or "now" (immediate). --- # notion-bug-pr Fetches tickets whose title contains th
testing10
skills/sdd-design
# sdd-design **Slash command**: `/sdd-design <slug>` **Purpose**: Create `design.md` by delegating to the `/ecc:plan` skill for architecture and step planning, then merging output into the project's design template. --- ## Prerequisites - `.claude/specs/<slug>/requirements.md` must exist (run `/sdd-requirements` first) - `.claude/specs/<slug>/source-notion.md` may optionally be present for additional context --- ## Steps ### 1. Read spec inputs ``` .claude/specs/<slug>/requirements.md
content-media10
git-pr
Generate PR description and automatically create pull request on GitHub
tools10
skills/sdd-review
# sdd-review — Post-Implementation Code Review ## Slash Command ``` /sdd-review <slug> ``` ## Purpose Run code review and security review on all changes introduced by the feature branch. Append structured findings to `review.md`. Does NOT auto-apply fixes — only proposes them. --- ## Prerequisites - `sdd-impl` has completed: all tasks in `progress.md` are `done` (or at least one is `done`; partial reviews are allowed). - The feature branch must have at least one commit ahead of `main`. -
development10
skills/sdd-review-plan
# sdd-review-plan **Slash command**: `/sdd-review-plan <slug>` **Purpose**: Comprehensive pre-implementation review of requirements, design, and tasks. Writes "Traceability Coherence" and "Plan Review" findings to `review-results/plan-review.md`. --- ## Prerequisites - `.claude/specs/<slug>/requirements.md` must exist - `.claude/specs/<slug>/design.md` must exist - `.claude/specs/<slug>/tasks.md` must exist - `.claude/specs/<slug>/progress.md` must exist (used to read `mode`) - `.claude/spec
documentation10
skills/sdd-init
# Skill: sdd-init ## Invocation ``` /sdd-init <slug> [notion-url] [--mode standard|auto] ``` **Arguments:** - `<slug>` — kebab-case identifier for the feature (e.g. `user-invitation`, `supplier-csv-import`) - `[notion-url]` — optional Notion page URL to fetch and archive as source material - `[--mode standard|auto]` — workflow mode (default: `standard`) - `standard`: engineer-led — AI assists, human drives decisions - `auto`: AI-led — suitable for non-engineers; AI asks questions and mak
testing10
skills/sdd-impl
# sdd-impl — Implement Tasks (TDD) ## Slash Command ``` /sdd-impl <slug> [task-id] ``` ## Purpose Implement one task (or all pending tasks) for a spec using strict Test-Driven Development. Delegates test/implementation cycles to the `/ecc:tdd-workflow` skill and keeps `progress.md` up to date throughout. --- ## Prerequisites Before running this skill, confirm: - `sdd-review-plan` has been run: `review-results/plan-review.md` must exist and contain no `❌` in the Traceability section. - `t
development10
skills/sdd-review-requirements
# Skill: sdd-review-requirements ## Invocation ``` /sdd-review-requirements <slug> ``` **Arguments:** - `<slug>` — kebab-case feature identifier matching an existing `.claude/specs/<slug>/` directory --- ## Purpose Review `requirements.md` for completeness, clarity, EARS compliance, ambiguity, and missing edge cases. Writes a structured "Requirements Review" file to `.claude/specs/<slug>/review-results/requirement-review.md`. The mode is read from `progress.md` and determines which agents
documentation10
skills/sdd-requirements
# Skill: sdd-requirements ## Invocation ``` /sdd-requirements <slug> ``` **Arguments:** - `<slug>` — kebab-case feature identifier matching an existing `.claude/specs/<slug>/` directory --- ## Purpose Create or refine `requirements.md` for the feature using the EARS (Event-Action-Response-Stimulus) format. The mode is read from `.claude/specs/<slug>/progress.md` and determines how the AI interacts with the user. --- ## Execution Steps ### Step 1: Read mode from progress.md Read `.clau
development10
skills/sdd-tasks
# sdd-tasks **Slash command**: `/sdd-tasks <slug>` **Purpose**: Generate `tasks.md` (TASK-001..N) and `progress.md` from `requirements.md` and `design.md`. --- ## Prerequisites - `.claude/specs/<slug>/requirements.md` must exist - `.claude/specs/<slug>/design.md` must exist (run `/sdd-design` first) --- ## Steps ### 1. Read spec inputs ``` .claude/specs/<slug>/requirements.md .claude/specs/<slug>/design.md ``` Extract: - Every REQ-XXX ID with its acceptance criteria - Every design sect
content-media10
agent-development
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
tools10
configure
Set up the Telegram channel — save the bot token and review access policy. Use when the user pastes a Telegram bot token, asks to configure Telegram, asks "how do I set this up" or "who can reach me," or wants to check channel status.
testing10
skill-creator
Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, update or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.
testing10
configure
Set up the Discord channel — save the bot token and review access policy. Use when the user pastes a Discord bot token, asks to configure Discord, asks "how do I set this up" or "who can reach me," or wants to check channel status.
testing10
access
Manage iMessage channel access — approve pairings, edit allowlists, set DM/group policy. Use when the user asks to pair, approve someone, check who's allowed, or change policy for the iMessage channel.
testing10
command-development
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
development10
playground
Creates interactive HTML playgrounds — self-contained single-file explorers that let users configure something visually through controls, see a live preview, and copy out a prompt. Use when the user asks to make a playground, explorer, or interactive tool for a topic.
tools10
writing-hookify-rules
This skill should be used when the user asks to "create a hookify rule", "write a hook rule", "configure hookify", "add a hookify rule", or needs guidance on hookify rule syntax and patterns.
documentation10
access
Manage Telegram channel access — approve pairings, edit allowlists, set DM/group policy. Use when the user asks to pair, approve someone, check who's allowed, or change policy for the Telegram channel.
testing10
example-command
An example user-invoked skill that demonstrates frontmatter options and the skills/<name>/SKILL.md layout
tools10
configure
Check iMessage channel setup and review access policy. Use when the user asks to configure iMessage, asks "how do I set this up" or "who can reach me," or wants to know why texts aren't reaching the assistant.
testing10
claude-automation-recommender
Analyze a codebase and recommend Claude Code automations (hooks, subagents, skills, plugins, MCP servers). Use when user asks for automation recommendations, wants to optimize their Claude Code setup, mentions improving Claude Code workflows, asks how to first set up Claude Code for a project, or wants to know what Claude Code features they should use.
tools10
math-olympiad
Solve competition math problems (IMO, Putnam, USAMO, AIME) with adversarial verification that catches the errors self-verification misses. Activates when asked to 'solve this IMO problem', 'prove this olympiad inequality', 'verify this competition proof', 'find a counterexample', 'is this proof correct', or for any problem with 'IMO', 'Putnam', 'USAMO', 'olympiad', or 'competition math' in it. Uses pure reasoning (no tools) — then a fresh-context adversarial verifier attacks the proof using specific failure patterns, not generic 'check logic'. Outputs calibrated confidence — will say 'no confident solution' rather than bluff. If LaTeX is available, produces a clean PDF after verification passes.
tools10
implement-spec
Implement one or more specs while maintaining a per-spec implementation notes file at ./.claude/learned/<slug>.md. Use when the user asks to implement a spec, build a feature, or provides a spec description and wants design decisions, deviations, tradeoffs, and open questions captured as work proceeds.
development10
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
development10
example-skill
This skill should be used when the user asks to "demonstrate skills", "show skill format", "create a skill template", or discusses skill development patterns. Provides a reference template for creating Claude Code plugin skills.
tools10
build-mcp-app
This skill should be used when the user wants to build an "MCP app", add "interactive UI" or "widgets" to an MCP server, "render components in chat", build "MCP UI resources", make a tool that shows a "form", "picker", "dashboard" or "confirmation dialog" inline in the conversation, or mentions "apps SDK" in the context of MCP. Use AFTER the build-mcp-server skill has settled the deployment model, or when the user already knows they want UI widgets.
tools10
build-mcpb
This skill should be used when the user wants to "package an MCP server", "bundle an MCP", "make an MCPB", "ship a local MCP server", "distribute a local MCP", discusses ".mcpb files", mentions bundling a Node or Python runtime with their MCP server, or needs an MCP server that interacts with the local filesystem, desktop apps, or OS and must be installable without the user having Node/Python set up.
tools10
build-mcp-server
This skill should be used when the user asks to "build an MCP server", "create an MCP", "make an MCP integration", "wrap an API for Claude", "expose tools to Claude", "make an MCP app", or discusses building something with the Model Context Protocol. It is the entry point for MCP server development — it interrogates the user about their use case, determines the right deployment model (remote HTTP, MCPB, local stdio), picks a tool-design pattern, and hands off to specialized skills.
tools10
hook-development
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.
tools10
mcp-integration
This skill should be used when the user asks to "add MCP server", "integrate MCP", "configure MCP in plugin", "use .mcp.json", "set up Model Context Protocol", "connect external service", mentions "${CLAUDE_PLUGIN_ROOT} with MCP", or discusses MCP server types (SSE, stdio, HTTP, WebSocket). Provides comprehensive guidance for integrating Model Context Protocol servers into Claude Code plugins for external tool and service integration.
tools10
plugin-settings
This skill should be used when the user asks about "plugin settings", "store plugin configuration", "user-configurable plugin", ".local.md files", "plugin state files", "read YAML frontmatter", "per-project plugin settings", or wants to make plugin behavior configurable. Documents the .claude/plugin-name.local.md pattern for storing plugin-specific configuration with YAML frontmatter and markdown content.
tools10
plugin-structure
This skill should be used when the user asks to "create a plugin", "scaffold a plugin", "understand plugin structure", "organize plugin components", "set up plugin.json", "use ${CLAUDE_PLUGIN_ROOT}", "add commands/agents/skills/hooks", "configure auto-discovery", or needs guidance on plugin directory layout, manifest configuration, component organization, file naming conventions, or Claude Code plugin architecture best practices.
tools10
skill-development
This skill should be used when the user wants to "create a skill", "add a skill to plugin", "write a new skill", "improve skill description", "organize skill content", or needs guidance on skill structure, progressive disclosure, or skill development best practices for Claude Code plugins.
tools10
session-report
Generate an explorable HTML report of Claude Code session usage (tokens, cache, subagents, skills, expensive prompts) from ~/.claude/projects transcripts.
development10
strategic-compact
Suggests manual context compaction at logical intervals to preserve context through task phases rather than arbitrary auto-compaction.
tools10
update-codemaps
Analyzes codebase structure and updates architecture documentation with diff tracking
development10
visualize
Convert documents to infographic images (PNG/JPG/PDF) for easy sharing
documentation10
claude-md-improver
Audit and improve CLAUDE.md files in repositories. Use when user asks to check, audit, update, improve, or fix CLAUDE.md files. Scans for all CLAUDE.md files, evaluates quality against templates, outputs quality report, then makes targeted updates. Also use when the user mentions "CLAUDE.md maintenance" or "project memory optimization".
testing10
spec-requirements
Generate comprehensive requirements definition documents with technology selection and improvement suggestions
documentation10
update-docs
Syncs documentation from source-of-truth files like package.json and .env.example
documentation10
team-builder
Intelligently compose and deploy Claude Code Agent Teams based on user requirements. Auto-selects optimal team composition from all available skills and agents (project, user, global, plugin scopes), generates task dependency graphs, and orchestrates team lifecycle. Use when creating multi-agent teams for complex tasks requiring parallel specialized work.
tools10
ui-advice
Provides UI/UX design pattern advice and generates text wireframes
content-media10
chrome
Comprehensive Chrome DevTools development system with native Chrome capabilities for debugging, E2E testing, performance analysis, and browser automation
tools10
smart-think
Advanced multi-mode thinking system with Sequential Thinking MCP and Serena integration for complex problem solving
tools10
test
Advanced test implementation command with unit/E2E support, auto-execution, and smart fixing capabilities
testing10
test-coverage
Analyzes test coverage and generates missing tests to achieve 80%+ coverage
testing10
spec-tech-research
Advanced technical research command with extended thinking modes and MCP integration for comprehensive analysis
tools10
okr
Create quarterly OKRs based on team goals and role. Generates 3 Objectives with 3 Key Results each (9 total), with 70%/100% achievement criteria.
development10
serena
Token-efficient Serena MCP command for structured app development and problem-solving
tools10
update-claude-md
Intelligent command for automatically generating and updating project-specific CLAUDE.md (Serena + Sequential Thinking integration)
testing10
better-result-adopt
Adopt better-result in an existing TypeScript codebase. Use when replacing try/catch, Promise rejection handling, null sentinels, or thrown domain exceptions with typed Result workflows.
development10
sample/harness/next-js-pages/skills/sdd-review-plan
# sdd-review-plan **Slash command**: `/sdd-review-plan <slug>` **Purpose**: Comprehensive pre-implementation review of requirements, design, and tasks. Appends "Traceability Coherence" and "Plan Review" sections to `review.md`. --- ## Prerequisites - `.claude/specs/<slug>/requirements.md` must exist - `.claude/specs/<slug>/design.md` must exist - `.claude/specs/<slug>/tasks.md` must exist - `.claude/specs/<slug>/progress.md` must exist (used to read `mode`) --- ## Steps ### 1. Read all sp
content-media10
access
Manage Discord channel access — approve pairings, edit allowlists, set DM/group policy. Use when the user asks to pair, approve someone, check who's allowed, or change policy for the Discord channel.
testing9