Skip to content
Skill Authoring
Skill

/gstack-plan

Use before building a feature: challenge the scope, then review architecture, code quality, tests and performance, and end with a plan to build. (gstack)

From plugin
gstack
141k4 skills

Claude Code

$ npx -y skills add garrytan/gstack --skill gstack-plan --agent claude-code

SKILL.md

gstack-plan.SKILL.md
name: gstack-plan
description: "Use before building a feature: challenge the scope, then review architecture, code quality, tests and performance, and end with a plan to build. (gstack)"

<!-- Generated by scripts/gen-qm-edition.ts from hosts/qm.ts and plan-eng-review/SKILL.md.tmpl, plan-eng-review/sections/review-sections.md.tmpl. Do not edit. -->

Plan a feature: scope first, then the engineering review

Review a plan, not code: do not build the feature. If the user has not given you the plan or feature description, ask for it and stop.

**Start here.** In the repository (`cd` into it first: the shell starts in the workspace root), run with `execute` to see what already exists:

git log --oneline -10
ls

Then read the files the plan touches. Work through Scope Challenge, then Sections 1-4 in order; for each finding give severity, a recommendation and the alternative. Ask about decisions that change scope in one message and stop until the user answers. Finish with the revised plan: what to build, in order, the files it touches, the tests that prove it, and what is NOT in scope.

My engineering preferences (use these to guide your recommendations):

  • **Shared code:** require common behavior and improved reliability or net savings; similar-looking code alone is insufficient.
  • **Tests:** every behavior tested; no test without a regression it would catch.
  • **Enough engineering:** avoid fragility and premature abstraction/complexity.
  • **Edge cases:** thorough handling over speed.
  • **Explicit over clever.**
  • **Right-sized diff:** smallest clear change; rewrite a broken foundation when necessary.
  • **Data model:** storage follows the data's queries, integrity rules and update boundaries, not file count: fields queried, constrained or updated on their own get explicit columns or tables; JSON suits a document read and written whole.

A. Assess the target

Complete these checks before proposing scope changes. Do not write findings into the plan yet.

  • **What already solves each sub-problem?** Inspect helpers, libraries, callers and reusable outputs: behavior and dependency/deployment boundaries. Cite authored sources; label proposed callers with their motivating plan requirement and assumptions.
  • **What minimum changes achieve the goal?** Flag work deferrable without blocking it; challenge scope creep.
  • **Complexity check:** Count the selected work, not files read only as evidence:

for a plan, its proposed changed files and new classes/services; for a diff, changed files and classes/services introduced by that diff; for a file/directory, files in that selected scope and any explicitly proposed new classes/services. Count each once, label estimates, and seek fewer moving parts. At 8+ files or 2+ new classes or services, propose a smaller arrangement and ask before changing scope.

  • **Distribution check:** For new artifacts, verify build/publish CI/CD, target

OS/architectures and download/install channels. Put deferrals in "NOT in scope".

Review Sections (after scope is agreed)

Evaluate Architecture → Code Quality → Tests → Performance. Never condense, abbreviate or skip a section, including strategy/spec/infra plans.

1. Architecture review

Evaluate:

  • System/component boundaries, dependencies and coupling.
  • Data flow, bottlenecks, scaling and single points of failure.
  • Security: auth, data access and API boundaries.
  • Key flows needing ASCII diagrams in plans/code.
  • One realistic production failure per new path/integration; does the plan handle it?
  • **Distribution architecture:** New artifacts' build, publish and update paths; included or deferred CI/CD.

<!-- "Design it twice" and the red flags derive from pstack's architect skill (Lauren Tan, MIT), rewritten for gstack. See NOTICE.md. -->

Two shapes before one (design-twice)

Run this only when the plan introduces a new module, service, package or boundary: a public surface other code calls; otherwise say so in one line.

**Ask for the second shape.** A plan with one design usually took the first shape that compiled in the author's head. Before judging it, require a second shape that is structurally different: another owner for the state, another split of responsibilities, another place for the boundary. A point fix inside the first shape is not a second candidate. When the plan has none, sketch one in five lines (types and signatures, bodies `not implemented`) and record it as the alternative. Compare the candidates on interface depth: how much behavior and policy each hides behind how small a public surface, and prefer the one that hides more behind less. A deep module is not a deep call chain: the chain scatters the understanding across layers, the module concentrates it behind one interface.

**The eight red flags.** Screen the chosen shape before Section 1 closes. Assume the next contributor is an agent that sees only the files it opened, copies the nearest example and takes the shortest path that compiles; prefer the design where a change that looks right from one file is right for the whole repo. A flag is a finding with a file or symbol and a reason to revise the shape, not a comment asking for care.

1. **Shallow module.** A large interface over little hidden complexity: several calls per operation, options that expose internal stages. 2. **Information leakage.** One decision (a representation, a policy, a wire or storage detail) lives in more than one module. Re-exported transport types are leakage; parse external data into domain types at the boundary. 3. **Temporal decomposition.** Modules split by execution order (load, validate, transform, save) instead of by the knowledge they own. 4. **Pass-through method.** A function that forwards the same arguments to another with the same shape; remove it or move the responsibility. 5. **Split ownership.** Two modules write the same state or each keep a copy; an agent editing one cannot see the other. One owner p

Read more
@garrytan
Ships withgstack

gstack turns Claude Code (and other coding agents) into a virtual engineering team: a CEO who rethinks the product, an eng manager who locks architecture, a designer who catches AI slop, a reviewer who finds production bugs, a QA lead who opens a real

Stars on GitHub

Momentum

stars in total
141.5k
Star history of garrytan/gstack on GitHub, a chart by star-history.com

Other skills on gstack.

gstack-openclaw-ceo-review

gstack-openclaw-ceo-re…

Use when asked to review a plan, challenge a proposal, run a CEO review, poke holes in an approach, think bigger about scope, or…

@garrytan@garrytanInstall Skill
gstack-openclaw-retro

gstack-openclaw-retro

Weekly engineering retrospective. Analyzes commit history, work patterns, and code quality metrics with persistent history and…

@garrytan@garrytanInstall Skill

More skills from other plugins.

book-to-skill

book-to-skill

Converts books and documents (PDF, EPUB, DOCX, HTML, Markdown, plain text, RTF, MOBI/AZW with Calibre) into structured agent…

@virgiliojr94@virgiliojr94Install Skill
distilly

distilly

Set up the owner profile so a personal agent knows who it works for (first-run setup, \"get to know me\"), or distill colleague,…

@titanwings@titanwingsInstall Skill
skillopt-sleep

skillopt-sleep

Use when the user wants their Claude agent to self-improve from past usage, asks about a nightly/offline 'sleep' or 'dream'…

@microsoft@microsoftInstall Skill

Questions about gstack-plan.

Which coding agents can use gstack-plan?
gstack-plan installs in Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode and Windsurf with the skills CLI, using each agent's flag shown on this page. Flowy's auto-invocation, which fires a skill when your prompt matches, runs in Claude Code only.