plan-ceo-review skill (gstack) (part 2)

Part 2 of 2 of plan-ceo-review skill (gstack) (plan-ceo-review/SKILL.md in garrytan/gstack); the SKILL.md text continues verbatim from the previous part.

SKILL.md (verbatim, continued)

If the Aside check did not print READY, run the same queries with the WebSearch tool when the host provides it; with neither, skip this check and note: "Search unavailable — proceeding with in-distribution knowledge only."

Run the three-layer synthesis:

• [Layer 1] What's the tried-and-true approach in this space?
• [Layer 2] What are the search results saying?
• [Layer 3] First-principles reasoning — where might the conventional wisdom be wrong?

Feed into the Premise Challenge (0A) and Dream State Mapping (0C). If you find a eureka moment, surface it during the Expansion opt-in ceremony as a differentiation opportunity. Log it (see preamble).

Prior Learnings

Search for relevant learnings from previous sessions:

_CROSS_PROJ=$(~/.claude/skills/gstack/bin/gstack-config get cross_project_learnings 2>/dev/null || echo "unset")
echo "CROSS_PROJECT: $_CROSS_PROJ"
if [ "$_CROSS_PROJ" = "true" ]; then
  ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 10 --cross-project 2>/dev/null || true
else
  ~/.claude/skills/gstack/bin/gstack-learnings-search --limit 10 2>/dev/null || true
fi

If CROSS_PROJECT is unset (first time): Use AskUserQuestion:

gstack can search learnings from your other projects on this machine to find patterns that might apply here. This stays local (no data leaves your machine). Recommended for solo developers. Skip if you work on multiple client codebases where cross-contamination would be a concern.

Options:

• A) Enable cross-project learnings (recommended)
• B) Keep learnings project-scoped only

If A: run ~/.claude/skills/gstack/bin/gstack-config set cross_project_learnings true If B: run ~/.claude/skills/gstack/bin/gstack-config set cross_project_learnings false

Then re-run the search with the appropriate flag.

If learnings are found, incorporate them into your analysis. When a review finding matches a past learning, display:

"Prior learning applied: [key] (confidence N/10, from [date])"

This makes the compounding visible. The user should see that gstack is getting smarter on their codebase over time.

Brain Context (preflight)

Before asking any clarifying questions, load the brain's structured context for this project. The cache layer handles staleness, refresh, and stale-but- usable fallback automatically. Skip questions whose answers are already present in the loaded context; ground recommendations in what the brain already knows about the user, the product, the goals, and recent decisions.

eval "$(~/.claude/skills/gstack/bin/gstack-slug 2>/dev/null)" 2>/dev/null || true
{
  printf '## Brain Context\n\n'
  printf '\n### %s\n\n' "product"
  ~/.claude/skills/gstack/bin/gstack-brain-cache get product --project "$SLUG" 2>/dev/null || printf '_(no product digest available yet)_\n'
  printf '\n### %s\n\n' "goals"
  ~/.claude/skills/gstack/bin/gstack-brain-cache get goals --project "$SLUG" 2>/dev/null || printf '_(no goals digest available yet)_\n'
  printf '\n### %s\n\n' "recent-decisions"
  ~/.claude/skills/gstack/bin/gstack-brain-cache get recent-decisions --project "$SLUG" 2>/dev/null || printf '_(no recent-decisions digest available yet)_\n'
  printf '\n### %s\n\n' "user-profile"
  ~/.claude/skills/gstack/bin/gstack-brain-cache get user-profile  2>/dev/null || printf '_(no user-profile digest available yet)_\n'
} > /tmp/.gstack-brain-context-$$.md 2>/dev/null
[ -s /tmp/.gstack-brain-context-$$.md ] && cat /tmp/.gstack-brain-context-$$.md
rm -f /tmp/.gstack-brain-context-$$.md 2>/dev/null || true

How to use this context:

• If product digest names the value prop, target user, or stage — don't re-ask.
• If goals digest lists active goals — frame recommendations against them.
• If recent-decisions digest names a prior scope/architecture choice — flag if this plan contradicts.
• If user-profile digest carries calibration pattern statements ("tends to over-engineer security") — surface them when relevant.
• If a digest is (no X digest available yet), treat that section as cold; ask the user.

