
Plan Eng Review
Run an engineering-manager-style plan review—architecture, data flow, tests, edge cases, and performance—before your agent touches code.
Overview
gstack plan-eng-review is an agent skill most often used in Ship (also Validate, Build) that reviews execution plans interactively for architecture, tests, and edge cases before code changes.
Install
npx skills add https://github.com/topshark-jim/gstack --skill plan-eng-reviewWhat is this skill?
- Eng manager-mode review: architecture, data flow, diagrams, edge cases, tests, performance
- Priority hierarchy: Step 0 and test diagram outrank compressible sections
- Opinionated recommendations with tradeoffs and mandatory user input before assuming direction
- Preferences: aggressive DRY flags, non-negotiable test coverage, balanced engineering depth
- Interactive walkthrough—asks the user directly per workflow stops
- Priority hierarchy: Step 0 and test diagram must not be skipped when compressing context
Adoption & trust: 1 installs on skills.sh; 3/3 security scanners passed (skills.sh audits); trending (+100% hot-view momentum).
What problem does it solve?
You have an execution plan but no structured eng review to catch architectural gaps, weak test strategy, or unhandled edge cases before coding begins.
Who is it for?
Indie builders with a written plan or TODO who want Socratic, test-heavy critique before the agent edits the repo.
Skip if: Emergency hotfixes where the plan is already approved, or tasks with no plan artifact to review.
When should I use this skill?
Review this plan thoroughly before making any code changes and stop for user input on each major recommendation.
What do I get? / Deliverables
You exit with a reviewed plan, explicit tradeoff decisions, a test diagram mindset, and user-confirmed direction—ready to implement or invoke a planning-to-code handoff skill.
- Issue list with tradeoffs and opinionated recommendations
- Test coverage diagram emphasis and confirmed user decisions on open questions
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Plan eng review is canonically shelved under Ship/review because it is structured critique of an execution plan with the same rigor as pre-merge review, just earlier in the loop. The review subphase matches interactive issue walkthroughs, opinionated recommendations, and explicit user input before direction is assumed.
Where it fits
Walk the spec for missing edge cases before you approve prototype scope.
Review a task breakdown for DRY issues and test coverage before the agent opens files.
Treat the execution plan like a pre-merge review with diagrams and performance notes.
How it compares
Structured plan review with mandatory user checkpoints—not a linter-only pass or a journey-wide brainstorming ritual.
Common Questions / FAQ
Who is gstack plan-eng-review for?
Solo developers and small teams using gstack-style agents who want manager-level plan scrutiny without scheduling a human review meeting.
When should I use gstack plan-eng-review?
In Validate when scoping a feature spec, in Build before PM breakdown turns into tickets, and in Ship when you want review-grade rigor on architecture and tests prior to implementation.
Is gstack plan-eng-review safe to install?
Review the Security Audits panel on this page; the skill prompts for input and reads repo docs but should not be treated as a substitute for your own security sign-off on the plan.
SKILL.md
READMESKILL.md - Plan Eng Review
<!-- Generated by tools/convert_gstack.py. Edit the converter, not this file. --> ## Runtime Notes - Ask the user directly when the workflow says to stop for input. - Treat `AGENTS.md`, `TODO.md`, and `TODOS.md` as the likely sources of repo-local instructions. - Keep the workflow intent intact, but translate any environment-specific wording to the current toolset. # Plan Review Mode Review this plan thoroughly before making any code changes. For every issue or recommendation, explain the concrete tradeoffs, give me an opinionated recommendation, and ask for my input before assuming a direction. ## Priority hierarchy If you are running low on context or the user asks you to compress: Step 0 > Test diagram > Opinionated recommendations > Everything else. Never skip Step 0 or the test diagram. ## My engineering preferences (use these to guide your recommendations): * DRY is important—flag repetition aggressively. * Well-tested code is non-negotiable; I'd rather have too many tests than too few. * I want code that's "engineered enough" — not under-engineered (fragile, hacky) and not over-engineered (premature abstraction, unnecessary complexity). * I err on the side of handling more edge cases, not fewer; thoughtfulness > speed. * Bias toward explicit over clever. * Minimal diff: achieve the goal with the fewest new abstractions and files touched. ## Documentation and diagrams: * I value ASCII art diagrams highly — for data flow, state machines, dependency graphs, processing pipelines, and decision trees. Use them liberally in plans and design docs. * For particularly complex designs or behaviors, embed ASCII diagrams directly in code comments in the appropriate places: Models (data relationships, state transitions), Controllers (request flow), Concerns (mixin behavior), Services (processing pipelines), and Tests (what's being set up and why) when the test structure is non-obvious. * **Diagram maintenance is part of the change.** When modifying code that has ASCII diagrams in comments nearby, review whether those diagrams are still accurate. Update them as part of the same commit. Stale diagrams are worse than no diagrams — they actively mislead. Flag any stale diagrams you encounter during review even if they're outside the immediate scope of the change. ## BEFORE YOU START: ### Step 0: Scope Challenge Before reviewing anything, answer these questions: 1. **What existing code already partially or fully solves each sub-problem?** Can we capture outputs from existing flows rather than building parallel ones? 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. Be ruthless about scope creep. 3. **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. Then ask if I want one of three options: 1. **SCOPE REDUCTION:** The plan is overbuilt. Propose a minimal version that achieves the core goal, then review that. 2. **BIG CHANGE:** Work through interactively, one section at a time (Architecture → Code Quality → Tests → Performance) with at most 8 top issues per section. 3. **SMALL CHANGE:** Compressed review — Step 0 + one combined pass covering all 4 sections. For each section, pick the single most important issue (think hard — this forces you to prioritize). Present as a single numbered list with lettered options + mandatory test diagram + completion summary. one direct question round at the end. For each issue in the batch, state your recommendation and explain WHY, with lettered options. **Critical: If I do not select SCOPE REDUCTION