@trieungoctam/vibekit 1.0.0

package/skills/core/fix/references/workflow-deep.md

@@ -0,0 +1,122 @@
+# Deep Workflow
+
+Full pipeline with research, brainstorming, and planning for complex issues. Uses native Claude Tasks with dependency chains.
+
+## Task Setup (Before Starting)
+
+Create all phase tasks upfront. Steps 1+2 run in parallel (no mutual dependency).
+
+```
+T1 = TaskCreate(subject="Debug & investigate",       activeForm="Debugging issue",       metadata={phase: "diagnose"})
+T2 = TaskCreate(subject="Research solutions",         activeForm="Researching solutions",  metadata={phase: "research"})
+T3 = TaskCreate(subject="Brainstorm approaches",      activeForm="Brainstorming",          metadata={phase: "design"},    addBlockedBy=[T1, T2])
+T4 = TaskCreate(subject="Create implementation plan", activeForm="Planning implementation", metadata={phase: "design"},    addBlockedBy=[T3])
+T5 = TaskCreate(subject="Implement fix",              activeForm="Implementing fix",        metadata={phase: "implement"}, addBlockedBy=[T4])
+T6 = TaskCreate(subject="Run tests",                  activeForm="Running tests",           metadata={phase: "verify"},    addBlockedBy=[T5])
+T7 = TaskCreate(subject="Code review",                activeForm="Reviewing code",          metadata={phase: "verify"},    addBlockedBy=[T6])
+T8 = TaskCreate(subject="Finalize & docs",            activeForm="Finalizing",              metadata={phase: "finalize"},  addBlockedBy=[T7])
+```
+
+## Steps
+
+### Step 1: Debug & Parallel Investigation
+`TaskUpdate(T1, status="in_progress")`
+Activate `ck:debug` skill. Launch 2-3 `Explore` subagents in parallel:
+```
+Task("Explore", "Find error origin", "Trace error")
+Task("Explore", "Find affected components", "Map deps")
+Task("Explore", "Find similar patterns", "Find patterns")
+```
+See `references/parallel-exploration.md` for patterns.
+
+`TaskUpdate(T1, status="completed")`
+**Output:** `✓ Step 1: Root cause - [summary], system impact: [scope]`
+
+### Step 2: Research (parallel with Step 1)
+`TaskUpdate(T2, status="in_progress")`
+Use `researcher` subagent for external knowledge.
+
+- Search latest docs, best practices
+- Find similar issues/solutions
+- Gather security advisories if relevant
+
+`TaskUpdate(T2, status="completed")`
+**Output:** `✓ Step 2: Research complete - [key findings]`
+
+### Step 3: Brainstorm
+`TaskUpdate(T3, status="in_progress")` — auto-unblocks when T1 + T2 complete.
+Activate `ck:brainstorm` skill.
+
+- Evaluate multiple approaches
+- Consider trade-offs
+- Get user input on preferred direction
+
+`TaskUpdate(T3, status="completed")`
+**Output:** `✓ Step 3: Approach selected - [chosen approach]`
+
+### Step 4: Plan
+`TaskUpdate(T4, status="in_progress")`
+Use `planner` subagent to create implementation plan.
+
+- Break down into phases
+- Identify dependencies
+- Define success criteria
+
+`TaskUpdate(T4, status="completed")`
+**Output:** `✓ Step 4: Plan created - [N] phases`
+
+### Step 5: Implement
+`TaskUpdate(T5, status="in_progress")`
+Implement per plan. Use `ck:context-engineering`, `ck:sequential-thinking`, `ck:problem-solving`.
+
+**Parallel Verification:** Launch `Bash` agents: typecheck + lint + build
+See `references/parallel-exploration.md`
+
+`TaskUpdate(T5, status="completed")`
+**Output:** `✓ Step 5: Implemented - [N] files, [M] phases, verified`
+
+### Step 6: Test
+`TaskUpdate(T6, status="in_progress")`
+Use `tester` subagent.
+
+- Comprehensive testing
+- Edge cases, security, performance
+- If fail → debug, fix, repeat
+
+`TaskUpdate(T6, status="completed")`
+**Output:** `✓ Step 6: Tests [X/X passed]`
+
+### Step 7: Review
+`TaskUpdate(T7, status="in_progress")`
+Use `code-reviewer` subagent.
+
+See `references/review-cycle.md` for mode-specific handling.
+
+`TaskUpdate(T7, status="completed")`
+**Output:** `✓ Step 7: Review [score]/10 - [status]`
+
+### Step 8: Finalize
+`TaskUpdate(T8, status="in_progress")`
+- Use `project-manager` subagent to update roadmap
+- Use `docs-manager` subagent for documentation
+- Use `git-manager` subagent for commit
+
+`TaskUpdate(T8, status="completed")`
+**Output:** `✓ Step 8: Complete - [actions taken]`
+
+## Skills/Subagents Activated
+
+| Step | Skills/Subagents |
+|------|------------------|
+| 1 | `ck:debug`, parallel `Explore` subagents for investigation |
+| 2 | `researcher` (runs parallel with step 1) |
+| 3 | `ck:brainstorm` |
+| 4 | `planner` |
+| 5 | `ck:problem-solving`, `ck:sequential-thinking`, `ck:context-engineering`, parallel `Bash` |
+| 6 | `tester` |
+| 7 | `code-reviewer` |
+| 8 | `project-manager`, `docs-manager`, `Bash` |
+
+**Rules:** Don't skip steps. Validate before proceeding. One phase at a time.
+**Frontend:** Use `chrome`, `ck:chrome-devtools` or any relevant skills/tools to verify.
+**Visual Assets:** Use `ck:ai-multimodal` for visual assets generation, analysis and verification.

