superpowers-extensions
Quality-gate, refactor, project-orchestration, UI workflow, and design-system skills extending the obra/superpowers suite.
Open source Open in the app JSON README (API)
About
Quality-gate, refactor, project-orchestration, UI workflow, and design-system skills extending the obra/superpowers suite.
Details
- Kind
- Plugins
- Topic
- No topic detected
- Publisher
- marcelroozekrans
- Origin
- gemini
- Category
- ferramentas
- Version
- 1.22.1
- Stars
- 2
- Open pull requests
- 1
- Last push
- 2026-09-03T02:49:25Z
- Repository state
- ativo
- Language
- HTML
- Added
- 2026-08-30 14:13:39
- Updated
- 2026-08-30 14:13:39
- Origin id
marcelroozekrans/superpowers-extensions
README
# Superpowers Extensions for Claude Code
[](https://github.com/sponsors/MarcelRoozekrans)
Extension skills for the [superpowers](https://github.com/obra/superpowers) suite, providing quality gates, development workflow skills, and project lifecycle management for web application development. It includes twelve skills:
- **regression-test** -- Comprehensive regression testing using the [Microsoft Playwright MCP server](https://github.com/microsoft/playwright-mcp), 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](https://github.com/MarcelRoozekrans/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](https://github.com/JuliusBrussee/caveman) (MIT) but reimplemented without a Python toolchain.
- **roslyn-codelens-integration** -- Superpowers integration for [Roslyn CodeLens](https://github.com/MarcelRoozekrans/roslyn-codelens-mcp) 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](https://github.com/MarcelRoozekrans/memorylens-mcp) 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 74 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.
- **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/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
| Phase | Description |
|---|---|
| **Phase 1: Setup & Context** | Auto-detect base branch, gather the diff, find plan docs and project rules |
| **Phase 2: Plan Adherence** | Compare changes against the plan document (skipped if no plan found) |
| **Phase 3: Code Quality** | Review diff for security, YAGNI, debug code, dead code, error handling, naming, test coverage |
| **Phase 4: Commit Hygiene** | Check commits for secrets, large files, unintended files, conflict markers, message quality |
| **Phase 5: Regression Testing** | Run existing test suites; optionally invoke browser-based testing |
| **Phase 6: Verdict & Report** | Generate report with PASS/FAIL verdict and remediation plan if needed |
### Verdict Logic
| Condition | Verdict |
|---|---|
| Any **Blocker** finding in any phase | **FAIL** |
| Three or more **Warning** findings across all phases | **FAIL** |
| Fewer than 3 warnings and no blockers | **PASS** |
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/plans/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](https://github.com/MarcelRoozekrans/LongtermMemory-MCP) as its persistence layer.
### What It Does
The skill operates in two 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.
### Decision Categories
| Category | Importance | Decay | Example |
|---|---|---|---|
| Architectural | 9 | 120 days | "We use the repository pattern with unit of work" |
| Convention | 7 | 120 days | "All DTOs go in the Contracts project" |
| Task-specific | 5 | 30 days | "UserService refactor must preserve v2 API compat" |
### 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](https://github.com/MarcelRoozekrans/roslyn-codelens-mcp) 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](https://github.com/MarcelRoozekrans/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
| Sub-skill | Trigger | What It Does |
|---|---|---|
| `map-codebase` | Before brainstorming on an existing project | Analyzes structure, entry points, dependencies, and patterns; saves a codebase map to `docs/plans/` |
| `init-conventions` | Kickoff via `plan-roadmap`; self-heal when `CONVENTIONS.md` is missing; on demand when a convention changes | Detects the project's stack, commit format, branching model, release mechanism, and deploy target from the repo, proposes them for confirmation, then records the confirmed set in `docs/planning/CONVENTIONS.md`. Every commit and tag the skill makes is rendered from that file |
| `plan-roadmap` | "plan the roadmap" / first project setup, no `ROADMAP.md` yet | Brainstorms the project at roadmap scope (3-7 milestones with rough phase outlines), writes initial `ROADMAP.md` + `MILESTONE.md` for milestone 1. Runs `init-conventions` first so stack and release decisions are settled before the brainstorm |
| `progress` | "where are we?" / session start | Reads `docs/planning/` state files and presents milestone/phase status |
| `add-phase` | "add a phase" | Appends a new pending phase to the current milestone (Write tool + VERIFY gate) |
| `insert-phase` | "insert urgent work" | Inserts a phase between two existing phases, renumbers subsequent phases |
| `remove-phase` | "remove phase N.M" | Removes a future (pending) phase after user confirmation |
| `list-phase-assumptions` | Before executing a phase | Surfaces the intended implementation approach for user review before work begins |
| `plan-milestone-gaps` | After a failed milestone audit | Proposes new phases to close each identified gap |
| `pause-work` | "done for today" / stopping | Writes `docs/planning/STATE.md` with current position, open decisions, and recommended next step |
| `resume-work` | "resume" / session start | Reads `STATE.md`, presents a session handoff summary, then chains into `start-next-phase` |
| `start-next-phase` | After `resume-work`, or "continue" / "next" | Routing hub — finds the next non-complete phase and mechanically chains into brainstorming / writing-plans / executing-plans depending on which artifacts exist |
| `complete-phase` | After `executing-plans` finishes a phase, or "mark phase N.M complete" | Promotes a phase from `active` to `complete`. Without it ROADMAP.md keeps showing the phase active and `start-next-phase` routes back to already-finished work |
| `audit-milestone` | "verify milestone is done" | Verifies each definition-of-done criterion: phases, tests, regression test, docs, and the release tag — the last one only on projects whose conventions say milestone completion tags a release, and skipped (not failed) otherwise |
| `complete-milestone` | After audit PASS | Archives the milestone and updates the roadmap, then handles the release per `docs/planning/CONVENTIONS.md`. Creates a tag only when the project's conventions say milestone completion tags a release; where an automation owns releases, it creates none and says so |
| `new-milestone` | After `complete-milestone` | Brainstorms the next milestone end-to-end before writing `MILESTONE.md` (refuses to start if previous milestone is not complete) |
| `init-github-sync` | "set up GitHub sync" / `/sync-to-github`, one-time | Creates labels, native Milestones, and Issues on GitHub from `ROADMAP.md`, writing the resulting numbers back. Refuses if sync is already initialized |
| `sync-github` | Auto-invoked from `pause-work` and `complete-phase`; manual on demand | Projects `ROADMAP.md` state onto GitHub issues/milestones (one-way write). Step 5 embeds `detect-external-signals`, which posts advisory comments when an external dev closes or edits an issue out of band. Skips silently rather than blocking when `gh` is unauthenticated |
### 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](https://github.com/MarcelRoozekrans/superpowers-extensions/issues/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/plans/**` — plan documents read literally by `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`:
```yaml
---
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](https://github.com/JuliusBrussee/caveman) (MIT). See [plugins/compress-memory/skills/compress-memory/NOTICE.md](plugins/compress-memory/skills/compress-memory/NOTICE.md) for the full attribution.
---
## 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/plans/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:
| Sub-verdict | PASS | PARTIAL | FAIL |
|---|---|---|---|
| Contract adherence | No ❌ Missing | Only ⚠️ Partial | Any ❌ Missing |
| Anti-slop | All 9 patterns Pass | n/a | Any pattern Fail |
| 5-dimension critique | Floor ≥ 3, average ≥ 3.5 | Floor = 3 | Floor ≤ 2 |
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/plans/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 74-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`
### Curated catalog
74 real-world design systems vendored from [VoltAgent/awesome-design-md](https://github.com/VoltAgent/awesome-design-md) (MIT) and categorized in [`design-systems/INDEX.md`](plugins/ui-design-system/skills/ui-design-system/design-systems/INDEX.md):
| Category | Systems |
|---|---|
| **AI / LLM** | claude, cohere, mistral.ai, ollama, x.ai, minimax, together.ai, composio, elevenlabs, runwayml, replicate |
| **Developer tools** | vercel, cursor, supabase, mongodb, hashicorp, sentry, posthog, sanity, resend, mintlify, opencode.ai, voltagent, warp, ibm, clickhouse, framer, webflow, expo |
| **SaaS productivity** | linear.app, notion, figma, miro, airtable, cal, intercom, raycast, superhuman, zapier, lovable, shopify, slack |
| **Consumer / lifestyle** | apple, airbnb, spotify, pinterest, uber, nike, starbucks, theverge, wired, meta, playstation, nintendo-2001 |
| **Fintech / commerce** | stripe, coinbase, mastercard, revolut, wise, binance, kraken |
| **Auto / luxury** | tesla, bmw, bmw-m, ferrari, lamborghini, bugatti, renault, spacex |
| **Enterprise** | nvidia, vodafone, clay, hp, dell-1996 |
The catalog auto-refreshes every Monday via [`refresh-design-systems.yml`](.github/workflows/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>`:
| Refused | What it is |
|---|---|
| **Pictorial** | The mark is a recognisable object or living thing drawn as itself — a fox, a mountain, a coffee cup. |
| **Mascot or character** | Anything with a face, a posture, a gesture, or a name. |
| **Illustrative emblem** | A badge, crest, or roundel whose interior is a depicted scene rather than a construction. |
**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:
| Found | Asked for | Route |
|---|---|---|
| nothing | anything | `logo-concept`, **full flow** — all eight steps |
| a mark | **variants of it** — a favicon, a dark or mono version, a lockup, an app icon | `logo-concept`, **variants-only** — no new concept is generated and nothing that ships is redrawn. Requires the existing mark to clear the reproduction checklist first, and that gate is not waivable. |
| a mark | an **audit**, or a **new** mark | `logo-review` |
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
| Agent | Expertise | Decision authority |
|---|---|---|
| **Lead** | Architecture, coordination, trade-offs | Full |
| **Backend Engineer** | APIs, data models, services, infra | Domain |
| **Frontend Engineer** | UI, components, styling, UX | Domain |
| **Tester** | Test strategy, coverage, edge cases | Advisory |
| **Scribe** | Decisions, conventions, institutional memory | None |
### 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
```bash
claude plugin install squad
```
No MCP servers required. Optionally install `longterm-memory` for semantic search in tier 1:
```bash
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:
| Dependency | Repository | Purpose |
|---|---|---|
| **superpowers** | [obra/superpowers](https://github.com/obra/superpowers) | Core superpowers skills framework -- brainstorming, writing-plans, subagent-driven-development, TDD, debugging, and more |
| **LongtermMemory-MCP** | [MarcelRoozekrans/LongtermMemory-MCP](https://github.com/MarcelRoozekrans/LongtermMemory-MCP) | Semantic long-term memory for AI agents -- persistence layer for decision-tracker |
| **roslyn-codelens-mcp** | [MarcelRoozekrans/roslyn-codelens-mcp](https://github.com/MarcelRoozekrans/roslyn-codelens-mcp) | Roslyn-based .NET code graph intelligence -- enhances brainstorming and refactor-analysis with semantic code understanding |
| **memorylens-mcp** | [MarcelRoozekrans/memorylens-mcp](https://github.com/MarcelRoozekrans/memorylens-mcp) | .NET memory profiling MCP server -- required by memorylens-integration for memory snapshot analysis and leak detection. Skill is inert without it. |
### MCP description compression (optional, not bundled)
If MCP tool descriptions bloat your context window — particularly Playwright's, which is large — [`caveman-shrink`](https://www.npmjs.com/package/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](https://github.com/MarcelRoozekrans/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.
| Harness | Manifest | Install instructions |
|---|---|---|
| **Claude Code** | [`.claude-plugin/marketplace.json`](.claude-plugin/marketplace.json) + per-plugin `plugin.json` | [Installation](#installation) section below |
| **Cursor Agent** | [`.cursor-plugin/plugin.json`](.cursor-plugin/plugin.json) + [`hooks/hooks-cursor.json`](hooks/hooks-cursor.json) | Add this repo as a Cursor plugin source; the manifest registers `./plugins/` as the skills root and `hooks/session-start` runs at session start |
| **OpenAI Codex CLI / App** | [`.codex-plugin/plugin.json`](.codex-plugin/plugin.json) + [`.codex/INSTALL.md`](.codex/INSTALL.md) | Clone-and-symlink each plugin into `~/.agents/skills/`; instructions and a copy-paste loop in [`.codex/INSTALL.md`](.codex/INSTALL.md) |
| **Gemini CLI** | [`gemini-extension.json`](gemini-extension.json) + [`GEMINI.md`](GEMINI.md) | `GEMINI.md` lists each SKILL.md via `@./plugins/.../SKILL.md` import syntax |
| **GitHub Copilot CLI** | Reuses [`.claude-plugin/marketplace.json`](.claude-plugin/marketplace.json) + [`.copilot-cli/INSTALL.md`](.copilot-cli/INSTALL.md) | `copilot plugin marketplace add MarcelRoozekrans/superpowers-extensions`, then install individual plugins |
| **OpenCode.ai** | [`.opencode/plugins/superpowers-extensions.js`](.opencode/plugins/superpowers-extensions.js) | JS plugin registers all twelve plugin skill paths via OpenCode's `config.skills.paths` array — no symlinks needed |
The polymorphic [`hooks/session-start`](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). [`hooks/run-hook.cmd`](hooks/run-hook.cmd) is the
Windows polyglot wrapper that routes to Git Bash on Windows hosts.
### 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](https://github.com/MarcelRoozekrans/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`](https://github.com/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 74 vendored design systems** under
[`plugins/ui-design-system/skills/ui-design-system/design-systems/`](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`](https://github.com/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 twelve 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, and roslyn-codelens-mcp as transitive dependencies:
```bash
claude install gh:MarcelRoozekrans/superpowers-extensions
```
Then install the plugins you need from the marketplace:
```bash
# 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
```
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:
```bash
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):**
```bash
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:**
```bash
# 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 --