Privacy: Salience digest is filtered by allowlist (D9 default: projects/, gstack/, concepts/ only). Personal/family/therapy content never leaks here.

Section index — Read each section when its situation applies

This skill is a decision-tree skeleton. The steps below point to on-demand sections. Read a section in full before doing its step; do not work from memory.

When	Read this section
running the 11-section deep review, required outputs, and review report (only after Step 0 scope and mode are agreed)	sections/review-sections.md

Step 0: Nuclear Scope Challenge + Mode Selection

0A. Premise Challenge

1. Is this the right problem to solve? Could a different framing yield a dramatically simpler or more impactful solution?
2. What is the actual user/business outcome? Is the plan the most direct path to that outcome, or is it solving a proxy problem?
3. What would happen if we did nothing? Real pain point or hypothetical one?

0B. Existing Code Leverage

1. What existing code already partially or fully solves each sub-problem? Map every sub-problem to existing code. Can we capture outputs from existing flows rather than building parallel ones?
2. Is this plan rebuilding anything that already exists? If yes, explain why rebuilding is better than refactoring.

0C. Dream State Mapping

Describe the ideal end state of this system 12 months from now. Does this plan move toward that state or away from it?

  CURRENT STATE                  THIS PLAN                  12-MONTH IDEAL
  [describe]          --->       [describe delta]    --->    [describe target]

0C-bis. Implementation Alternatives (MANDATORY)

Before selecting a mode (0F), produce 2-3 distinct implementation approaches. This is NOT optional — every plan must consider alternatives.

For each approach:

APPROACH A: [Name]
  Summary: [1-2 sentences]
  Effort:  [S/M/L/XL]
  Risk:    [Low/Med/High]
  Pros:    [2-3 bullets]
  Cons:    [2-3 bullets]
  Reuses:  [existing code/patterns leveraged]

APPROACH B: [Name]
  ...

APPROACH C: [Name] (optional — include if a meaningfully different path exists)
  ...

RECOMMENDATION: Choose [X] because [one-line reason mapped to engineering preferences].

Rules:

• At least 2 approaches required. 3 preferred for non-trivial plans.
• One approach must be the "minimal viable" (fewest files, smallest diff).
• One approach must be the "ideal architecture" (best long-term trajectory).
• These two approaches have equal weight. Don't default to "minimal viable" just because it's smaller. Recommend whichever best serves the user's goal. If the right answer is a rewrite, say so.
• If only one approach exists, explain concretely why alternatives were eliminated.
• Do NOT proceed to mode selection (0F) without user approval of the chosen approach.

Present these approach options via AskUserQuestion using the preamble's AskUserQuestion Format section: include RECOMMENDATION and Completeness: N/10 on every option. These approaches differ in coverage (minimal viable vs ideal architecture), so completeness scoring applies directly.

STOP. AskUserQuestion once per issue. Do NOT batch. Recommend + WHY. Do NOT proceed to Step 0D or 0F until the user responds to 0C-bis. A "clearly winning approach" is still an approach decision and still needs explicit user approval before it lands in the plan. Reminder: Do NOT make any code changes. Review only.

0F. Mode Selection

Run after 0C-bis and before 0D; labels remain stable for cross-references. In every mode, you are 100% in control. No scope is added without your explicit approval.

Present four options:

1. SCOPE EXPANSION: The plan is good but could be great. Dream big — propose the ambitious version. Every expansion is presented individually for your approval. You opt in to each one.
2. SELECTIVE EXPANSION: The plan's scope is the baseline, but you want to see what else is possible. Every expansion opportunity presented individually — you cherry-pick the ones worth doing. Neutral recommendations.
3. HOLD SCOPE: The plan's scope is right. Review it with maximum rigor — architecture, security, edge cases, observability, deployment. Make it bulletproof. No expansions surfaced.
4. SCOPE REDUCTION: The plan is overbuilt or wrong-headed. Propose a minimal version that achieves the core goal, then review that.

Context-dependent defaults:

• Greenfield feature → default EXPANSION
• Feature enhancement or iteration on existing system → default SELECTIVE EXPANSION
• Bug fix or hotfix → default HOLD SCOPE
• Refactor → default HOLD SCOPE
• Plan touching >15 files → suggest REDUCTION unless user pushes back
• User says "go big" / "ambitious" / "cathedral" → EXPANSION, no question
• User says "hold scope but tempt me" / "show me options" / "cherry-pick" → SELECTIVE EXPANSION, no question

After mode is selected, confirm which implementation approach (from 0C-bis) applies under the chosen mode. EXPANSION may favor the ideal architecture approach; REDUCTION may favor the minimal viable approach.

Once selected, commit fully. Do not silently drift.

Present these mode options via AskUserQuestion using the preamble's AskUserQuestion Format section: include RECOMMENDATION. These options differ in kind (review posture), not coverage — do NOT emit Completeness: N/10 per option. Include the one-line note from step 4 of the preamble format rule instead: Note: options differ in kind, not coverage — no completeness score.

STOP. Unless the user already explicitly selected a mode, ask via AskUserQuestion and wait for their choice. Then continue to 0D-prelude, 0D, 0D-POST, and 0E as applicable. Reminder: Do NOT make any code changes. Review only.

0D-prelude. Expansion Framing (shared by EXPANSION and SELECTIVE EXPANSION)

Every expansion proposal you generate in SCOPE EXPANSION or SELECTIVE EXPANSION mode follows this framing pattern:

FLAT (avoid): "Add real-time notifications. Users would see workflow results faster — latency drops from ~30s polling to <500ms push. Effort: ~1 hour CC."

EXPANSIVE (aim for): "Imagine the moment a workflow finishes — the user sees the result instantly, no tab-switching, no polling, no 'did it actually work?' anxiety. Real-time feedback turns a tool they check into a tool that talks to them. Concrete shape: WebSocket channel + optimistic UI + desktop notification fallback. Effort: human ~2 days / CC ~1 hour. Makes the product feel 10x more alive."

Both are outcome-framed. Only one makes the user feel the cathedral. Lead with the felt experience, close with concrete effort and impact.

For SELECTIVE EXPANSION: neutral recommendation posture ≠ flat prose. Present vivid options, then let the user decide. Do not over-sell — "Makes the product feel 10x more alive" is vivid; "This would 10x your revenue" is over-sell. Evocative, not promotional.

0D. Mode-Specific Analysis

For SCOPE EXPANSION — run all three, then the opt-in ceremony:

1. 10x check: What's the version that's 10x more ambitious and delivers 10x more value for 2x the effort? Describe it concretely.
2. Platonic ideal: If the best engineer in the world had unlimited time and perfect taste, what would this system look like? What would the user feel when using it? Start from experience, not architecture.
3. Delight opportunities: What adjacent 30-minute improvements would make this feature sing? Things where a user would think "oh nice, they thought of that." List at least 5.
4. Expansion opt-in ceremony: Describe the vision first (10x check, platonic ideal). Then distill concrete scope proposals from those visions — individual features, components, or improvements. Present each proposal as its own AskUserQuestion. Recommend enthusiastically — explain why it's worth doing. But the user decides. Options: A) Add to this plan's scope B) Defer to TODOS.md C) Skip. Accepted items become plan scope for all remaining review sections. Rejected items go to "NOT in scope."

For SELECTIVE EXPANSION — run the HOLD SCOPE analysis first, then surface expansions:

1. Complexity check: If the plan touches more than 8 files or introduces more than 2 new classes/services, treat that as a smell and challenge whether the same goal can be achieved with fewer moving parts.
2. What is the minimum set of changes that achieves the stated goal? Flag any work that could be deferred without blocking the core objective.
3. Then run the expansion scan (do NOT add these to scope yet — they are candidates):
   • 10x check: What's the version that's 10x more ambitious? Describe it concretely.
   • Delight opportunities: What adjacent 30-minute improvements would make this feature sing? List at least 5.
   • Platform potential: Would any expansion turn this feature into infrastructure other features can build on?
4. Cherry-pick ceremony: Present each expansion opportunity as its own individual AskUserQuestion. Neutral recommendation posture — present the opportunity, state effort (S/M/L) and risk, let the user decide without bias. Options: A) Add to this plan's scope B) Defer to TODOS.md C) Skip. If you have more than 8 candidates, present the top 5-6 and note the remainder as lower-priority options the user can request. Accepted items become plan scope for all remaining review sections. Rejected items go to "NOT in scope."