package/skills/core/fix/references/workflow-logs.md

@@ -0,0 +1,72 @@
+# Log Analysis Fix Workflow
+
+For fixing issues from application logs. Uses native Claude Tasks for phase tracking.
+
+## Prerequisites
+- Log file at `./logs.txt` or similar
+
+## Setup (if logs missing)
+
+Add permanent log piping to project config:
+- **Bash/Unix**: `command 2>&1 | tee logs.txt`
+- **PowerShell**: `command *>&1 | Tee-Object logs.txt`
+
+## Task Setup (Before Starting)
+
+```
+T1 = TaskCreate(subject="Read & analyze logs",  activeForm="Analyzing logs")
+T2 = TaskCreate(subject="Scout codebase",        activeForm="Scouting codebase",    addBlockedBy=[T1])
+T3 = TaskCreate(subject="Plan fix",              activeForm="Planning fix",          addBlockedBy=[T1, T2])
+T4 = TaskCreate(subject="Implement fix",         activeForm="Implementing fix",      addBlockedBy=[T3])
+T5 = TaskCreate(subject="Test fix",              activeForm="Testing fix",           addBlockedBy=[T4])
+T6 = TaskCreate(subject="Code review",           activeForm="Reviewing code",        addBlockedBy=[T5])
+```
+
+## Workflow
+
+### Step 1: Read & Analyze Logs
+`TaskUpdate(T1, status="in_progress")`
+
+- Read logs with `Grep` (use `head_limit: 30` initially, increase if needed)
+- Use `debugger` agent for root cause analysis
+- Focus on last N lines first (most recent errors)
+- Look for stack traces, error codes, timestamps, repeated patterns
+
+`TaskUpdate(T1, status="completed")`
+
+### Step 2: Scout Codebase
+`TaskUpdate(T2, status="in_progress")`
+Use `ck:scout` agent or parallel `Explore` subagents to find issue locations.
+
+See `references/parallel-exploration.md` for patterns.
+
+`TaskUpdate(T2, status="completed")`
+
+### Step 3: Plan Fix
+`TaskUpdate(T3, status="in_progress")` — auto-unblocks when T1 + T2 complete.
+Use `planner` agent.
+
+`TaskUpdate(T3, status="completed")`
+
+### Step 4: Implement
+`TaskUpdate(T4, status="in_progress")`
+Implement the fix.
+
+`TaskUpdate(T4, status="completed")`
+
+### Step 5: Test
+`TaskUpdate(T5, status="in_progress")`
+Use `tester` agent. If issues remain → keep T5 `in_progress`, loop back to Step 2.
+
+`TaskUpdate(T5, status="completed")`
+
+### Step 6: Review
+`TaskUpdate(T6, status="in_progress")`
+Use `code-reviewer` agent.
+
+`TaskUpdate(T6, status="completed")`
+
+## Tips
+- Focus on last N lines first (most recent errors)
+- Look for stack traces, error codes, timestamps
+- Check for patterns/repeated errors

package/skills/core/fix/references/workflow-quick.md

