Plan Eng Review

What Is This?

Overview

Plan Eng Review is an engineering manager-mode review skill designed to lock in execution plans before development begins. It systematically walks through architecture decisions, data flow, diagrams, edge cases, test coverage, and performance considerations, providing opinionated recommendations at each step. The skill operates interactively, surfacing potential issues early rather than allowing them to compound during implementation.

The skill is sourced from the garrytan/gstack collection and operates at preamble tier 3, meaning it applies a high level of structured reasoning to the review process. Rather than offering passive observations, it takes a directive stance, similar to how a senior engineering manager would challenge assumptions and push for clarity before a team commits to a technical direction.

Plan Eng Review is most valuable at the boundary between planning and coding. When a developer or team has a design document or architectural sketch and is about to write the first line of code, this skill intercepts that transition and ensures the plan is genuinely ready for execution. It catches architecture issues before they become expensive refactors.

Who Should Use This

• Software engineers preparing to implement a new feature or service who want a structured pre-coding review
• Engineering managers who need a consistent framework for reviewing technical plans submitted by their teams
• Technical leads responsible for architecture decisions on projects involving multiple contributors
• Developers working solo on complex systems who lack a peer reviewer but need external challenge to their assumptions
• Teams adopting a design-first development culture who want a repeatable review process
• Product engineers transitioning from prototype to production-grade implementation

Why Use It?

Problems It Solves

• Architecture decisions made informally during planning often lack documented rationale, leading to confusion during implementation and onboarding
• Edge cases discovered mid-development cause scope creep, missed deadlines, and hasty workarounds that accumulate as technical debt
• Test coverage gaps are rarely visible until after code is written, making retroactive testing more difficult and less effective
• Performance bottlenecks embedded in early architectural choices are costly to address once a system is built and deployed
• Data flow ambiguities between services or components create integration bugs that are difficult to trace and reproduce

Core Highlights

• Interactive, step-by-step review process that walks through each architectural concern in sequence
• Opinionated recommendations rather than open-ended questions, providing actionable direction
• Covers architecture, data flow, diagrams, edge cases, test coverage, and performance in a single session
• Proactively suggests itself when a plan or design document is present and coding is imminent
• Designed to mirror the rigor of an engineering manager review without requiring a synchronous meeting
• Structured to produce a locked execution plan, not just a list of concerns
• Compatible with any technology stack or project type

How to Use It?

Basic Usage

Invoke the skill when you have a plan document, architecture diagram, or design spec ready. A typical trigger phrase looks like this:

"Review the architecture for my new authentication service."
"Engineering review: here is my design doc for the data pipeline."
"Lock in the plan before I start coding the payment module."

The skill will begin an interactive session, moving through each review dimension and asking targeted questions or surfacing specific concerns.

Specific Scenarios

Scenario 1: Microservice Architecture Review A developer has sketched a three-service architecture for an order processing system. The skill reviews service boundaries, identifies a missing retry mechanism in the payment callback flow, and recommends adding a dead-letter queue before implementation begins.

Scenario 2: Database Schema Lock-In Before migrating a monolith to a new schema, the skill reviews the proposed table structure, flags a missing index on a high-frequency query column, and recommends a migration rollback strategy.

Real-World Examples

A team building a real-time notification system uses the skill to review their WebSocket architecture. The review surfaces a fan-out bottleneck under high concurrency and recommends a pub-sub pattern instead.

A solo developer designing a file upload service runs the skill before writing any code. The review identifies an unhandled partial upload edge case and recommends chunked upload validation logic.

Important Notes

Requirements

• A concrete plan, design document, or architectural sketch must exist before invoking the skill
• The user should be prepared to engage interactively, as the review proceeds through multiple dimensions
• Sufficient context about the system, its constraints, and its expected load should be available for accurate recommendations