Lab-8 fork of Superpowers — first-principles design, mandatory clean-slate evaluation, built-in code review & verification, core skills library.

A complete software development workflow for your coding agents, built on top of composable "skills" and initial instructions that make sure your agent uses them.

• Mandatory clean-slate evaluation — every brainstorming session presents three approaches: (a) extend existing code, (b) refactor then build, and (c) clean-slate build. Without this, incremental changes silently accumulate into band-aids and workarounds. The clean-slate option forces you to think about what proper code looks like before deciding whether to extend what's there.
• Built-in code review & verification — integrated code review agents and verification-before-completion checks ensure work meets requirements before you claim it's done.
• Required documentation sections — specs must include architecture diagrams, file trees, connection maps, and design rationale. No more vague specs.
• First-principles design step — before proposing approaches, the agent describes what the ideal implementation would look like if built from scratch today, using the codebase's own conventions.

It starts from the moment you fire up your coding agent. As soon as it sees that you're building something, it steps back and asks you what you're really trying to do.

Once it's teased a spec out of the conversation, it shows it to you in chunks short enough to actually read and digest.

After you've signed off on the design, your agent puts together an implementation plan that's clear enough for an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing to follow. It emphasizes true red/green TDD, YAGNI (You Aren't Gonna Need It), and DRY.

Next up, once you say "go", it launches a subagent-driven-development process, having agents work through each engineering task, inspecting and reviewing their work, and continuing forward.

Because the skills trigger automatically, you don't need to do anything special. Your coding agent just has powers.

claude plugin add nambo35/lab8-powers

Start a new session and ask for something that should trigger a skill (e.g., "help me plan this feature" or "let's debug this issue"). The agent should automatically invoke the relevant skill.

1. brainstorming — Refines ideas through questions, runs first-principles design, presents 3 approaches (extend / refactor / clean-slate), saves design document with required diagrams and connection maps.

2. using-git-worktrees — Creates isolated workspace on a new branch, runs project setup, verifies clean test baseline.

3. writing-plans — Breaks work into bite-sized tasks with exact file paths, complete code, and verification steps. Includes dependency/connection maps and holistic clean-slate review.

4. subagent-driven-development or executing-plans — Dispatches fresh subagent per task with two-stage review (spec compliance, then code quality), or executes in batches with human checkpoints.

5. test-driven-development — Enforces RED-GREEN-REFACTOR: write failing test, watch it fail, write minimal code, watch it pass, commit.

6. requesting-code-review — Reviews against plan, reports issues by severity. Critical issues block progress.

7. verification-before-completion — Runs verification commands and confirms output before making any success claims.

8. finishing-a-development-branch — Verifies tests, presents options (merge/PR/keep/discard), cleans up worktree.

Skills trigger automatically. Mandatory workflows, not suggestions.

Design & Planning

• brainstorming — First-principles design with mandatory clean-slate evaluation
• writing-plans — Implementation plans with dependency maps and clean-slate review
• executing-plans — Batch execution with human checkpoints
• dispatching-parallel-agents — Concurrent subagent workflows
• subagent-driven-development — Fast iteration with two-stage review

Testing & Verification

• test-driven-development — RED-GREEN-REFACTOR cycle
• systematic-debugging — 4-phase root cause process
• verification-before-completion — Evidence before assertions

Code Review

• requesting-code-review — Pre-review checklist with severity levels
• receiving-code-review — Technical rigor over performative agreement

Git & Workflow

• using-git-worktrees — Isolated development branches
• finishing-a-development-branch — Merge/PR decision workflow

Meta

• writing-skills — Create new skills following best practices
• using-lab8-powers — Introduction to the skills system

• First-principles design — Understand the ideal before proposing approaches
• Mandatory clean-slate option — Incremental changes silently become band-aids. Always evaluate what proper code looks like before deciding to extend
• Test-Driven Development — Write tests first, always
• Evidence over claims — Verify before declaring success
• Complexity reduction — Simplicity as primary goal

Based on Superpowers by Jesse Vincent.

MIT License - see LICENSE file for details