@@ -0,0 +1,59 @@
+# Quick Workflow
+
+Fast debug-fix-review cycle for simple issues.
+
+## Steps
+
+### Step 1: Debug
+Activate `ck:debug` skill. Find root cause quickly. Verify the root cause with multiple `Explore` subagents in parallel.
+- Read error message/logs
+- Locate affected file(s)
+- Identify exact fix needed
+
+**Output:** `✓ Step 1: Root cause - [brief description]`
+
+### Step 2: Fix & Verify
+Implement the fix directly.
+- Make minimal changes
+- Follow existing patterns
+
+**Parallel Verification:**
+Launch `Bash` agents in parallel:
+```
+Task("Bash", "Run typecheck", "Verify types")
+Task("Bash", "Run lint", "Verify lint")
+```
+
+See `references/parallel-exploration.md` for patterns.
+
+**Output:** `✓ Step 2: Fixed - [N] files, verified (types/lint passed)`
+
+### Step 3: Verify
+Use `code-reviewer` subagent for quick review.
+
+Prompt: "Quick review of fix for [issue]. Check: correctness, security, no regressions. Score X/10."
+
+**Review handling:** See `references/review-cycle.md`
+
+**Output:** `✓ Step 3: Review [score]/10 - [status]`
+
+### Step 4: Complete
+Report summary to user.
+
+**If autonomous mode:** Ask to commit via `git-manager` subagent if score >= 9.0
+**If HITL mode:** Ask user next action
+
+**Output:** `✓ Step 4: Complete - [action]`
+
+## Skills/Subagents Activated
+
+- `ck:debug` - Always (Step 1)
+- Parallel `git-manager` - Verification (Step 2)
+- `code-reviewer` subagent - Always (Step 3)
+- `ck:context-engineering` - If dealing with AI/LLM code
+
+## Notes
+
+- Skip if review fails → escalate to Standard workflow
+- Total steps: 4 (vs 5-6 in Standard/Deep)
+- No planning phase needed

package/skills/core/fix/references/workflow-standard.md

@@ -0,0 +1,111 @@
+# Standard Workflow
+
+Full pipeline for moderate complexity issues. Uses native Claude Tasks for phase tracking.
+
+## Task Setup (Before Starting)
+
+Create all phase tasks upfront with dependencies. See `references/task-orchestration.md`.
+
+```
+T1 = TaskCreate(subject="Debug & investigate",  activeForm="Debugging issue")
+T2 = TaskCreate(subject="Scout related code",   activeForm="Scouting codebase")
+T3 = TaskCreate(subject="Implement fix",        activeForm="Implementing fix",    addBlockedBy=[T1, T2])
+T4 = TaskCreate(subject="Run tests",            activeForm="Running tests",       addBlockedBy=[T3])
+T5 = TaskCreate(subject="Code review",          activeForm="Reviewing code",      addBlockedBy=[T4])
+T6 = TaskCreate(subject="Finalize",             activeForm="Finalizing",          addBlockedBy=[T5])
+```
+
+## Steps
+
+### Step 1: Debug & Investigate
+`TaskUpdate(T1, status="in_progress")`
+Activate `ck:debug` skill. Use `debugger` subagent if needed.
+
+- Read error messages, logs, stack traces
+- Reproduce the issue
+- Trace backward to root cause
+- Identify all affected files
+
+`TaskUpdate(T1, status="completed")`
+**Output:** `✓ Step 1: Root cause - [summary], [N] files affected`
+
+### Step 2: Parallel Scout
+`TaskUpdate(T2, status="in_progress")`
+Launch multiple `Explore` subagents in parallel to scout and verify the root cause.
+
+**Pattern:** In SINGLE message, launch 2-3 Explore agents:
+```
+Task("Explore", "Find [area1] files related to issue", "Scout area1")
+Task("Explore", "Find [area2] patterns/usage", "Scout area2")
+Task("Explore", "Find [area3] tests/dependencies", "Scout area3")
+```
+
+- Only if unclear which files need changes
+- Find patterns, similar implementations, dependencies
+
+See `references/parallel-exploration.md` for patterns.
+
+`TaskUpdate(T2, status="completed")`
+**Output:** `✓ Step 2: Scouted [N] areas - Found [M] related files`
+
+### Step 3: Implement Fix
+`TaskUpdate(T3, status="in_progress")` — auto-unblocked when T1 + T2 complete.
+Fix the issue following debugging findings.
+
+- Apply `ck:problem-solving` skill if stuck
+- Use `ck:sequential-thinking` for complex logic
+
+**After implementation - Parallel Verification:**
+Launch `Bash` agents in parallel to verify:
+```
+Task("Bash", "Run typecheck", "Verify types")
+Task("Bash", "Run lint", "Verify lint")
+Task("Bash", "Run build", "Verify build")
+```
+
+`TaskUpdate(T3, status="completed")`
+**Output:** `✓ Step 3: Implemented - [N] files, verified (types/lint/build passed)`
+
+### Step 4: Test
+`TaskUpdate(T4, status="in_progress")`
+Use `tester` subagent to run tests.
+
+- Write new tests if needed
+- Run existing test suite
+- If fail → use `debugger`, fix, repeat
+
+`TaskUpdate(T4, status="completed")`
+**Output:** `✓ Step 4: Tests [X/X passed]`
+
+### Step 5: Review
+`TaskUpdate(T5, status="in_progress")`
+Use `code-reviewer` subagent.
+
+See `references/review-cycle.md` for mode-specific handling.
+
+`TaskUpdate(T5, status="completed")`
+**Output:** `✓ Step 5: Review [score]/10 - [status]`
+
+### Step 6: Finalize
+`TaskUpdate(T6, status="in_progress")`
+- Report summary to user
+- Ask to commit via `git-manager` subagent
+- Update docs if needed via `docs-manager`
+
+`TaskUpdate(T6, status="completed")`
+**Output:** `✓ Step 6: Complete - [action]`
+
+## Skills/Subagents Activated
+
+| Step | Skills/Subagents |
+|------|------------------|
+| 1 | `ck:debug`, `debugger` subagent |
+| 2 | Multiple `Explore` subagents in parallel (optional) |
+| 3 | `ck:problem-solving`, `ck:sequential-thinking`, parallel `Bash` for verification |
+| 4 | `tester` subagent |
+| 5 | `code-reviewer` subagent |
+| 6 | `git-manager`, `docs-manager` subagents |
+
+**Rules:** Don't skip steps. Validate before proceeding. One phase at a time.
+**Frontend:** Use `chrome`, `ck:chrome-devtools` or any relevant skills/tools to verify.
+**Visual Assets:** Use `ck:ai-multimodal` for visual assets generation, analysis and verification.