For HOLD SCOPE — run this:

1. Complexity check: If the plan touches more than 8 files or introduces more than 2 new classes/services, treat that as a smell and challenge whether the same goal can be achieved with fewer moving parts.
2. What is the minimum set of changes that achieves the stated goal? Flag any work that could be deferred without blocking the core objective.

For SCOPE REDUCTION — run this:

1. Ruthless cut: What is the absolute minimum that ships value to a user? Everything else is deferred. No exceptions.
2. What can be a follow-up PR? Separate "must ship together" from "nice to ship together."

0D-POST. Persist CEO Plan (EXPANSION and SELECTIVE EXPANSION only)

After the opt-in/cherry-pick ceremony, write the plan to disk so the vision and decisions survive beyond this conversation. Only run this step for EXPANSION and SELECTIVE EXPANSION modes.

eval "$(~/.claude/skills/gstack/bin/gstack-slug 2>/dev/null)" && mkdir -p ~/.gstack/projects/$SLUG/ceo-plans

Before writing, check for existing CEO plans in the ceo-plans/ directory. If any are >30 days old or their branch has been merged/deleted, offer to archive them:

mkdir -p ~/.gstack/projects/$SLUG/ceo-plans/archive
# For each stale plan: mv ~/.gstack/projects/$SLUG/ceo-plans/{old-plan}.md ~/.gstack/projects/$SLUG/ceo-plans/archive/

Write to ~/.gstack/projects/$SLUG/ceo-plans/{date}-{feature-slug}.md using this format:

---
status: ACTIVE
---
# CEO Plan: {Feature Name}
Generated by /plan-ceo-review on {date}
Branch: {branch} | Mode: {EXPANSION / SELECTIVE EXPANSION}
Repo: {owner/repo}

## Vision

### 10x Check
{10x vision description}

### Platonic Ideal
{platonic ideal description — EXPANSION mode only}

## Scope Decisions

| # | Proposal | Effort | Decision | Reasoning |
|---|----------|--------|----------|-----------|
| 1 | {proposal} | S/M/L | ACCEPTED / DEFERRED / SKIPPED | {why} |

