Superpowers扩展插件集

Superpowers Extensions for Claude Code

Extension skills for the superpowers suite, providing quality gates, development workflow skills, and project lifecycle management for web application development. It includes thirteen skills:

• regression-test -- Comprehensive regression testing using the Microsoft Playwright MCP server, combining existing test suite execution with AI-powered visual and functional browser testing.
• pre-push-review -- A structured branch review that diffs against the base branch and gates on plan adherence, code quality, commit hygiene, and regression testing, producing a PASS/FAIL verdict with a prioritized remediation plan on failure.
• refactor-analysis -- Transitive impact analysis for complex refactorings. Maps all affected files, classifies breaking vs cosmetic changes, identifies risks, and produces a safe execution order with checkpoint boundaries before writing implementation plans.
• decision-tracker -- Persistent cross-cutting decision tracking using LongtermMemory-MCP. Automatically extracts architectural decisions, conventions, and constraints during brainstorming and planning, persists them to semantic long-term memory, and recalls them at session start and subagent dispatch to prevent decision amnesia.
• compress-memory -- Compresses natural-language memory files (CLAUDE.md, STATE.md, ROADMAP.md, project notes) to save input tokens replayed every session. Pure-markdown skill — preserves code blocks, URLs, file paths, frontmatter, headings, tables, and list structure byte-exact; backs up the original to FILE.original.md before each compression. Opt-in via project-orchestration:plan-roadmap; auto-invoked by pause-work. Inspired by caveman-compress (MIT) but reimplemented without a Python toolchain.
• roslyn-codelens-integration -- Superpowers integration for Roslyn CodeLens intelligence. Enforces use of 32 semantic .NET code analysis tools (instead of Grep/Glob and dotnet build) across every superpowers skill — brainstorming, refactor-analysis, writing-plans, executing-plans, subagent-driven-development, systematic-debugging, TDD, verification, code review, and pre-push review.
• memorylens-integration -- Superpowers integration for MemoryLens memory profiling. Enhances systematic-debugging with .NET memory snapshot analysis, leak detection, and before/after fix validation. Direct triggers on "memory leak", "OOM", "high GC pressure". Inert on non-.NET projects.
• project-orchestration -- GSD-inspired project lifecycle management for larger multi-session projects. Brownfield codebase mapping, milestone tracking, phase management, session pause/resume, milestone audit, release cycle management, and a start-next-phase routing hub that mechanically chains brainstorming → writing-plans → executing-plans for the next non-complete phase.
• ui-workflow -- Frontend design contracts and visual auditing. Generates structured UI design contracts before implementing frontend phases (ui-phase) and performs visual audits afterwards (ui-review) using a three-layer grading: contract adherence, anti-slop scan, and 5-dimension critique.
• ui-design-system -- Generates a complete design system before frontend implementation. Three modes: curated (pick from 84 vendored real-world references — Stripe, Linear, Vercel, Notion, Apple, Figma, Supabase, Cursor, Claude, …), guided (7 questions), or quick (inline one-liner). Includes 5 hand-tuned OKLch design directions and an anti-slop checklist. Auto-detects Blazor, React, Vue, Astro stacks. Outputs docs/design/MASTER.md.
• logo-design -- Generates brand marks as hand-authored SVG and audits existing ones. Two sub-skills: logo-concept draws a mark (or derives the variant set for one that already exists) and logo-review audits one across three layers — reproduction hazards, a ten-pattern anti-slop scan, and a five-dimension critique. Ships four mark types (geometric, monogram, wordmark, abstract) and refuses pictorial, mascot, and illustrative-emblem marks by design. Reads docs/design/MASTER.md for palette and typography when present. Outputs docs/design/LOGO.md, seven SVG variants through to a redrawn favicon, a contact sheet, and an eight-file raster icon set exported from those SVGs — recorded UNRUN rather than failed when no SVG rasteriser is installed.
• context-budget -- Keeps long sessions cheap. A UserPromptSubmit hook measures the session's context size and suggests a fresh session at a natural break; a PreToolUse hook requires an explicit non-Fable model on general-purpose subagent dispatches. The skill states the suite-wide model rule (Sonnet by default, Opus for marked tasks, retries and the final review, Haiku for lookups) and the fresh-session handoff recipe.
• squad -- Persistent AI agent teams (Lead, Backend Engineer, Frontend Engineer, Tester, Scribe) dispatched as parallel Task subagents during brainstorming and planning workflows. Each specialist runs in an isolated context window with its own charter and tier-1 history, so they cannot anchor on each other's reasoning. Per-role history.md files accumulate project-specific knowledge across sessions; tiered context lookup (semantic search → grep → recent history) keeps each subagent's prompt lean.

Regression Test Skill

When invoked, Claude follows a structured 4-phase process:

1. Discovery -- Scans your project for existing test frameworks (Playwright, Cypress, Jest, Vitest, Mocha, Karma), test files, route definitions, and the application URL.

2. Existing Test Execution -- Runs any discovered test suites and captures pass/fail/skip results. Failures are recorded but don't block the next phases.

3. Browser-Based Testing -- Uses Playwright MCP tools to:

   • Navigate every discovered page
   • Handle authentication (prompts for credentials when a login form is detected)
   • Check for console errors and failed network requests
   • Verify element visibility and content with browser_verify_* assertion tools
   • Take screenshots at 3 viewport sizes (Desktop 1920x1080, Tablet 768x1024, Mobile 375x812)
   • Evaluate each screenshot for layout, spacing, typography, color/contrast, responsiveness, visual completeness, and overall polish using Claude's vision

4. Reporting -- Generates a timestamped markdown report with embedded screenshots, page-by-page findings, and prioritized recommendations. Also prints a concise summary in the conversation.

Usage

Invoke the skill by asking Claude:

• "Regression test my web app at http://localhost:3000"
• "Run a visual regression check on this application"
• "Smoke test the UI before we deploy"
• /regression-test

Output

The skill produces:

• Screenshots saved to docs/regression-screenshots/YYYY-MM-DD-HHmm/ with filenames like home-desktop.png, dashboard-mobile-full.png
• Markdown report saved to docs/regression-report-YYYY-MM-DD-HHmm.md with summary table, existing test results, page-by-page findings, and recommendations
• Conversation summary with overall status, issue counts, and top 3 findings

Pre-Push Review Skill

The pre-push review skill provides a comprehensive, structured branch review to run before pushing code or creating a pull request. It reviews every change across four dimensions and produces a clear PASS or FAIL verdict.

What It Does

The review covers four dimensions:

1. Plan Adherence -- Verifies that planned work was completed and nothing unplanned snuck in. Compares the diff against plan documents found in docs/superpowers/plans/ (and the legacy docs/plans/).
2. Code Quality -- Reviews the diff against 7 code quality rules: security (OWASP Top 10), YAGNI/over-engineering, debug/temporary code, dead code/unused imports, error handling, naming/readability, and test coverage.
3. Commit Hygiene -- Checks commits for secrets, large files, unintended files (node_modules, build artifacts), merge conflict markers, and commit message quality.
4. Regression Testing -- Runs existing test suites and optionally invokes browser-based regression testing via the regression-test skill.

The 6 Phases

Verdict Logic

On FAIL, the report includes a prioritized remediation plan with specific file/line references, suggested fixes, and effort estimates.

Usage

Invoke the skill by asking Claude:

• "Review this branch before I push"
• "Run a pre-push quality check"
• "Is this branch ready for a PR?"
• /pre-push-review

Output

The skill produces:

• Markdown report saved to docs/pre-push-review-YYYY-MM-DD-HHmm.md with header metrics, per-phase findings, and remediation plan (on FAIL)
• Conversation summary with verdict, issue counts, top 3 findings, and report path

Refactor Analysis Skill

When invoked, Claude follows a structured 7-phase process:

1. Scope Definition -- Reads the design doc, identifies all refactor targets (classes, functions, modules, files), classifies the refactor type (rename, move, extract, inline, change interface, architectural), and confirms with the user.

2. Direct Dependency Mapping -- Searches the codebase for all direct references to each target: imports, type annotations, function calls, configuration references, string-based references, and test file references.

3. Transitive Closure -- Expands beyond direct dependencies by checking if each affected file's public interface changes. If so, treats those exports as new targets and repeats the search until no new files are discovered.

4. Impact Classification -- Classifies each affected file as Breaking (will fail without changes), Update Required (functions but incorrect), Test Impact (tests need updating), or Cosmetic (optional cleanup).

5. Risk Identification -- Flags dynamic references, cross-boundary impacts, circular dependencies, high fan-in nodes, implicit coupling, runtime registration, external consumers, and serialized state.

6. Safe Execution Order -- Produces a topologically sorted sequence of change groups with checkpoint boundaries where tests can run and commits can be made.

7. Output -- Generates a timestamped markdown impact analysis document with summary metrics, a Graphviz dependency graph, annotated file list, risk register, and execution order. Then transitions to writing-plans.

Usage

Invoke the skill by asking Claude:

• "Analyze the impact of this refactoring"
• "What files will be affected if I rename this module?"
• "Run a refactor impact analysis before we start"
• /refactor-analysis

Output

The skill produces:

• Impact analysis document saved to docs/superpowers/specs/YYYY-MM-DD-<topic>-impact-analysis.md with summary table, dependency graph, annotated file list, risk register, and execution order
• Conversation summary with refactor type, affected file counts by classification, top risks, and document path

Decision Tracker Skill

The decision tracker skill provides persistent cross-cutting decision tracking that integrates with the superpowers brainstorming and planning workflow. It uses LongtermMemory-MCP as its persistence layer.

What It Does

The skill operates in three modes:

1. Recall -- At session start, searches long-term memory for decisions tagged with the current project and presents them grouped by category (architectural, convention, task-specific).

2. Extract -- During brainstorming, writing-plans, and refactor-analysis, automatically identifies cross-cutting decisions and saves them to long-term memory with appropriate tags, types, and importance levels.

3. Harvest -- When a superpowers subagent-driven-development or executing-plans run finishes, it saves the run's rule-setting Ruling: lines from the plan ledger before upstream deletes the workspace. It keeps rules and reviewer trade-offs, skips one-task fixes, and tags each saved ruling ruling and plan:<name>. Ledgers left behind by interrupted runs are harvested at the next session start.

Decision Categories

Subagent Integration

When subagent-driven-development dispatches parallel agents, the skill injects only the 2-3 most relevant decisions into each agent's prompt using semantic search -- keeping context focused rather than flooding agents with every decision.

Graceful Degradation

Without LongtermMemory-MCP installed, the skill still identifies decisions and embeds them in plan documents. It nudges the user to install LongtermMemory-MCP for cross-session persistence.

Usage

The skill activates automatically during superpowers workflows. No explicit invocation needed. You can also invoke it directly:

• /decision-tracker

Roslyn CodeLens Integration Skill

The roslyn-codelens-integration skill enhances brainstorming and refactor-analysis with semantic .NET code intelligence when roslyn-codelens MCP tools are available. It activates automatically -- no explicit invocation needed.

What It Does

The skill upgrades text-based code search with semantic Roslyn queries:

• During brainstorming: Calls get_project_dependencies for solution architecture, get_symbol_context for types mentioned in the request, find_implementations and find_callers to ground clarifying questions in actual code, and get_di_registrations / find_reflection_usage when proposing approaches.

• During refactor-analysis: Replaces Grep with find_callers and find_implementations in Phase 2 (dependency mapping), uses get_type_hierarchy and get_project_dependencies for Phase 3 (transitive closure), and adds find_reflection_usage for Phase 5 (risk identification) to catch hidden dynamic coupling.

Graceful Degradation

If roslyn-codelens MCP tools are not available, the skill is completely inert. Brainstorming and refactor-analysis fall back to their standard Grep/Glob-based approach with no errors or warnings.

MemoryLens Integration Skill

The memorylens-integration skill enhances superpowers:systematic-debugging with .NET memory profiling when memorylens-mcp tools are available. It activates automatically — no explicit invocation needed — and triggers directly on user phrases like "memory leak", "OOM", "high GC pressure", or "process memory keeps growing".

What It Does

Memory profiling is injected into two debugging phases:

• Phase 1 — Root Cause Investigation: ensure_dotmemory verifies the dotMemory CLI, list_processes finds the target .NET process, snapshot captures memory state without stopping the process, and analyze runs the 10-rule engine (ML001-ML010) covering event handler leaks, static collection growth, undisposed disposables, LOH fragmentation, hot-path allocations, closure retention, and more.
• Phase 3 — Hypothesis Testing: compare_snapshots validates whether a proposed fix actually reduced retention — captures two snapshots with a configurable delay and diffs growth, new types, and retained bytes. A fix that "looks right" but doesn't move the snapshot is rejected.

The skill also applies its rule knowledge during superpowers:brainstorming on .NET projects — flagging memory risk patterns (event subscriptions, static caches, IDisposable ownership, large buffers) as design questions before code is written.

Graceful Degradation

If MemoryLens MCP tools are not available, the skill is completely inert. systematic-debugging falls back to standard hypothesis testing with no errors or warnings.

Usage

The skill activates automatically when systematic-debugging is on a .NET process. You can also invoke it directly:

• "Investigate the memory leak in OrderService"
• "OOM in production, snapshot the worker"
• "Profile memory after the auth fix"
• /memorylens-integration

Project Orchestration Skill

The project-orchestration skill provides GSD-inspired project lifecycle management for larger, multi-session projects. It wraps around the superpowers workflow without replacing it — adding navigation and state persistence on top of brainstorming, planning, and execution.

Sub-Skills

State Files

All state is stored in docs/planning/ at the project root (commit or gitignore — your choice):

• docs/planning/ROADMAP.md — All milestones and phases with completion status
• docs/planning/MILESTONE.md — Current active milestone definition and definition of done
• docs/planning/STATE.md — Session handoff document written by pause-work, read by resume-work
• docs/planning/CONVENTIONS.md — The project's stack, commit, branching, release, and deployment conventions. Written by init-conventions, read before every commit and tag. Unlike the other three it is stable across milestones rather than per-phase state

Conventions-driven commits and releases

The skill used to hardcode its own git conventions — chore(roadmap): … commit messages and a git tag -a vN.0 release tag on every milestone. Both were wrong on any project that does not happen to share them, and the tag was wrong on this repository itself, where release-please owns releases.

init-conventions now records what the project actually does in docs/planning/CONVENTIONS.md, and a single Commit & Release Protocol in SKILL.md is the only thing that decides how a commit message is rendered or whether a tag is created. Sub-skills pass intent (type / scope / subject); the protocol reads the conventions and renders it — omitting a scope when the host's commitlint would reject it, and never failing a commit over one.