package/skills/core/fix/references/workflow-test.md

@@ -0,0 +1,75 @@
+# Test Failure Fix Workflow
+
+For fixing failing tests and test suite issues. Uses native Claude Tasks for phase tracking.
+
+## Task Setup (Before Starting)
+
+```
+T1 = TaskCreate(subject="Compile & collect failures", activeForm="Compiling and collecting failures")
+T2 = TaskCreate(subject="Debug root causes",          activeForm="Debugging test failures",       addBlockedBy=[T1])
+T3 = TaskCreate(subject="Plan fixes",                 activeForm="Planning fixes",                addBlockedBy=[T2])
+T4 = TaskCreate(subject="Implement fixes",             activeForm="Implementing fixes",            addBlockedBy=[T3])
+T5 = TaskCreate(subject="Re-test",                     activeForm="Re-running tests",              addBlockedBy=[T4])
+T6 = TaskCreate(subject="Code review",                 activeForm="Reviewing code",                addBlockedBy=[T5])
+```
+
+## Workflow
+
+### Step 1: Compile & Collect Failures
+`TaskUpdate(T1, status="in_progress")`
+Use `tester` agent. Fix all syntax errors before running tests.
+
+- Run full test suite, collect all failures
+- Group failures by module/area
+
+`TaskUpdate(T1, status="completed")`
+
+### Step 2: Debug
+`TaskUpdate(T2, status="in_progress")`
+Use `debugger` agent for root cause analysis.
+
+- Analyze each failure group
+- Identify shared root causes across failures
+
+`TaskUpdate(T2, status="completed")`
+
+### Step 3: Plan
+`TaskUpdate(T3, status="in_progress")`
+Use `planner` agent for fix strategy.
+
+- Prioritize fixes (shared root causes first)
+- Identify dependencies between fixes
+
+`TaskUpdate(T3, status="completed")`
+
+### Step 4: Implement
+`TaskUpdate(T4, status="in_progress")`
+Implement fixes step by step per plan.
+
+`TaskUpdate(T4, status="completed")`
+
+### Step 5: Re-test
+`TaskUpdate(T5, status="in_progress")`
+Use `tester` agent. If tests still fail → keep T5 `in_progress`, loop back to Step 2.
+
+`TaskUpdate(T5, status="completed")`
+
+### Step 6: Review
+`TaskUpdate(T6, status="in_progress")`
+Use `code-reviewer` agent.
+
+`TaskUpdate(T6, status="completed")`
+
+## Common Commands
+```bash
+npm test
+bun test
+pytest
+go test ./...
+```
+
+## Tips
+- Run single failing test first for faster iteration
+- Check test assertions vs actual behavior
+- Verify test fixtures/mocks are correct
+- Don't modify tests to pass unless test is wrong

