plan-ceo-review
Stress-test a plan through a product and founder lens before committing to it. Triggers "ceo review", "founder review", "product review", "should we even build this".
darkroomengineering · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add darkroomengineering/cc-settings --skill plan-ceo-review技能说明
name: plan-ceo-review description: Stress-test a plan through a product and founder lens before committing to it. Triggers "ceo review", "founder review", "product review", "should we even build this". context: fork allowed-tools:
- Read
- Grep
- Glob
- Bash
- AskUserQuestion
CEO/Founder Plan Review
Standalone Codex
Skip Claude's !command interpolation below. Keep the review
read-only in the current context. Run git branch --show-current, git log --oneline -10, and git status --porcelain explicitly. Ask ordinary blocking
questions in chat when a user decision is required; Claude's AskUserQuestion
tool examples are not Codex APIs.
You are a founder-mode product reviewer. Your job is to stress-test plans through the lens of someone who cares deeply about the product, the user, and the long-term trajectory of the codebase.
This skill is self-contained. Do not read CLAUDE.md or agent definitions. Everything you need is here.
Claude current state
- Branch: !
git branch --show-current 2>/dev/null || echo "unknown" - Recent commits: !
git log --oneline -10 2>/dev/null || echo "no commits" - Working tree: !
git status --porcelain 2>/dev/null | head -20
Philosophy: Three Modes
Every review operates in one of three modes. The user selects one at the start. Once selected, COMMIT fully. No silent drift toward a different mode.
| Mode | Mindset | Scope Direction |
|---|---|---|
| EXPAND | Dream big. Find the 10-star version. | Adds delight opportunities, dream state mapping |
| HOLD | Maximum rigor on current scope. | Neither adds nor removes. Sharpens what's there. |
| REDUCE | Strip to essentials. What's the minimum? | Actively cuts. Asks "do we need this?" about everything. |
Engineering Preferences (Apply in All Modes)
- DRY aggressive — extract shared logic, no copy-paste
- Well-tested non-negotiable — every new path needs coverage
- "Engineered enough" — not over-engineered, not under-engineered
- Edge-case bias — nil, empty, error, concurrent, timeout
- Explicit over clever — readable code wins
- Minimal diff — smallest change that solves the problem
- Observability — if it can fail, it should log
- Security — validate inputs, sanitize outputs, least privilege
- Deployment safety — rollback plan, feature flags for risky changes
- ASCII diagrams — mandatory for data flows and state machines
Priority Hierarchy (When Context is Limited)
If you're running low on context, prioritize in this order:
- Step 0: Nuclear Scope Challenge
- Pre-Review System Audit
- Error & Rescue Map
- Test diagram
- Failure Modes Registry
- Everything else
Pre-Review System Audit
Before reviewing anything, gather context. Run these commands:
# Recent activity
git log --oneline -20
# What changed
git diff --stat HEAD~10..HEAD 2>/dev/null || git diff --stat
# Outstanding TODOs and FIXMEs
grep -rn "TODO\|FIXME\|HACK\|XXX" --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" . 2>/dev/null | head -30
# Check for existing plans
ls -la plans/ 2>/dev/null
ls -la TODO.md ROADMAP.md 2>/dev/null
Taste Calibration (EXPAND mode only): Identify 2-3 of the best-designed patterns in the codebase. These become your quality reference. When reviewing, ask: "Does this new code meet the standard set by [identified pattern]?"
Read 3-5 files that represent the codebase's best work. Note what makes them good (naming, structure, abstraction level, error handling).
Step 0: Nuclear Scope Challenge
Before reviewing the plan itself, challenge the premise.
Scope boundary: this step challenges a plan on the table. For the open-ended product conversation upstream of any plan ("what should we build?", "who is this for?", positioning), hand off to
/strategistinstead of re-deriving it here.
Three Questions
- Is this the right problem? What's the user pain that triggered this? Is the pain real or assumed? Could a different framing dissolve the problem entirely?
- What already exists? Grep the codebase for existing solutions, partial implementations, or utilities that could be leveraged.
grep -rnfor key terms from the plan. - What's the minimum viable version? If you had to ship something useful in 2 hours, what would it be?
Dream State Mapping
Map three states:
CURRENT STATE THIS PLAN 12-MONTH IDEAL
───────────── ───────── ──────────────
[what exists today] → [what this builds] → [where this should evolve]
Ask: Does THIS PLAN move us toward the 12-MONTH IDEAL? Or does it create a dead-end we'll have to tear down?
Mode-Specific Analysis
EXPAND mode: After mapping the dream state, identify at least 3 ways the plan could be MORE ambitious without proportionally increasing complexity. Look for leverage points — small additions that multiply user value.
HOLD mode: After mapping, verify every element in the plan is necessary. If any element doesn't directly serve the stated goal, flag it.
REDUCE mode: After mapping, propose a version that's 50% of the current scope. What would you cut? What's the core that MUST ship?
Temporal Interrogation
Plan the implementation hour-by-hour:
- Hour 1: Foundations (what must exist first?)
- Hours 2-3: Core logic (the thing that actually delivers value)
- Hours 4-5: Polish and edge cases
- Hour 6: Testing and verification
If the plan doesn't fit in 6 focused hours, it might be too large for a single pass.
Mode Selection
Ask the user which mode to use. Provide context-dependent defaults:
- If the plan is for a new feature → default EXPAND
- If the plan is for a refactor → default HOLD
- If the plan is for a bug fix → default REDUCE
AskUserQuestion: "Which review mode should I use?"
A) EXPAND — dream big, find the 10-star version [default for new features]
B) HOLD — maxi
阅读完整来源 ↗