## Accepted Scope (added to this plan)
- {bullet list of what's now in scope}

## Deferred to TODOS.md
- {items with context}

Derive the feature slug from the plan being reviewed (e.g., "user-dashboard", "auth-refactor"). Use the date in YYYY-MM-DD format.

After writing the CEO plan, run the spec review loop on it:

Spec Review Loop

Before presenting the document to the user for approval, run an adversarial review.

Step 1: Dispatch reviewer subagent

Use the Agent tool to dispatch an independent reviewer, passing run_in_background: false (subagents default to background since Claude Code v2.1.198; this loop consumes the reviewer's verdict). The reviewer has fresh context and cannot see the brainstorming conversation — only the document. This ensures genuine adversarial independence.

Prompt the subagent with:

• The file path of the document just written
• "Read this document and review it on 5 dimensions. For each dimension, note PASS or list specific issues with suggested fixes. At the end, output a quality score (1-10) across all dimensions."

Dimensions:

1. Completeness — Are all requirements addressed? Missing edge cases?
2. Consistency — Do parts of the document agree with each other? Contradictions?
3. Clarity — Could an engineer implement this without asking questions? Ambiguous language?
4. Scope — Does the document creep beyond the original problem? YAGNI violations?
5. Feasibility — Can this actually be built with the stated approach? Hidden complexity?

The subagent should return:

• A quality score (1-10)
• PASS if no issues, or a numbered list of issues with dimension, description, and fix

Step 2: Fix and re-dispatch

If the reviewer returns issues:

1. Fix each issue in the document on disk (use Edit tool)
2. Re-dispatch the reviewer subagent with the updated document
3. Maximum 3 iterations total

Convergence guard: If the reviewer returns the same issues on consecutive iterations (the fix didn't resolve them or the reviewer disagrees with the fix), stop the loop and persist those issues as "Reviewer Concerns" in the document rather than looping further.

If the subagent fails, times out, or is unavailable — skip the review loop entirely. Tell the user: "Spec review unavailable — presenting unreviewed doc." The document is already written to disk; the review is a quality bonus, not a gate.

Step 3: Report and persist metrics

After the loop completes (PASS, max iterations, or convergence guard):

1. Tell the user the result — summary by default: "Your doc survived N rounds of adversarial review. M issues caught and fixed. Quality score: X/10." If they ask "what did the reviewer find?", show the full reviewer output.

2. If issues remain after max iterations or convergence, add a "## Reviewer Concerns" section to the document listing each unresolved issue. Downstream skills will see this.

3. Append metrics:

mkdir -p ~/.gstack/analytics
echo '{"skill":"plan-ceo-review","ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","iterations":ITERATIONS,"issues_found":FOUND,"issues_fixed":FIXED,"remaining":REMAINING,"quality_score":SCORE}' >> ~/.gstack/analytics/spec-review.jsonl 2>/dev/null || true

Replace ITERATIONS, FOUND, FIXED, REMAINING, SCORE with actual values from the review.

0E. Temporal Interrogation (EXPANSION, SELECTIVE EXPANSION, and HOLD modes)

Think ahead to implementation: What decisions will need to be made during implementation that should be resolved NOW in the plan?

  HOUR 1 (foundations):     What does the implementer need to know?
  HOUR 2-3 (core logic):   What ambiguities will they hit?
  HOUR 4-5 (integration):  What will surprise them?
  HOUR 6+ (polish/tests):  What will they wish they'd planned for?

NOTE: These represent human-team implementation hours. With CC + gstack, 6 hours of human implementation compresses to ~30-60 minutes. The decisions are identical — the implementation speed is 10-20x faster. Always present both scales when discussing effort.

Surface these as questions for the user NOW, not as "figure it out later."

STOP. Before running the 11-section deep review, required outputs, and review report (only after Step 0 scope and mode are agreed), Read ~/.claude/skills/gstack/plan-ceo-review/sections/review-sections.md and execute it in full. Do not work from memory — that section is the source of truth for this step.

Section self-check (before you finish)

You ran a carved skill. The Section index above named sections/review-sections.md as the source of truth for the 11-section deep review, the required outputs, and the review report. Confirm you issued a Read for it and executed every section from the file, not from memory. If you produced the Completion Summary or wrote the review report without Reading that section, STOP, Read it now, and redo the review from the source of truth.

EXIT PLAN MODE GATE (BLOCKING)

Before calling ExitPlanMode, run this self-check. If any item fails, do the missing work — do NOT call ExitPlanMode:

1. Read the plan file with the Read tool (after your most recent write to it).
2. Confirm the LAST ## heading in the file is ## GSTACK REVIEW REPORT. In-body prose that mentions "outside voice", "codex findings", or similar does NOT count — only the structured ## GSTACK REVIEW REPORT section satisfies this check.
3. Confirm the report has a Runs / Status / Findings table and a VERDICT line (CODEX / CROSS-MODEL absorbed if applicable).
4. Confirm the report's FINAL non-whitespace line is the unresolved-decisions status: the exact unbolded NO UNRESOLVED DECISIONS, or a bullet of a final **UNRESOLVED DECISIONS:** block. BLOCKING, no "if applicable" escape — a bolded sentinel, any trailing CODEX/CROSS-MODEL/VERDICT/prose, or a missing status each FAILS the gate.
5. If a plan file is in context for this skill invocation: confirm gstack-review-log was called and gstack-review-read was run at least once. If no plan file is in context (e.g. /codex consult against a diff with no plan), this check short-circuits — checks 1-4 already short-circuit when no plan file exists.

Failing this gate and calling ExitPlanMode anyway is a contract violation — the user will see a plan whose review report is missing or stale, and will (correctly) reject it. Self-deception failure mode to watch for: feeling "done" after writing review prose into the plan body. The body prose is not the report. The report is a separate, structured, table-bearing section that must be the file's terminal heading.

Other files in this skill

• SKILL.md.tmpl
• sections/manifest.json
• sections/review-sections.md
• sections/review-sections.md.tmpl

Back to garrytan/gstack (Garry Tan's Claude Code skill suite) or Agent skills.