package/skills/core/fix/references/workflow-types.md

@@ -0,0 +1,33 @@
+# Type Error Fix Workflow
+
+Quick workflow for TypeScript/type errors.
+
+## Commands
+```bash
+bun run typecheck
+tsc --noEmit
+npx tsc --noEmit
+```
+
+## Rules
+- Fix ALL type errors, don't stop at first
+- **NEVER use `any` just to pass** - find proper types
+- Repeat until zero errors
+
+## Common Fixes
+- Missing type imports
+- Incorrect property access
+- Null/undefined handling
+- Generic type parameters
+- Union type narrowing
+
+## Workflow
+1. Run typecheck command
+2. Fix errors one by one
+3. Re-run typecheck
+4. Repeat until clean
+
+## Tips
+- Group related errors (same root cause)
+- Check `@types/*` packages for library types
+- Use `unknown` + type guards instead of `any`

package/skills/core/fix/references/workflow-ui.md

@@ -0,0 +1,75 @@
+# UI Fix Workflow
+
+For fixing visual/UI issues. Requires design skills. Uses native Claude Tasks for phase tracking.
+
+## Required Skills (activate in order)
+1. `ck:ui-ux-pro-max` - Design database (ALWAYS FIRST)
+2. `ck:ui-ux-pro-max` - Design principles
+3. `ck:frontend-design` - Implementation patterns
+
+## Pre-fix Research
+```bash
+python3 .claude/skills/ui-ux-pro-max/scripts/search.py "<product-type>" --domain product
+python3 .claude/skills/ui-ux-pro-max/scripts/search.py "<style>" --domain style
+python3 .claude/skills/ui-ux-pro-max/scripts/search.py "accessibility" --domain ux
+```
+
+## Task Setup (Before Starting)
+
+```
+T1 = TaskCreate(subject="Analyze visual issue",    activeForm="Analyzing visual issue")
+T2 = TaskCreate(subject="Implement UI fix",         activeForm="Implementing UI fix",       addBlockedBy=[T1])
+T3 = TaskCreate(subject="Verify visually",          activeForm="Verifying visually",         addBlockedBy=[T2])
+T4 = TaskCreate(subject="DevTools check",           activeForm="Checking with DevTools",     addBlockedBy=[T3])
+T5 = TaskCreate(subject="Test compilation",         activeForm="Testing compilation",        addBlockedBy=[T4])
+T6 = TaskCreate(subject="Update design docs",       activeForm="Updating design docs",       addBlockedBy=[T5])
+```
+
+## Workflow
+
+### Step 1: Analyze
+`TaskUpdate(T1, status="in_progress")`
+Analyze screenshots/videos with `ck:ai-multimodal` skill.
+
+- Read `./docs/design-guidelines.md` first
+- Identify exact visual discrepancy
+
+`TaskUpdate(T1, status="completed")`
+
+### Step 2: Implement
+`TaskUpdate(T2, status="in_progress")`
+Use `ui-ux-designer` agent.
+
+`TaskUpdate(T2, status="completed")`
+
+### Step 3: Verify Visually
+`TaskUpdate(T3, status="in_progress")`
+Screenshot + `ck:ai-multimodal` analysis.
+
+- Capture parent container, not whole page
+- Compare to design guidelines
+- If incorrect → keep T3 `in_progress`, loop back to Step 2
+
+`TaskUpdate(T3, status="completed")`
+
+### Step 4: DevTools Check
+`TaskUpdate(T4, status="in_progress")`
+Use `ck:chrome-devtools` skill.
+
+`TaskUpdate(T4, status="completed")`
+
+### Step 5: Test
+`TaskUpdate(T5, status="in_progress")`
+Use `tester` agent for compilation check.
+
+`TaskUpdate(T5, status="completed")`
+
+### Step 6: Document
+`TaskUpdate(T6, status="in_progress")`
+Update `./docs/design-guidelines.md` if needed.
+
+`TaskUpdate(T6, status="completed")`
+
+## Tips
+- Use `ck:ai-multimodal` for generating visual assets
+- Use `ImageMagick` for image editing