Behavior change for existing users: milestone completion no longer tags unconditionally. complete-milestone honors the project's recorded release mechanism, and where an automation owns releases (release-please, semantic-release, changesets, a CI job) it creates no tag at all and announces which mechanism owns the release instead. Honoring a project's conventions is sometimes the decision not to act. audit-milestone's release-tag criterion is gated on the same field, so a project that does not tag per milestone no longer fails its own audit forever. Projects that do tag per milestone are unaffected — but the tag is now rendered in the scheme and prefix their existing tags already use rather than assumed to be vN.0. On a project with no CONVENTIONS.md, the protocol runs init-conventions to establish one rather than falling back to the old hardcodes.

Usage

The skill activates automatically in session context. You can also invoke it directly:

• "Where are we in the project?" → progress
• "I'm done for today" → pause-work
• "Resume from last session" → resume-work
• "Add a phase for authentication" → add-phase
• "Verify milestone 1 is complete" → audit-milestone
• /project-orchestration

Surviving conversation compaction

When a long session is auto-compacted (VS Code Copilot Chat, long Claude Code sessions, etc.), the generated summary often contains a "Continuation Plan" with code-level instructions. The agent treats those as user instructions and bypasses the workflow — no STATE.md read, no plan check, straight into implementation. See issue #77.

The skill's HARD-GATE includes a Post-compaction discipline section that names compaction as an explicit resume-work trigger and instructs the agent to treat the compaction summary as advisory, not authoritative. For this to fire reliably:

• Keep docs/planning/STATE.md current. pause-work writes it; complete-phase and complete-milestone keep ROADMAP/MILESTONE up-to-date so STATE.md never drifts more than the active phase.
• Reference plan files instead of inlining code-level steps in summaries. When you produce a manual session summary or hand-off note, prefer Continue from docs/superpowers/plans/2026-05-04-m7.md step 3 over fix the auth method to handle null tokens. Reference > recall.
• If using a host that auto-compacts (VS Code Copilot Chat is the worst offender), the first message after compaction should be resume — that hits the explicit resume-work trigger directly, sidestepping any compaction-summary heuristic.

Compress Memory Skill

The compress-memory skill compresses natural-language memory files to save input tokens replayed every Claude Code session, while preserving every byte a downstream consumer (skill or human) might key off.

This is input token compression. Output-style "caveman speech" is explicitly not in scope — it would fight every other skill in this suite that produces structured artifacts.

What It Does

When invoked, the skill:

1. Validates the file is compressible (allowed extension, not on denylist, under 50 kB, no per-file compress: skip opt-out)
2. Backs up the original to <file>.original.md (only on the first compression — subsequent runs leave the backup untouched)
3. Compresses the prose per the drop / replace rules — strips articles, filler, pleasantries, hedging, connective fluff; replaces verbose phrasing with shorter equivalents
4. Preserves byte-exact: fenced code blocks, indented code blocks, inline code spans, URLs and markdown links, file paths, shell commands, environment variables, version numbers, dates, frontmatter blocks, markdown tables, headings, and list nesting
5. Validates structurally — counts of code blocks, headings, URLs, tables must match input; frontmatter byte-equal; code blocks byte-equal
6. Restores from backup if validation fails (no partial corruption)
7. Reports size delta to the user

Denylist (hard-coded, not configurable)

The skill REFUSES to operate on:

• docs/superpowers/** and the legacy docs/plans/** — specs, plans, and reports read literally by writing-plans, executing-plans, subagent-driven-development
• *ui-contract* — UI contracts audited by ui-workflow:ui-review
• *impact-analysis* — refactor impact analyses with nuanced risk register prose
• *-design.md — brainstorm design documents
• *-review-*.md — pre-push review reports and UI review audits
• MILESTONE.md — rewritten only on milestone transitions
• CONVENTIONS.md — machine-read before every commit and tag; its **Key:** value fields are prose, so compression could break them while validation still passes
• *.original.md — backup files (never compressed, never overwritten)
• Anything not .md or .txt, or larger than 50 kB

These files are contracts between skills; compressing them would break downstream consumers.

Opt-in via project-orchestration

The skill is opt-in. During project-orchestration:plan-roadmap, the user is asked once whether to enable compression. The answer is persisted as YAML frontmatter on docs/planning/ROADMAP.md:

---
compress_memory: enabled
---

When enabled, pause-work invokes compress-memory on STATE.md after writing it (and on ROADMAP.md itself when it has changed since the last commit). Compression failures are logged and never block pause-work — local state remains the source of truth even when compression breaks.

Flipping the field to disabled (or removing it) stops auto-compression on subsequent pause-work runs.

Manual usage

The skill is always available manually, regardless of the opt-in setting:

• /compress-memory <path>
• "compress STATE.md"
• "shrink CLAUDE.md"
• "compact this memory file"

Output

• Modified file — the input file is overwritten in place with the compressed version
• Backup — <basename>.original.md containing the pristine first-write copy (e.g. docs/planning/STATE.md → docs/planning/STATE.original.md)
• Conversation report — size delta (Before / After / Saved) and backup path

Prerequisites

No additional tools required. Runs in the active Claude Code conversation — no Python, no extra MCP servers.

Attribution

Inspired by caveman-compress (MIT). See plugins/compress-memory/skills/compress-memory/NOTICE.md for the full attribution.

Context Budget Skill

The context-budget skill keeps long sessions cheap. Two hooks do the measuring and checking; the skill holds the rules and the handoff recipe.

What It Does

• Size reminder. A UserPromptSubmit hook reads the session transcript and, once the context passes 200000 tokens, adds a reminder. It turns firm at 400000 tokens and re-arms every further 50000 tokens. The count resets only when the size drops by at least 50000 tokens, for example after a compaction. After a compaction the hook measures the size from the compaction record. The hook only ever adds a suggestion.
• Dispatch check. A PreToolUse hook on the Agent and Task tools denies any Fable model. It also denies a missing model on general-purpose dispatches, so every such subagent runs on a model chosen on purpose. fork and every other agent type pass.
• Model rule. Haiku, Sonnet and Opus only. Implementers and reviewers default to Sonnet; Opus is for a plan task marked **Model:** opus, a stuck-implementer retry and the final whole-branch review; Haiku is only for lookups and searches. The rule holds in every run, including plain subagent-driven-development and executing-plans.
• Fresh-session handoff. At a natural break, and only when the next work needs nothing from the current context, Claude offers a fresh session. A big context that the work needs is fine, and Claude then says nothing. With docs/planning/STATE.md present the handoff uses pause-work; otherwise Claude writes .claude/handoff.md and gives you one line to paste into the new session. Where the create_session tool is available, as with Claude Code Remote or a Remote Control server, Claude instead offers to start the new session with the full handoff as its first message, checks that it is running, and then archives the old session.

Hooks never fail a turn. On any error they exit silently.

Configuration

Optional .claude/context-budget.json in the project:

{ "nudge": 200000, "firm": 400000, "enforceDispatchModel": true }

A missing or invalid file means the defaults shown.

Prerequisites

Node.js, which Claude Code already requires. The hooks run on Linux, macOS and Windows.

UI Workflow Skill

The ui-workflow skill provides two complementary capabilities that close the design-implementation gap in frontend work.

Sub-Skills

ui-phase — Run before implementing a frontend phase. Produces a structured UI design contract covering:

• Design system tokens (colors, typography, spacing, component library)
• Component inventory with props API, variants, and interaction states
• Layout specification at desktop (≥1280px), tablet (768–1279px), and mobile (<768px)
• Interaction states: loading, empty, error, success
• Accessibility requirements (ARIA roles, keyboard nav, contrast targets)

The contract is saved to docs/superpowers/specs/YYYY-MM-DD-<phase>-ui-contract.md and becomes the implementation spec.

ui-review — Run after implementing a frontend phase. Audits the result against the ui-contract using regression-test screenshots. Three-layer grading:

1. Contract adherence — each criterion rated ✅ Pass / ⚠️ Partial / ❌ Missing.
2. Anti-slop scan — 9 binary Pass/Fail checks for AI-generated UI tells (purple gradients as default, generic emoji icons, hand-drawn SVG humans, Inter as display face, invented metrics, filler copy, etc.).
3. 5-dimension critique — Philosophy / Hierarchy / Execution / Specificity / Restraint, each scored 1-5 with band labels. Floor score is the gate, not the average.

Final verdict is the worst of the three sub-verdicts:

A contract-clean implementation with critique floor 2 (e.g. specificity = 2/5) still fails — anti-slop and critique-floor are hard floors regardless of contract match. The audit report is saved to docs/superpowers/reviews/YYYY-MM-DD-ui-review-<phase>.md.

Usage

• "Let's design the UI for this phase" → ui-phase
• "Review the UI against the design spec" → ui-review
• /ui-workflow

Prerequisites

• ui-phase: No additional tools required.
• ui-review: Requires the regression-test skill and its Playwright MCP prerequisite.

UI Design System Skill

The ui-design-system skill generates a complete design system before frontend implementation begins, ensuring consistent tokens, patterns, and visual language across the entire application.

Modes

Curated mode — Pick a real-world reference from the 84-system vendored catalog (Stripe, Linear, Vercel, Notion, Apple, Figma, Supabase, Cursor, Claude, Cohere, Mistral, Notion, Airbnb, Spotify, and more). The skill loads the reference's DESIGN.md (real CSS tokens, fonts, shadow values extracted from production sites), asks 3 adaptation questions, and writes MASTER.md with explicit Inspired by: attribution and a Deviations from reference: section.

• ui-design-system: like linear
• ui-design-system: based on stripe
• "Make it look like Notion" → curated mode

Guided mode — The skill asks 7 targeted questions (product type, brand feel, primary audience, existing brand constraints, scale, must-avoid patterns, optional reference product) before generating the system. Question 7 — naming a reference product — switches mid-flow into curated mode.

Quick mode — Invoke with a single inline description and the skill infers all design decisions:

• "Generate a design system for a SaaS dashboard"
• /ui-design-system dark modern fintech

Contrast check

Before MASTER.md is written, every text pair the design system defines (text on background and surface, foreground on primary and secondary, each semantic colour on background) is checked with scripts/contrast.mjs and must reach WCAG AA 4.5:1. The ratios are recorded in MASTER.md's Contrast section. The five built-in OKLch directions are held to the same bar by a test that runs in CI.

Curated catalog

84 real-world design systems vendored from VoltAgent/awesome-design-md (MIT) and categorized in design-systems/INDEX.md:

The catalog auto-refreshes every Monday via refresh-design-systems.yml — opens a PR with upstream additions, removals, and edits for human review.

5 design directions

Five hand-tuned OKLch palettes inline in the skill, used when no reference is named:

• Editorial Restraint — premium content / fintech (Stripe, Apple, Monocle vibe)
• Modern Minimal — developer SaaS / productivity (Linear, Vercel, Notion vibe)
• Warm Soft — consumer / creator tools (Notion warm, Cohere, Lovable, Cal vibe)
• Tech Utility — dev tools / ops dashboards (Datadog, Sentry, ClickHouse vibe)
• Brutalist Experimental — editorial / anti-corporate (x.ai, Are.na, Wired vibe)

Each direction ships 6 OKLch tokens, 3 font categories, and 4-6 posture rules.

What It Generates

• Color system — Primary, secondary, accent, semantic (success/warning/error/info), neutral scales, and dark-mode variants
• Typography — Font families, type scale (xs through 4xl), line heights, letter spacing, and heading/body/mono stacks
• Spacing & layout — Base unit, spacing scale, breakpoints, container widths, and grid system
• Component patterns — Button variants, form elements, card styles, navigation patterns, and feedback components
• Stack-specific tokens — CSS custom properties, Tailwind config, or framework-specific variables depending on detected stack
• Anti-slop scan — generated MASTER.md is screened against 9 patterns to avoid (purple gradients as default, generic emoji feature icons, hand-drawn SVG humans, Inter as display face, invented metrics without citation, etc.)

Stack Detection

Auto-detects Blazor, React, Vue, and Astro projects and tailors output format (CSS variables, Tailwind config, MudBlazor theme, etc.) accordingly.

Usage

• ui-design-system: like <name> → curated mode
• "Make it look like Linear" → curated mode (mid-flow handoff from guided mode)
• "Create a design system" → guided mode (7 questions)
• ui-design-system: <inline description> → quick mode
• /ui-design-system

Output

The skill produces docs/design/MASTER.md — a single source-of-truth design system document with all tokens, patterns, stack-specific implementation snippets, and (in curated mode) deviation tracking.

Prerequisites

No additional tools required.

Logo Design Skill

The logo-design skill generates a brand mark as hand-authored SVG — every coordinate derived by arithmetic from one already placed, rather than sampled freehand — and audits marks that already exist, including ones it never drew.

Sub-Skills

logo-concept — Draws a new mark, or derives the variant set for a mark that already exists. Eight numbered steps: read docs/design/MASTER.md and scan for an existing mark; capture the brief verbatim before drawing; ask five questions one at a time; write three directions as rationale before anything is drawn; draw all three on a 16-unit grid on a 256 artboard; render them on a fixed contact sheet and critique the render against a nine-item checklist; present the survivors for the user to pick or blend; then derive the variant set and close out docs/design/LOGO.md. Two renders per presentation — the first, and one re-render after fixes. There is no third.

logo-review — Audits a mark across three layers. The verdict is the worst of the three:

1. Reproduction hazards — binary per item: minimum sizes for screen and print, clearspace, mono collapse, dark inversion, the favicon redraw tests, path complexity, and artboard hygiene.
2. Anti-slop scan — ten clichés, each with a source signature. None of the ten needs a render to detect, so this layer runs in full with or without a browser.
3. Five-dimension critique — Distinctiveness, Simplicity, Memorability, Appropriateness, Versatility, each scored 1-5. The floor gates, not the average.

The vocabulary is deliberately ui-workflow's ui-review: PASS / PARTIAL / FAIL per layer, so a verdict on a mark and a verdict on a screen mean the same thing to the person reading both. The report is saved to docs/design/YYYY-MM-DD-logo-review.md. logo-review never writes LOGO.md and never redraws the mark.

Mark types — four shipped, three refused

Four types are shippable, each with its own recipe, worked fragment, and characteristic failure: geometric (the default when the user has no preference), monogram, wordmark, and abstract.

Three are refused by name, behind a <HARD-GATE>:

This is a feature, not a caveat. The gate fires on the request, before anything is drawn; it is not negotiable by the user and not waivable by the agent. The skill will not draw a simplified version, a placeholder, or a rough — and it will not ship a degraded mark with a disclaimer attached. The reason is mechanical rather than modest: the skill derives every coordinate from one already placed, and its own reproduction layer treats an outline that reuses none of its own numbers as a tracing signature and fails it. A convincing animal is exactly that outline. Instead it offers three alternatives: a brief-only deliverable, a different mark type that serves the same goal, or commissioning a designer or illustrator — stated plainly as the legitimate answer it often is.

Entry paths

Three, decided before anything is drawn by a guard that scans assets/brand/, public/brand/, wwwroot/brand/, public/favicon.* and static/logo.*. A hit does not decide the route on its own — what was asked for does:

A replacement is never generated for a mark that already exists. Offered after an audit it is a decision the user can weigh; offered instead of one it is a guess about work somebody already paid for. The route and the row that matched are announced before any work happens.

Output

• docs/design/LOGO.md — the record: the brief verbatim, the seed and derivation chain, the nine optical corrections one row each, stroke and counter values, computed contrast, clearspace and minimum sizes, misuse rules that each cite a number from the file, and an asset manifest. An empty slot is a finding, not a silence.
• Seven SVG variants — logo-mark.svg, logo-wordmark.svg, logo-full.svg, logo-stacked.svg, logo-mono-black.svg, logo-mono-white.svg, and logo-favicon.svg — written to public/brand/, wwwroot/brand/, or assets/brand/ depending on the detected stack. The favicon is redrawn, not scaled. Where a variant is meaningless for the chosen type (a wordmark has no mark-alone symbol) the row reads n/a with a reason and no file ships — the count is never padded to reach seven.
• An eight-file raster icon set — favicon-16.png, favicon-32.png, favicon-48.png, favicon.ico, apple-touch-icon.png, icon-192.png, icon-512.png, and icon-1024.png — exported from the SVG set by a bundled Node script, each routed to the SVG whose reproduction spec covers its size. Where no SVG rasteriser (resvg, rsvg-convert, Inkscape, ImageMagick) is on the machine, the step degrades to UNRUN rather than failing — the SVG set still ships. A separate, always-offered step can then replace a host project's existing icon files with the exported set, matching by each file's actual pixel size rather than its name, and never adding an icon the project doesn't already reference.
• docs/design/logo-contact-sheet.html — the fixed render harness: every candidate at each size, on both grounds, in colour and mono, with a measurement readout. It prints each number beside the threshold it is held against and returns no verdict; the grading belongs to the skill.
• docs/design/YYYY-MM-DD-logo-review.md — logo-review's report: verdict line, a three-row summary, then the failures and a prioritised findings list.

Honest limits

• The vision collision check is not a trademark search. Where the sheet has been rendered and read back, one thing looked for is a resemblance to a mark the model happens to recognise. It consults no corpus and queries no register, and a resemblance it does not recognise is not a resemblance that is absent. LOGO.md carries that disclaimer as fixed text that ships unedited, and no sentence in either flow describes the pass as a search. Clearance remains somebody's job.
• Wordmarks ship referencing a declared webfont. The skill has no font engine — an explicit non-goal, not an oversight — so outline conversion is recorded as a step that was not performed. It has to happen before the mark is used anywhere the webfont is not guaranteed: print, embroidery, a third party's site, an email client. Until it does, a text-bearing wordmark is not a finished asset.
• logo-review cannot issue PASS for a mark with no LOGO.md. Several checklist items are satisfiable only by a record — a derivation answer that only whoever drew the mark can give — so an undocumented mark caps at PARTIAL — evidence-limited. That is deliberate: a skill that issued PASS anyway would be certifying the absence of evidence. It is a statement about the evidence rather than about the mark: the remediation is the record and never a redraw, and the report's first sentence says that no finding was raised against the mark.

Usage

• "Design a logo for this product", "we need a brand mark" → logo-concept
• "Make us a favicon", "we need a dark version", "we need a stacked lockup" → logo-concept, variants-only
• "Review our logo", "does our mark survive at favicon size" → logo-review
• logo-design: <one-liner> → quick mode, which skips the questions the one-liner already answers. Where the mark must survive is asked anyway, standalone, because it eliminates half the solution space before anything is drawn.
• /logo-design

Prerequisites

• Playwright MCP — optional, but strongly recommended. Every render-dependent check goes through it. Without it both sub-skills still run and the contact sheet is still written, but every such check is recorded UNRUN — <what would decide it>, never passed — and a review caps at PARTIAL — evidence-limited. grep UNRUN over a finished LOGO.md lists everything the record admits it does not know.
• docs/design/MASTER.md — optional. Read for palette and typography when present. When it is absent the mark ships in currentColor and the absence is recorded; running ui-design-system first produces a better result, but this skill never blocks on it.

Squad Skill

Squad creates persistent AI agent teams within your Claude Code session. Rather than treating Claude as a single assistant, squad dispatches five specialists — Lead, Backend Engineer, Frontend Engineer, Tester, and Scribe — as parallel Task subagents that participate actively in superpowers workflows and grow smarter about your project across sessions.

How It Works

Each specialist runs in an isolated Task subagent context window — not as an in-context persona. When a question is routed to one or more specialists:

1. Routing — match against routing.md to identify the relevant specialist(s) — possibly more than one.
2. Tiered lookup per specialist — extract the most relevant slice of that specialist's history.md:
   1. Semantic search (LongtermMemory-MCP) — fastest, cross-session
   2. Grep history — keyword match against history file
   3. Recent history — last 50 lines only
   4. Full history load — last resort
   5. Charter only — no history yet
3. Parallel dispatch — all relevant specialists go out as Task calls in a single assistant message, which causes Claude Code to fan them out concurrently. Each subagent's prompt has the same four-block shape: charter + recent project history + the routed question + response rules (prefix with role's emoji + name, cite history when applicable, mark [new-decision] for squad-sync).
4. Integration — when all subagents return, the main conversation presents their prefixed responses in stable order (Lead, Backend, Frontend, Tester, Scribe). For workflows that need a single answer (writing-plans review, pre-push-review verdict, plan-roadmap synthesis), Lead is then dispatched as a final subagent with the prior outputs as input.

The point of dispatching as separate subagents — instead of voice-switching inline — is isolation. Specialists genuinely cannot see each other's reasoning, so the second never anchors on the first.

Agents

Workflow Integration

• brainstorming — multi-specialty clarifying questions dispatch all relevant specialists in one parallel Task message; the main conversation presents prefixed responses
• writing-plans — Tester + Scribe dispatched in parallel after the plan is drafted; both findings merge into a ## Squad Review section
• subagent-driven-development — squad enriches each task subagent's prompt with role-specific tier-1 history (orthogonal to squad's own dispatch — both can run side by side)
• pre-push-review — Phase 2 (Scribe / decisions) and Phase 3 (Tester / risk) dispatched in parallel during evidence gathering
• project-orchestration — squad-sync auto-fires on pause-work. plan-roadmap dispatches all five specialists in parallel for roadmap-scope perspectives, then Lead synthesizes
• dispatching-parallel-agents — the lower-level superpowers skill governing how to construct multi-call messages; squad's routing layer decides which specialists, that skill governs how the calls are issued

Automatic Learning

At session end, a background agent distills learnings and appends dated entries to each agent's history.md — no prompting needed. After a few sessions, agents know your auth pattern, naming conventions, risky areas, and more. Subagents are instructed to mark new project decisions with [new-decision] so squad-sync can pick them up reliably.

Usage

• "Initialize my squad" → squad-init
• "Who's on my team?" → squad-status
• @backend how does our auth work? → squad-ask
• "Squad sync" → squad-sync (manual checkpoint)
• /squad

Output

Squad produces and maintains:

• ~/.claude/squad/agents/{name}/history.md — global agent wisdom
• .squad/agents/{name}/history.md — project-specific knowledge
• .squad/decisions.md — shared team decision log

Installation

claude plugin install squad

No MCP servers required. Optionally install longterm-memory for semantic search in tier 1:

claude plugin install longterm-memory

Ecosystem

Superpowers Extensions serves as the single entrypoint for the entire superpowers extension ecosystem. One install pulls in the core superpowers skills and all companion plugins:

MCP description compression (optional, not bundled)

If MCP tool descriptions bloat your context window — particularly Playwright's, which is large — caveman-shrink is a Node middleware that wraps any MCP server and compresses tool descriptions on startup. It is intentionally NOT bundled in this suite because it is MCP runtime infrastructure, not a Claude Code skill. The two compress projects sit at different layers: compress-memory (this suite) compresses persistent files on disk; caveman-shrink (separate) compresses per-session MCP descriptions in memory. Install separately with npm install -g caveman-shrink if relevant.

GitHub Copilot Support

These skills can also be used with GitHub Copilot via Copilot Skill Bridge -- a VS Code extension that discovers Claude marketplace skills, converts them to Copilot-compatible prompt/instruction files, and imports MCP server configurations. Add this repo as a marketplace source and the bridge will resolve all dependencies transitively.

Multi-Provider Support

Source-of-truth is one shared plugins/<name>/skills/<name>/SKILL.md tree of markdown files. Each supported coding-agent harness has a manifest at the repo root pointing at the same files. Skill content does not change per harness; only how the harness loads them.

The polymorphic hooks/session-start script detects which harness is running it via env vars (CURSOR_PLUGIN_ROOT, CLAUDE_PLUGIN_ROOT, COPILOT_CLI) and emits the JSON shape that harness expects (additional_context for Cursor, hookSpecificOutput for Claude Code, top-level additionalContext for SDK-standard hosts including Copilot CLI). Only Cursor registers it today, through hooks/hooks-cursor.json. Claude Code installs each plugin under plugins/ separately and lists every installed skill natively, so it needs no session-start injection and the repo root is not a Claude Code plugin. hooks/run-hook.cmd is the Windows polyglot wrapper that routes to Git Bash on Windows hosts.

Upstream compatibility

The suite builds on obra/superpowers and is pinned to the release in .github/upstream-superpowers.json (currently v7.0.0).

• CI runs npm run check:upstream, which clones the pinned release and fails if any superpowers:<skill> the suite names is missing, or if upstream text the suite relies on has moved. That covers the spec and plan locations under docs/superpowers/, brainstorming's hand-off to writing-plans, and the writing-plans steps squad hooks into.
• upstream-watch.yml checks daily for a new upstream release. For each one it opens a single upstream-superpowers issue with the release notes, a diff stat of upstream's skills and hooks, and the result of check-upstream against the new release. Bump the pin in the PR that adapts the suite.
• Projects started before superpowers v6 keep specs and plans in docs/plans/. Every skill that reads them checks there as a fallback.

What is not supported

Honestly: VS Code Copilot Chat (.github/copilot-instructions.md), Copilot Workspace, Aider, Continue, and Windsurf are not targeted by these manifests. For VS Code Copilot Chat specifically, use the separate Copilot Skill Bridge linked above — it converts Claude marketplace skills into Copilot instruction/prompt files at the project level.

Caveats

• Cursor / Codex / Gemini / Copilot CLI / OpenCode integrations are best-effort. Pattern adapted from obra/superpowers (MIT). Verify in your environment before relying on it for production work — the underlying plugin formats for some of these harnesses are still evolving.
• No using-superpowers-extensions bootstrap skill. This suite piggy-backs on obra/superpowers for the meta-skill that disciplines agents to invoke skills via the Skill tool. Install obra/superpowers alongside (it is already a marketplace dependency of this repo).
• The 84 vendored design systems under plugins/ui-design-system/skills/ui-design-system/design-systems/ travel with each harness — they are plain markdown, every harness reads them.

Pattern attribution

The multi-provider mechanism here is adapted directly from obra/superpowers (MIT). Their session-start hook was the model for ours; their per-harness manifest pattern is what enables one shared markdown tree to load natively in each host. Differences: we are a marketplace of thirteen plugins (versus their single-plugin layout), so our manifests target the suite at the repo root with skills resolved via ./plugins/.

Installation

Option A: Install as Claude Code Plugin (Recommended)

Install directly from GitHub -- this single command pulls in superpowers core skills, LongtermMemory-MCP, roslyn-codelens-mcp and memorylens-mcp as transitive dependencies:

claude install gh:MarcelRoozekrans/superpowers-extensions

Then install the plugins you need from the marketplace:

# Install all extension skills
claude plugin install regression-test
claude plugin install pre-push-review
claude plugin install refactor-analysis
claude plugin install decision-tracker
claude plugin install roslyn-codelens-integration
claude plugin install memorylens-integration
claude plugin install project-orchestration
claude plugin install ui-workflow
claude plugin install ui-design-system
claude plugin install squad
claude plugin install compress-memory
claude plugin install logo-design
claude plugin install context-budget

The regression-test plugin automatically configures the Playwright MCP server with --caps=testing. The pre-push-review plugin requires only git and no additional MCP servers for its core review.

Option B: Install from Local Clone

Clone the repository and install as a local marketplace:

git clone https://github.com/MarcelRoozekrans/superpowers-extensions.git
claude install /path/to/superpowers-extensions

# Install one or more plugins
claude plugin install regression-test
claude plugin install pre-push-review

# Install the refactor analysis skill
claude plugin install refactor-analysis

Option C: Manual Installation

If you prefer manual setup:

1. Add the Playwright MCP server (required for regression-test, optional for pre-push-review):

claude mcp add playwright -- npx @playwright/mcp@latest --caps=testing

The --caps=testing flag enables assertion tools (browser_verify_*, browser_generate_locator) used during functional checks.

2. Copy the skill files:

# Windows -- regression-test
xcopy /E /I plugins\regression-test\skills\regression-test %USERPROFILE%\.claude\skills\regression-test

# Windows -- pre-push-review
xcopy /E /I plugins\pre-push-review\skills\pre-push-review %USERPROFILE%\.claude\skills\pre-push-review

# macOS / Linux -- regression-test
cp -r plugins/regression-test/skills/regression-test ~/.claude/skills/regression-test

# macOS / Linux -- pre-push-review
cp -r plugins/pre-push-review/skills/pre-push-review ~/.claude/skills/pre-push-review

# Windows -- refactor-analysis
xcopy /E /I plugins\refactor-analysis\skills\refactor-analysis %USERPROFILE%\.claude\skills\refactor-analysis

# macOS / Linux -- refactor-analysis
cp -r plugins/refactor-analysis/skills/refactor-analysis ~/.claude/skills/refactor-analysis

# Windows -- decision-tracker
xcopy /E /I plugins\decision-tracker\skills\decision-tracker %USERPROFILE%\.claude\skills\decision-tracker

# macOS / Linux -- decision-tracker
cp -r plugins/decision-tracker/skills/decision-tracker ~/.claude/skills/decision-tracker

# Windows -- roslyn-codelens-integration
xcopy /E /I plugins\roslyn-codelens-integration\skills\roslyn-codelens-integration %USERPROFILE%\.claude\skills\roslyn-codelens-integration

# macOS / Linux -- roslyn-codelens-integration
cp -r plugins/roslyn-codelens-integration/skills/roslyn-codelens-integration ~/.claude/skills/roslyn-codelens-integration

# Windows -- memorylens-integration
xcopy /E /I plugins\memorylens-integration\skills\memorylens-integration %USERPROFILE%\.claude\skills\memorylens-integration

# macOS / Linux -- memorylens-integration
cp -r plugins/memorylens-integration/skills/memorylens-integration ~/.claude/skills/memorylens-integration

# Windows -- project-orchestration
xcopy /E /I plugins\project-orchestration\skills\project-orchestration %USERPROFILE%\.claude\skills\project-orchestration

# macOS / Linux -- project-orchestration
cp -r plugins/project-orchestration/skills/project-orchestration ~/.claude/skills/project-orchestration

# Windows -- ui-workflow
xcopy /E /I plugins\ui-workflow\skills\ui-workflow %USERPROFILE%\.claude\skills\ui-workflow

# macOS / Linux -- ui-workflow
cp -r plugins/ui-workflow/skills/ui-workflow ~/.claude/skills/ui-workflow

# Windows -- ui-design-system
xcopy /E /I plugins\ui-design-system\skills\ui-design-system %USERPROFILE%\.claude\skills\ui-design-system

# macOS / Linux -- ui-design-system
cp -r plugins/ui-design-system/skills/ui-design-system ~/.claude/skills/ui-design-system

# Windows -- squad
xcopy /E /I plugins\squad\skills\squad %USERPROFILE%\.claude\skills\squad

# macOS / Linux -- squad
cp -r plugins/squad/skills/squad ~/.claude/skills/squad

# Windows -- compress-memory
xcopy /E /I plugins\compress-memory\skills\compress-memory %USERPROFILE%\.claude\skills\compress-memory

# macOS / Linux -- compress-memory
cp -r plugins/compress-memory/skills/compress-memory ~/.claude/skills/compress-memory

# Windows -- logo-design
xcopy /E /I plugins\logo-design\skills\logo-design %USERPROFILE%\.claude\skills\logo-design

# macOS / Linux -- logo-design
cp -r plugins/logo-design/skills/logo-design ~/.claude/skills/logo-design

# Windows -- context-budget
xcopy /E /I plugins\context-budget\skills\context-budget %USERPROFILE%\.claude\skills\context-budget

# macOS / Linux -- context-budget
cp -r plugins/context-budget/skills/context-budget ~/.claude/skills/context-budget

Note: Some plugins require companion MCP servers. Install them separately:

• decision-tracker: claude mcp add longterm-memory -- npx -y longterm-memory-mcp
• roslyn-codelens-integration: claude install gh:MarcelRoozekrans/roslyn-codelens-mcp. That plugin ships the MCP server; don't also add it with claude mcp add, or every session starts two servers that both load the solution.
• memorylens-integration: claude install gh:MarcelRoozekrans/memorylens-mcp. Same: that plugin ships the server.

Optional Playwright Flags

# Headed mode (see the browser window)
claude mcp add playwright -- npx @playwright/mcp@latest --caps=testing --headless=false

# All capabilities (testing + PDF export + vision-based coordinates)
claude mcp add playwright -- npx @playwright/mcp@latest --caps=testing,pdf,vision

Verify Installation

In Claude Code, the skills should appear when you type /regression-test, /pre-push-review, /refactor-analysis, /decision-tracker, /roslyn-codelens-integration, /memorylens-integration, /project-orchestration, /ui-workflow, /ui-design-system, /squad, /compress-memory, /logo-design, or /context-budget, or when you ask Claude to perform regression testing, a pre-push review, a refactor impact analysis, decision tracking, .NET code graph analysis, .NET memory profiling, project lifecycle management, UI design contract work, design system generation, to activate your agent team, to compress a memory file, or to design or audit a brand mark.

Development Workflows

These skills are designed to compose. Below are the standard workflows for different development scenarios, showing which skills to invoke and in what order.

Starting a New Project

Run once when you begin working on a project with Claude:

1. squad-init          — set up your persistent agent team
2. project-orchestration map-codebase  — brownfield analysis (existing projects only)
3. decision-tracker    — runs automatically once brainstorming starts

After that, each session begins by Claude recalling prior decisions and squad loading agent histories. You don't need to re-explain your architecture, conventions, or prior choices.

Standard Feature Development

The core loop for building new features:

brainstorming          → explore the idea, squad answers domain questions
writing-plans          → detailed task plan with file paths and TDD steps
subagent-driven-development  → parallel execution with review between tasks
pre-push-review        → PASS/FAIL gate before push or PR

In practice:

"Let's build [feature]"        → triggers brainstorming (squad participates)
"Write a plan for this"        → triggers writing-plans (Tester + Scribe review it)
"Execute the plan"             → triggers subagent-driven-development
"Review before I push"         → triggers pre-push-review

Refactoring Existing Code

When a change touches many files or crosses architectural boundaries:

refactor-analysis      → transitive impact analysis, safe execution order
writing-plans          → implementation plan scoped to the impact analysis
subagent-driven-development  → parallel execution per change group
pre-push-review        → PASS/FAIL gate

For .NET codebases with roslyn-codelens-integration installed, refactor-analysis automatically uses Roslyn semantic queries instead of grep — catching dynamic references and reflection-based coupling that text search misses.

In practice:

"Analyze the impact of renaming X"  → triggers refactor-analysis
"Write a plan based on this"        → triggers writing-plans
"Execute it"                        → triggers subagent-driven-development

Frontend Development

When building or redesigning UI:

ui-design-system       → generate design tokens and component patterns (once per project)
                         curated mode: pick from 84 vendored references (Stripe, Linear, …)
                         guided mode: 7 questions
                         quick mode: inline one-liner
logo-design            → brand mark as SVG, from brief to favicon (once per product)
                         logo-concept: draw a mark, or derive its variant set
                         logo-review: audit an existing mark across 3 layers
ui-workflow ui-phase   → generate UI contract before implementing each frontend phase
[implement the phase]  → subagent-driven-development executes the contract
ui-workflow ui-review  → 3-layer audit: contract adherence + anti-slop scan + 5-dim critique
                         verdict is the worst of the three

In practice:

"Make it look like Linear"                   → ui-design-system curated mode
"Generate a design system for this project"  → ui-design-system guided mode
"Design a logo for this product"             → logo-design logo-concept
"Review our logo"                            → logo-design logo-review
"Design the UI for this phase"               → ui-workflow ui-phase
"Execute"                                    → subagent-driven-development
"Review the UI"                              → ui-workflow ui-review

Multi-Session Projects

For larger efforts that span multiple work sessions and milestones:

project-orchestration map-codebase   → understand the existing codebase
project-orchestration init-conventions → record stack, commit, and release conventions
project-orchestration progress       → "where are we?" at each session start
[standard feature/refactor workflows per phase]
project-orchestration pause-work     → checkpoint state + auto squad-sync
project-orchestration resume-work    → restore context at next session
project-orchestration audit-milestone → verify definition of done
project-orchestration complete-milestone → archive milestone, release per conventions

Squad + project-orchestration: pause-work automatically triggers squad-sync, so agent histories stay current without any extra steps.

Bug Fixing

For diagnosing and fixing unexpected behavior:

systematic-debugging   → structured root cause analysis before touching code
[fix + TDD]            → write failing test, fix, verify green
pre-push-review        → gate before push

For .NET memory leaks specifically:

systematic-debugging   → identifies memory as the concern
memorylens-integration → snapshot before and after, compare, confirm fix

Skill Composition at a Glance

The enrichment skills (squad, decision-tracker, roslyn-codelens-integration) activate automatically when present — no explicit invocation needed.

Project Structure

superpowers-extensions/
├── .claude-plugin/
│   └── marketplace.json                    # Marketplace catalog (all plugins)
├── .github/
│   └── workflows/
│       ├── lint.yml                        # markdownlint + commitlint on PR
│       ├── refresh-design-systems.yml      # Weekly auto-refresh of vendored catalog
│       └── release-please.yml              # Release automation
├── scripts/
│   └── refresh-design-systems.sh           # Atomic, idempotent catalog refresh
├── plugins/
│   ├── regression-test/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json                 # Plugin metadata
│   │   ├── .mcp.json                       # Playwright MCP server config
│   │   └── skills/
│   │       └── regression-test/
│   │           ├── SKILL.md                # Main skill -- 4-phase workflow
│   │           ├── visual-criteria.md      # Visual evaluation rubric (7 criteria)
│   │           └── test-framework-detection.md  # Framework & route detection
│   ├── pre-push-review/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json                 # Plugin metadata
│   │   └── skills/
│   │       └── pre-push-review/
│   │           ├── SKILL.md                # Main skill -- 6-phase workflow
│   │           ├── code-quality-rules.md   # 7 code quality review rules
│   │           └── commit-hygiene-rules.md # Commit hygiene checks
│   ├── refactor-analysis/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json                 # Plugin metadata
│   │   └── skills/
│   │       └── refactor-analysis/
│   │           ├── SKILL.md                # Main skill -- 7-phase workflow
│   │           └── reference-types.md      # Reference types catalog
│   ├── decision-tracker/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       └── decision-tracker/
│   │           └── SKILL.md
│   ├── roslyn-codelens-integration/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       └── roslyn-codelens-integration/
│   │           └── SKILL.md
│   ├── memorylens-integration/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       └── memorylens-integration/
│   │           ├── SKILL.md                # Phase 1 + Phase 3 augmentation for systematic-debugging
│   │           └── rule-reference.md       # ML001-ML010 triggers, impact, and fix patterns
│   ├── project-orchestration/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       └── project-orchestration/
│   │           ├── SKILL.md                # 18 sub-skills for project lifecycle (start-next-phase routing hub, plan-roadmap, init-conventions, github-sync)
│   │           ├── state-files.md          # docs/planning/ file format reference
│   │           └── templates/              # roadmap / milestone / phase design + conventions templates
│   ├── ui-workflow/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       └── ui-workflow/
│   │           ├── SKILL.md                # ui-phase and ui-review sub-skills (anti-slop + 5-dim critique)
│   │           └── ui-contract-template.md # UI design contract template
│   ├── ui-design-system/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       └── ui-design-system/
│   │           ├── SKILL.md                # curated / guided / quick modes
│   │           ├── domains/                # SaaS / admin / marketing domain rules
│   │           ├── stacks/                 # Astro / Blazor / generic-web / React / Vue stack notes
│   │           └── design-systems/         # 84 vendored real-world DESIGN.md references (MIT)
│   │               ├── INDEX.md            # Categorized catalog with vibe one-liners
│   │               ├── NOTICE.md           # Attribution + refresh instructions
│   │               ├── stripe/DESIGN.md    # Real CSS tokens from production sites
│   │               ├── linear.app/DESIGN.md
│   │               ├── vercel/DESIGN.md
│   │               └── ...                 # 71 more
│   ├── squad/
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       └── squad/
│   │           ├── SKILL.md                # routing, persona switching, sub-skills
│   │           ├── routing-rules.md        # default routing rules reference
│   │           ├── history-format.md       # history.md format spec
│   │           └── default-team/           # default agent charters
│   │               ├── lead.md
│   │               ├── backend.md
│   │               ├── frontend.md
│   │               ├── tester.md
│   │               └── scribe.md
│   ├── compress-memory/                    # Memory file compression (11th plugin)
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       └── compress-memory/
│   │           ├── SKILL.md                # Main skill — 5-step flow with hard denylist
│   │           ├── compression-rules.md    # Drop / Replace / Preserve / Compress rules
│   │           ├── safety-rules.md         # Denylist, backup invariant, validation
│   │           └── NOTICE.md               # Attribution to caveman (MIT)
│   ├── logo-design/                        # Brand marks as SVG (12th plugin)
│   │   ├── .claude-plugin/
│   │   │   └── plugin.json
│   │   └── skills/
│   │       └── logo-design/
│   │           ├── SKILL.md                # logo-concept and logo-review sub-skills + refusal gate
│   │           ├── references/             # construction / mark-types / reproduction / anti-slop
│   │           ├── templates/              # LOGO.md skeleton + contact-sheet render harness
│   │           └── scripts/                # export-raster.mjs — SVG-to-PNG/ICO icon exporter
│   └── context-budget/                     # Model rule and fresh-session handoff (13th plugin)
│       ├── .claude-plugin/
│       │   └── plugin.json
│       ├── hooks/
│       │   └── hooks.json                  # UserPromptSubmit size check, PreToolUse dispatch check
│       └── skills/
│           └── context-budget/
│               ├── SKILL.md                # Model Choice, Fresh-Session Handoff, Configuration
│               └── scripts/                # size-check.mjs, dispatch-check.mjs and shared helpers
└── docs/
    ├── planning/                           # Project lifecycle state (ROADMAP, MILESTONE, STATE, CONVENTIONS)
    └── plans/                              # Design documents and phase plans

Supported Frameworks

Test Runners

Playwright, Cypress, Jest, Vitest, Mocha, Karma, Nightwatch, WebdriverIO

Route Detection

React Router, Next.js (App Router & Pages Router), Angular, Vue Router, SvelteKit

Requirements

• Claude Code
• Node.js 18+
• For regression-test: Microsoft Playwright MCP server (@playwright/mcp) and a running web application to test
• For pre-push-review: A git repository with a feature branch. Playwright MCP server is optional (enables browser-based regression testing as part of the review).
• For refactor-analysis: A git repository with code to analyze. No additional tools required.
• For decision-tracker: LongtermMemory-MCP for cross-session persistence (installed automatically via marketplace dependencies). Works without it in degraded mode.
• For roslyn-codelens-integration: roslyn-codelens-mcp MCP server (installed automatically via marketplace dependencies). Skill is inert without it.
• For project-orchestration: No additional tools required. Uses only built-in tools (Read, Write, Glob, Bash for git commands). State files stored in docs/planning/.
• For ui-workflow: ui-phase requires no additional tools. ui-review requires the regression-test skill and its Playwright MCP prerequisite.
• For memorylens-integration: memorylens-mcp MCP server (installed automatically via marketplace dependencies). Skill is inert without it — safe to ignore on non-.NET projects.
• For ui-design-system: No additional tools required.
• For logo-design: No hard requirements — the drawing and the arithmetic need only built-in tools. Playwright MCP is optional but strongly recommended: without it every render-dependent check is recorded UNRUN rather than passed, and a review caps at PARTIAL — evidence-limited. A local SVG rasteriser (resvg, rsvg-convert, Inkscape, or ImageMagick) is optional too: without one the raster icon set is recorded UNRUN rather than failed, and the SVG set still ships. docs/design/MASTER.md from ui-design-system supplies palette and typography when present; the skill ships in currentColor when it is absent.
• For squad: No hard requirements — works standalone. LongtermMemory-MCP enables tier-1 semantic search for agent history (installed automatically via marketplace dependencies). Works without it, falling back to grep-based lookup.

Contributing

Two checks run in CI and are worth running locally before pushing:

npm run lint:md          # markdownlint — globs live in .markdownlint-cli2.jsonc
npm run check:registries # every plugin registered everywhere, counts match disk

Adding a plugin

A plugin is not one directory — it has to be registered in nine places, and missing one fails quietly. npm run check:registries enforces every item below, so add the plugin and run it rather than working from this list by hand:

Design system catalog

The catalog under design-systems/ is refreshed weekly from upstream by refresh-design-systems.yml. Curated mode resolves a system through INDEX.md, so a directory that upstream adds is unreachable until it is indexed — when the refresh PR adds one, add its row and update the count. check:registries fails if the index and the directory listing disagree.

License

MIT