package/skills/core/plan/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: writing-plans
+description: Use when you have a spec or requirements for a multi-step task, before touching code
+---
+
+# Writing Plans
+
+## Overview
+
+Write comprehensive implementation plans assuming the engineer has zero context for our codebase and questionable taste. Document everything they need to know: which files to touch for each task, code, testing, docs they might need to check, how to test it. Give them the whole plan as bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.
+
+Assume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.
+
+**Announce at start:** "I'm using the writing-plans skill to create the implementation plan."
+
+**Context:** This should be run in a dedicated worktree (created by brainstorming skill).
+
+**Save plans to:** `docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md`
+- (User preferences for plan location override this default)
+
+## Scope Check
+
+If the spec covers multiple independent subsystems, it should have been broken into sub-project specs during brainstorming. If it wasn't, suggest breaking this into separate plans — one per subsystem. Each plan should produce working, testable software on its own.
+
+## File Structure
+
+Before defining tasks, map out which files will be created or modified and what each one is responsible for. This is where decomposition decisions get locked in.
+
+- Design units with clear boundaries and well-defined interfaces. Each file should have one clear responsibility.
+- You reason best about code you can hold in context at once, and your edits are more reliable when files are focused. Prefer smaller, focused files over large ones that do too much.
+- Files that change together should live together. Split by responsibility, not by technical layer.
+- In existing codebases, follow established patterns. If the codebase uses large files, don't unilaterally restructure - but if a file you're modifying has grown unwieldy, including a split in the plan is reasonable.
+
+This structure informs the task decomposition. Each task should produce self-contained changes that make sense independently.
+
+## Bite-Sized Task Granularity
+
+**Each step is one action (2-5 minutes):**
+- "Write the failing test" - step
+- "Run it to make sure it fails" - step
+- "Implement the minimal code to make the test pass" - step
+- "Run the tests and make sure they pass" - step
+- "Commit" - step
+
+## Plan Document Header
+
+**Every plan MUST start with this header:**
+
+```markdown
+# [Feature Name] Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** [One sentence describing what this builds]
+
+**Architecture:** [2-3 sentences about approach]
+
+**Tech Stack:** [Key technologies/libraries]
+
+---
+```
+
+## Task Structure
+
+````markdown
+### Task N: [Component Name]
+
+**Files:**
+- Create: `exact/path/to/file.py`
+- Modify: `exact/path/to/existing.py:123-145`
+- Test: `tests/exact/path/to/test.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+def test_specific_behavior():
+    result = function(input)
+    assert result == expected
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `pytest tests/path/test.py::test_name -v`
+Expected: FAIL with "function not defined"
+
+- [ ] **Step 3: Write minimal implementation**
+
+```python
+def function(input):
+    return expected
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `pytest tests/path/test.py::test_name -v`
+Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/path/test.py src/path/file.py
+git commit -m "feat: add specific feature"
+```
+````
+
+## Remember
+- Exact file paths always
+- Complete code in plan (not "add validation")
+- Exact commands with expected output
+- Reference relevant skills with @ syntax
+- DRY, YAGNI, TDD, frequent commits
+
+## Plan Review Loop
+
+After writing the complete plan:
+
+1. Dispatch a single plan-document-reviewer subagent (see plan-document-reviewer-prompt.md) with precisely crafted review context — never your session history. This keeps the reviewer focused on the plan, not your thought process.
+   - Provide: path to the plan document, path to spec document
+2. If ❌ Issues Found: fix the issues, re-dispatch reviewer for the whole plan
+3. If ✅ Approved: proceed to execution handoff
+
+**Review loop guidance:**
+- Same agent that wrote the plan fixes it (preserves context)
+- If loop exceeds 3 iterations, surface to human for guidance
+- Reviewers are advisory — explain disagreements if you believe feedback is incorrect
+
+## Execution Handoff
+
+After saving the plan, offer execution choice:
+
+**"Plan complete and saved to `docs/superpowers/plans/<filename>.md`. Two execution options:**
+
+**1. Subagent-Driven (recommended)** - I dispatch a fresh subagent per task, review between tasks, fast iteration
+
+**2. Inline Execution** - Execute tasks in this session using executing-plans, batch execution with checkpoints
+
+**Which approach?"**
+
+**If Subagent-Driven chosen:**
+- **REQUIRED SUB-SKILL:** Use superpowers:subagent-driven-development
+- Fresh subagent per task + two-stage review
+
+**If Inline Execution chosen:**
+- **REQUIRED SUB-SKILL:** Use superpowers:executing-plans
+- Batch execution with checkpoints for review