gstack — How One Coder Runs a 23-Person Team

TL;DR

• gstack (garrytan/gstack) is a meta-framework in which Y Combinator President & CEO Garry Tan opened his own Claude Code setup as-is, as open source. Two months after its 2026-03-11 release: 95.9k★, 14.3k forks, 1,200+ issues, and at v1.34.1.0 (2026-05-13), a cumulative 14,965 unique installs + 305,309 skill invocations (opt-in telemetry). Of the three, it's the frame with the most explicit organizational metaphor.
• The mechanism in one line: 23 slashes + 8 power tools each map to a role. /office-hours (YC Office Hours persona), /plan-ceo-review (CEO/Founder), /plan-eng-review (Eng Manager), /plan-design-review (Senior Designer), /qa (QA Lead), /cso (Chief Security Officer), /ship (Release Engineer), /canary (SRE) — the org chart of a virtual company is the set of slash commands. A single coder calls those 23 people one at a time.
• How it runs: the sprint sequence is the substance. Think (/office-hours) → Plan (/plan-*-review) → Build → Review (/review) → Test (/qa) → Ship (/ship) → Reflect (/retro). Each slash reads the output of the prior stage and hands it to the next — the design doc flows into the plan, the plan builds the test matrix, the test flows into ship's regression check.
• It's also the frame with by far the thickest real code of the three. Behind /qa is a 2,000+ line Playwright-based browser server; behind /design-html is a Pretext computed-layout engine; a 22MB local ML classifier defends the sidebar agent against prompt injection. It's more than a bundle of markdown prompts.
• Used solo, it's strong at driving a product all the way through. Building a design system, QA with a real browser, PR automation — one cycle closes end to end. Mix it with Superpowers/GSD and you hit the 5 conflict surfaces in §6 — especially that /office-hours occupies the same slot as Superpowers' brainstorming HARD-GATE, and the invasive design where, uniquely among the three, it directly edits the user's CLAUDE.md.

1. Introducing gstack

1.1. What it is

garrytan/gstack — a meta-framework in which Y Combinator President & CEO Garry Tan opened his own Claude Code setup as-is. One line of the README distills its identity:

"gstack is how I do it. It turns Claude Code 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 browser, a security officer who runs OWASP + STRIDE audits, and a release engineer who ships the PR." — README

23 slashes + 8 power tools are mapped straight onto an org chart. If Superpowers has an opinion about work order and GSD about work environment, gstack has an opinion about the actor of the work — the metaphor that a single coder calls 23 people one at a time is the substance.

1.2. The creator — Garry Tan and a solo coder's virtual company

You can't understand gstack without the creator's narrative. The context he lays out himself in the README's "Why I Built This":

• President & CEO of Y Combinator. Before YC, an early engineer/PM/designer at Palantir, co-founder of Posterous (acquired by Twitter), and builder of YC's internal social network, Bookface.
• Between January and April 2026, while keeping his part-time YC role, he shipped 3 production services + 40+ new features. By "logical code change," that's 810× his 2013 pace (11,417 vs 14 logical lines/day).
• He addresses the LOC controversy over this claim separately in docs/ON_THE_LOC_CONTROVERSY.md. After applying a 2× AI-inflation deflation it's 408×, at 5× deflation 162×, and even in a 10× pathological case 81×. His own take: "arguing about the size of the coefficient doesn't change the conclusion."
• Motivation: he's explicit that gstack is his own answer to Andrej Karpathy's "I don't think I've typed like a line of code probably since December" (No Priors podcast, 2026-03) and to Peter Steinberger's OpenClaw (247K★, effectively a solo build).

One thing gstack write-ups commonly miss: gstack is not a one-person project. As of 2026-05-13, there are 1,200+ closed issues, 50+ community contributors, and routine fix-wave batch PR merges (21 community PRs merged at once in v1.31, 12 in v1.32). Garry Tan's self-image is a solo coder, but gstack itself is a collaborative project. Worth noting for the sake of accuracy.

1.3. Strengths

• It maps role personas one-to-one onto slashes. Superpowers makes process gates and GSD makes context separation the first-class citizen; gstack makes roles the first-class citizen. Call /plan-ceo-review and a reviewer in CEO mode re-reads the plan with three modes — scope expansion, reduction, and hold. Call /cso and the code is read through an OWASP Top 10 + STRIDE threat model. Which persona you call being the workflow choice is the decisive difference from the other two in the same category.
• It has by far the thickest real code of the three. Setting gsd-2 aside, gstack has the largest engineering investment in the category. A Playwright-based browser server (browse/src/, 2,000+ lines), a Pretext computed-layout engine (design-html/), a 22MB local ML classifier (prompt-injection defense), an isolated session for the sidebar agent — all of it real systems code, not markdown prompts. A mostly-.tsx TypeScript core sits behind the commands.
• The sprint sequence closes in one cycle. The README's core flow: /office-hours (generate a design doc) → /autoplan or the three /plan-*-review (accumulate CEO/design/eng reviews onto the plan) → writing code (Build) → /review (staff engineer pass) → /qa (real-browser QA + auto-generated regression tests) → /ship (PR + coverage audit) → /canary (post-deploy monitoring) → /retro (weekly retro). The design doc flows into the plan, the plan builds the test matrix, the test flows into ship's regression check — each stage makes the input for the next.
• Support for 10 AI agent harnesses. Beyond Claude Code: Codex CLI / OpenCode / Cursor / Factory / Slate / Kiro / Hermes / GBrain (its own mod) / OpenClaw (ACP via Claude Code session). A single ./setup auto-detects installed harnesses and branches the install. Adding a harness is designed to take one TypeScript config file.
• Team mode — auto-deploy to a shared repo. ./setup --team + gstack-team-init required force-configures auto-update with no vendored files. Throttled once an hour, silent on network failure, commits on change. Superpowers/GSD have no team-onboarding mechanism — this makes gstack the first frame to assume organizational adoption.

1.4. Installation

git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/.claude/skills/gstack
cd ~/.claude/skills/gstack && ./setup

./setup auto-detects installed harnesses (Claude Code / Codex / Cursor / OpenCode / Factory / Slate / Kiro / Hermes / GBrain) and branches the install into each one's skills directory. To target a single harness, ./setup --host <name>.

The official path for team adoption — inside the repo:

(cd ~/.claude/skills/gstack && ./setup --team) \
  && ~/.claude/skills/gstack/bin/gstack-team-init required \
  && git add .claude/ CLAUDE.md \
  && git commit -m "require gstack for AI-assisted work"

team-init required force-activates gstack at every team member's session start; optional only nudges. Both edit the project CLAUDE.md to add a gstack section. That intrusion becomes the design conflict surface in §6.3.

Additional requirements: Bun v1.0+ is required. Node.js is for Windows only. Chromium is auto-installed by Playwright when you use /qa//browse.

2. How it works — the 23-person virtual team and the sprint sequence

2.1. The core metaphor — "Think → Plan → Build → Review → Test → Ship → Reflect"

gstack's substance is the sprint. One line of the README:

"gstack is a process, not a collection of tools. The skills run in the order a sprint runs." — README

Each stage takes the prior stage's output as input. /office-hours writes a design doc, the three /plan-*-review read that doc and accumulate reviews onto the plan, /qa picks up the test matrix /plan-eng-review built, and /ship regression-checks the bugs /review found. So that no information drops, the inter-stage interfaces are spelled out as markdown files.

This sequence makes the decisive difference from the other two in the category. Superpowers is closer to an order discipline that forces brainstorming before every code change, and GSD is an environment discipline where each phase starts with its own fresh 200k context. gstack runs the sequence swapping only the persona within the same context — a design that separates roles without separating context.

2.2. The 23 slashes = the virtual team's org chart

Caution: catalog inaccuracy — the README's install snippet lists 23+, and this piece's rundown follows the README "Specialists" table. As of v1.34, the actual slash count has reached 30+ (/learn, /freeze, /guard, /codex, /pair-agent, /setup-*, etc.), with the CHANGELOG adding 1-2 a week. The README's "23 + 8" number is also the spot where Garry Tan's marketing tagline increasingly drifts from fact.

2.3. /autoplan — the substance of auto-routing

You don't need to memorize all 23 commands. A single /autoplan automatically decides which review goes to whom:

"Just like at a well-run startup: CEO doesn't have to look at infra bug fixes, design review isn't needed for backend changes. gstack tracks what reviews are run, figures out what's appropriate, and just does the smart thing." — README

/autoplan auto-routes the CEO → design → eng → DX reviews. It decides which reviews are needed based on the affected areas (UI / API·CLI·SDK / architecture, etc.) and surfaces only the taste decisions the user must make, via AskUserQuestion. An entry point you can start from without learning the 23 slashes.

2.4. /qa and the real browser — the actual fuel of the Build phase

gstack's thickest real code sits behind /qa. His own rundown in the README:

"gstack's core real-code feature — the thing that isn't just markdown prompts — is a Playwright-based CLI browser I wrote specifically so I could stop manually black-box testing my stuff. … 2,000+ lines of real systems code (server, CDP inspector, snapshot engine, content security, cookie management)." — ON_THE_LOC_CONTROVERSY.md

What /qa does: it takes a staging URL, spins up a real Chromium, clicks through real user flows, fixes the bugs it finds, and auto-generates a regression test for each fix. By telemetry it's the most-invoked slash (57,650 calls as of 2026-05 — double the next, /plan-eng-review at 28,014).

/open-gstack-browser — spins up its own branded Chromium called GStack Browser. The sidebar extension, anti-bot stealth, and custom branding (menu bar reads "GStack Browser," not "Chrome for Testing") are baked in. It doesn't touch your own Chrome, using a separate profile. Type natural language into the sidebar → a child Claude instance runs in an isolated session → click the screen, screenshot, edit CSS, extract data.

Where this real-browser substance diverges from GSD's analysis of "gstack's empty Build phase" is the subject of §6.4.

2.5. /pair-agent and cross-agent collaboration

A design gstack alone has — sharing the same browser with an AI agent from another vendor. Call /pair-agent and a GStack Browser window opens, printing a setup block to paste into another agent (OpenClaw / Hermes / Codex / Cursor). That agent opens its own tab and operates inside the same browser — with scoped tokens, tab isolation, rate limits, domain restrictions, activity attribution.

"This is the first time AI agents from different vendors can coordinate through a shared browser with real security." — README

With ngrok installed, an agent on another machine can connect too. Same-machine is zero-friction mode (credentials written directly). This mechanism also lets gstack be used as a cross-agent orchestration layer.

2.6. /learn and domain skills — cumulative learning

gstack has two mechanisms that accumulate learning across sessions:

• /learn — accumulates per-project patterns, pitfalls, and preferences as markdown. Searchable, prunable, exportable. His claim: the bigger the codebase gets, the smarter gstack gets about that codebase.
• $B domain-skill save — auto-saves per-site notes from browser automation. E.g., "LinkedIn's Apply button is inside an iframe." It auto-fires on the next visit to the same hostname. Promoted to active after 3 successes, with an option to promote-to-global across projects.

/learn's learning retrieval was reinforced in v1.33.1.0 (2026-05-12) with token-OR query + task-shaped retrieval. Search-accuracy improvements are an area included in the weekly fix-wave.

2.7. GBrain integration — a persistent knowledge base

GBrain is a persistent knowledge base for AI agents, separate from gstack. The coupling with gstack is /setup-gbrain (3 paths: existing Supabase URL / Supabase auto-provisioning / PGLite local) + /sync-gbrain (index the repo's code into gbrain). The most striking design:

"After init, the skill offers to register gbrain as an MCP server for Claude Code so gbrain search, gbrain put_page, etc. show up as first-class typed tools — not bash shell-outs." — README

In other words, gstack doesn't just consume MCP servers — it produces them. /sync-gbrain auto-adds/removes a ## GBrain Search Guidance block in the project CLAUDE.md so the agent prefers gbrain search·code-def·code-refs over Grep. The other two in the category have no MCP-production mechanism.

3. Standout design — "Vibe coding safe"

3.1. AI Slop detection and 0-10 design-dimension scoring

gstack's design-review mechanism scores each design dimension 0-10 and defines what a 10 is. Both /plan-design-review and /design-review use this rubric. It catches the Slop of AI-made mockups (overwrought gradients, inconsistent padding, meaningless emphasis, etc.) via dimensions nailed into definitions.

He's also honest that this rubric is separate from Ben Vinegar's (a Sentry founding engineer) slop-scan (deterministic AI-code-pattern rules). gstack itself once scored a 5.24 on slop-scan — the worst of anything Vinegar measured — and responded by cutting 62% in a single session. By telemetry, bun test passes 2,000+ tests in 1.65s (at v1.34.1).

3.2. The Confusion Protocol — blocking guesses

gstack uses a mechanism called the Confusion Protocol to keep Claude from guessing at architectural decisions. Similar in intent to Superpowers' brainstorming HARD-GATE, but closer to a runtime trigger than an utterance trigger — when an ambiguous command comes in, it surfaces an AskUserQuestion. v1.27.0.0 (2026-05-07) forced a gate-tier AskUserQuestion floor across all plan-* skills, and v1.31.0.0 (2026-05-10) removed the AskUserQuestion fallback (the CHANGELOG calls it "the root cause of the forever war").

3.3. Test-first enforcement — making "vibe coding" not "yolo coding"

"100% test coverage is the goal — tests make vibe coding safe instead of yolo coding." — README

/ship bootstraps a test framework if none exists. Every /qa bug fix generates a regression test. Every /ship run attaches a coverage audit to the PR body. From ~100 tests in 2026-01 to 2,000+ in 2026-05 is gstack's own telemetry. This design meshes with his framing that garbage written confidently by an AI gets caught by a verification loop.

3.4. The prompt-injection defense stack

The defense when the sidebar agent meets a hostile web page:

1. 22MB local ML classifier — scans every page and tool output locally
2. Claude Haiku transcript check — votes on the shape of the whole conversation
3. Canary token — plants a random token in the system prompt and detects exfil attempts in text, tool args, URLs, and file writes
4. Verdict combiner — both classifiers must agree to block (avoiding single-model false positives)
5. Opt-in hardening — GSTACK_SECURITY_ENSEMBLE=deberta for a 721MB DeBERTa-v3 ensemble with 2-of-3 agreement
6. Kill switch — GSTACK_SECURITY_OFF=1

A shield icon in the sidebar header shows status (green/amber/red). The only one of the three with a prompt-injection defense stack. Superpowers/GSD have brainstorming/process gates but no defense against executable external input.

3.5. Continuous checkpoint mode — auto-committing WIP

Enabled via gstack-config set checkpoint_mode continuous, the skills auto-commit during work:

• A WIP: prefix + a structured [gstack-context] body (decisions, remaining work, failed approaches)
• Survives crashes and context switches
• /context-restore reads the commits to reconstruct session state
• /ship filter-squashes to auto-clean the WIP commits, keeping bisect clean
• push is opt-in (checkpoint_push=true) — default is local only, so each WIP commit doesn't trigger CI

This mechanism makes gstack a frame where crash recovery is natural. Same motivation as GSD's .planning/ markdown state, but in gstack the git commit itself is the state.

4. The slash catalog

Beyond the 23 + 8 table in §2.2, there's a standalone CLI shipped since v0.19 (binaries, not slashes):

That the cross-model benchmark sits as a standalone binary makes clear gstack is not a frame locked to Claude alone. The same tool evaluates three models at once.

5. Parallel sprints — pairing with Conductor

gstack's transformative usage pattern is the parallel sprint. Conductor is a tool that spins up multiple Claude Code sessions in isolated worktrees, and the gstack workflow defines the work flow of each of those sessions. His operational claim:

"I regularly run 10-15 parallel sprints — that's the practical max right now." — README

Each session is at its own sprint stage — one in /office-hours on a new idea, one in /review on a PR, one implementing a feature, one in /qa verifying staging, six on other branches. His framing is the crux — without a sprint structure, 10 agents are 10 chaoses — putting process discipline in the spot of the indispensable mechanism.

This is where gstack's position in pairing with operational tools in the category shows. Superpowers/GSD are designs that refine a single session's own cycle. gstack is a tool that, for the person running N sessions at once, unifies each session under the same process. The metaphor of a solo coder running a virtual company hardens into fact here.

That said, 10-15 parallel sprints is a claim from his own environment, and for a general user it presumes a Max plan or above + enough disk space + familiarity running Conductor. The phrase practical max is an honest marker.

6. Where it breaks when run alongside Superpowers/GSD

The points below aren't observed from running them together — they're read off each one's SessionStart hooks, README, definition files, and filed issues, listing only collisions that are structurally inevitable.

The conflict surfaces when all three meta-frames are installed on one machine at once. Each surface comes from a difference in design assumptions.

6.1. SessionStart bootstrap triple-injection

All three plant a bootstrap message in context via a SessionStart hook. The Claude Code official manual:

"All matching hooks run in parallel, and identical handlers are deduplicated automatically. Command hooks are deduplicated by command string and args." — Claude Code docs

Since they're registered as different commands, all three bootstraps inject into context, and the order is nondeterministic. Superpowers' <EXTREMELY_IMPORTANT> block + GSD's gsd-update-banner.js + gstack's team-mode auto-update banner all go in at once, and which went in first determines that session's behavior. Fix: pick one main frame and opt the rest in per-project via .claude/settings.local.json.

6.2. /office-hours vs Superpowers brainstorming — two gates in the same slot

gstack's /office-hours and Superpowers' brainstorming have nearly identical design intent — agreeing on intent, requirements, and design with the user before writing code. The difference:

• Superpowers: auto-trigger (description match). Auto-invoked on a "build me X" utterance. No-exceptions design.
• gstack: user-explicit (the /office-hours slash). It doesn't run unless you explicitly call it.

With both in one environment, Superpowers' auto-trigger preempts gstack's slash decision. Even if the user intended to call /office-hours, Superpowers brainstorming fires first, and the two personas in the same slot (YC Office Hours vs the Superpowers design gate) collide. Fix: disable one of the two triggers. If Superpowers is your main, use gstack mostly for Plan/Review/Test/Ship; if gstack is your main, disable Superpowers' brainstorming description matching in AGENTS.md.

6.3. CLAUDE.md intrusion — only gstack edits the user's policy file

The gstack README install snippet instructs you to add a gstack section to the user's CLAUDE.md:

"Then add a 'gstack' section to CLAUDE.md that says to use the /browse skill from gstack for all web browsing, never use mcp__claude-in-chrome__* tools, and lists the available skills…" — README install snippet

By contrast, GSD doesn't auto-edit CLAUDE.md — it only uses .planning/. Superpowers keeps its instructions in the plugin's own CLAUDE.md and doesn't touch the user's CLAUDE.md.

Result: gstack's instructions stick most stubbornly in the user context. Install all three and gstack's policy is permanently visible to every session of the project, while GSD's/Superpowers' bootstraps only inject at session start. Priorities that differ from the user's intent can emerge, and team-mode auto-update can refresh policy without team consensus — the same surface.

Fix: if you install gstack, review that section yourself. Keeping it in a project-level .claude/CLAUDE.md is better for isolation than global ~/.claude/CLAUDE.md. For org adoption: optional has a lower consensus cost than team-mode required.

6.4. Is "gstack's empty Build phase" exactly true?

The GSD piece framed gstack's empty Build phase as the motivation for coupling. A spot that needs re-checking against the source.

"gstack has an intentional empty space. The workflow goes Think (/office-hours) → Plan (/plan-*-review) → Build → Review (/review) → Ship (/ship), but no slash or skill is defined for the Build phase." — GSD piece §6.5

In the narrow sense it's true — there's no "/build" slash between plan and review. But in the broad sense it's partly true:

• /design-html — converts a mockup to production HTML/CSS. A 30KB Pretext engine. Its code output is shippable.
• /design-shotgun — generates 4-6 mockup variants with GPT Image, picks from a comparison board, learns iteratively.
• /qa — spins up a real browser on a staging URL, fixes bugs directly, and generates regression tests. That is, it writes code.
• /setup-deploy, /setup-gbrain, /setup-browser-cookies — environment-bootstrap code.
• /learn, $B domain-skill save — not code, but treats learning artifacts like accumulating code.

The GSD piece's framing is accurate in that there's no explicit "write-code slash" between plan and review, but the phrasing "gstack's Build phase is empty" invites a misread — design, QA, bootstrap, and learning code fill that slot. Put accurately: "gstack doesn't break code-writing out into a separate slash; the design, QA, and setup commands produce the code." The coupling analysis has to be redone on top of that correction.

6.5. Context separation vs persona switching — a clash of meta-assumptions

GSD's substance is a fresh 200k-context subagent. gstack's is switching only the persona within the same context. When the two assumptions meet in one session:

• Inside the executor GSD dispatched, gstack slashes don't work — because the gstack bootstrap isn't injected into the fresh context. So the GSD subagent can't see gstack's 23 personas.
• Conversely, call GSD's /gsd-execute-phase inside a gstack session and the current gstack context isn't passed to the GSD subagent — the CEO/design/eng reviews accumulated on the plan vanish.

Fix: don't use the two frames in the same sprint. The only thing that works is the layer-sequence separation the external coupling guides agree on — gstack strategy → GSD spec/state → Superpowers build, or the reverse. Concurrent operation collides out of the box.

6.6. Conflict-surface summary

The three frames also share that they barely mention each other in official docs. The coupling discourse is all generated by third parties (Pulumi, Medium, DEV.to). Coupling with no official guide is the user's experiment.

7. Limits and trade-offs

7.1. The honest limits of the LOC claim — what he flagged himself

On the 810× claim covered in §1.2, the items he self-concedes in docs/ON_THE_LOC_CONTROVERSY.md:

• Greenfield vs maintenance — the 2026 figures are new-project-heavy. They don't transfer cleanly to maintaining a 10M-LOC legacy codebase.
• Survivorship bias in the 2013 baseline — a year of low public activity, so the comparison baseline may be set artificially low.
• Quality-adjusted productivity — there's no clean bug-density comparison. There are indirect indicators like a 2.0% revert rate, 6.3% fix rate, and 2,000+ tests, but no direct comparison.
• The meaning of "shipped" differs by era — if 80% are dead in two years, the critique holds.

This self-concession is an honesty only gstack has of the three. Superpowers/GSD don't make a productivity claim at all.

7.2. CLAUDE.md intrusion — a governance concern

Covered in §6.3. Team-mode required delegates to gstack the authority to refresh policy every hour without team consensus. An org with security/compliance awareness should isolate it as optional, not required and project-level, not global.

7.3. Bun/Chromium dependency

gstack's real-code core depends on Bun and Playwright Chromium. In Python environments and declarative environments like nix, the dependency is heavy. On certain harnesses (Codex, OpenCode, Cursor, etc.) some commands fail with no fallback in cloud IDEs that lack bun. After v1.31.0.0 removed the AskUserQuestion fallback, a harness primitive is partly filling this slot.

7.4. Learning curve — /autoplan sits above the 23 commands

The 23+ slashes are a burden to learn. The design where the README's install snippet force-registers every slash as a catalog is also a context burden for first-time users. The v1.29–v1.34 fix-waves spend most of their effort on making the commands simple again — learning retrieval, the AskUserQuestion floor, plan-tune — building the relief levers in step with the growing catalog. To get started, a single /autoplan is enough.

7.5. A byproduct as a YC recruiting lure

A "We're hiring. Come work at YC" block is planted at the bottom of the README. gstack is an open-source tool and a YC Software recruiting lure at once. That itself isn't a problem — but the fact that Garry Tan's incentives span the two axes of channel-pure tool-maker and VC-fund recruiter at once is a signal to read part of the marketing tone and self-presentation critically. 810× productivity is both a technical claim and a narrative for the VC funnel.

7.6. Fix-wave dependency — a v1.x.x.0 ships every week

The CHANGELOG shows 10 versions in 11 days, from v1.25 (2026-05-02) to v1.34 (2026-05-13). Every week a fix wave batch-merges community PRs. Stability swings with what goes into the batch. A regression like v1.33.2.0's (2026-05-12) Conductor worktree pollution gets caught in the next version. To harden it for long-running production, it's safer to stay one beat behind the fix-wave.

8. Synthesis — gstack is the framework of "role division"

In three lines:

1. Neither a process opinion nor an environment opinion — a role opinion. Superpowers enforces how to work, GSD enforces where to work. gstack enforces who works — a single coder cycling through 23 people. Of the three in the category, the most explicit role metaphor.
2. It has the thickest real code of the three. A Playwright server, a Pretext engine, a local ML classifier, gbrain MCP integration. More than a bundle of markdown prompts. The largest engineering investment in the category.
3. The CLAUDE.md intrusion is strong. Uniquely of the three, it edits the user's policy file and makes team-mode auto-update the default. A governance-aware user is safer with project-level isolation.

Operational takeaway: for a cycle where one person drives a product all the way (design system → mockup → HTML → QA → ship → canary), gstack is the most fitting of the three. For uses that need only pure code discipline or context separation, Superpowers/GSD solo are lighter. When run alongside Superpowers/GSD: you hit the 5 conflict surfaces in §6 — especially the /office-hours vs brainstorming same slot, the CLAUDE.md intrusion, and the orthogonal context model. Only the layer-sequence separation the three external analyses agree on (gstack strategy → GSD spec → Superpowers build) works.

One-line recommendation — if you want to code as if running a product company solo, turn gstack on. The very fact that Garry Tan opened his own setup instead of selling it is part of the category moment — a YC President throwing his own tool straight onto GitHub is a signal of the simultaneous meta-frame explosion of Q1 2026. If the catalog of 23 slashes is a burden, just start with a single /autoplan. For org adoption, isolate it as optional over required and project-level over global. Since it's the tool most faithful to the organizational metaphor of the three, if the metaphor of a solo coder running a virtual company resonates, that's exactly where it works best.

References

Official, first-party

• garrytan/gstack — v1.34.1.0 stable, 95.9k★ (as of 2026-05-13)
• README.md — install snippet · 23+8 catalog · sprint sequence
• ETHOS.md — 6 principles (Boil the Lake · Search Before Building · User Sovereignty, etc.)
• CHANGELOG.md — v1.25 → v1.34 fix-wave timeline
• docs/ON_THE_LOC_CONTROVERSY.md — the self-concession on the 810× claim
• docs/skills.md — a deep dive per skill
• docs/domain-skills.md — the $B domain-skill save mechanism
• USING_GBRAIN_WITH_GSTACK.md — gstack ↔ gbrain MCP integration
• garrytan/gbrain — the persistent knowledge base (separate repo)

External comparison/coupling analyses

• Pulumi — Superpowers, GSD, GSTACK: Picking the Right Framework — Diri, 2026-04-13
• Medium — What Each Claude Code Framework Actually Constrains — Mak, 2026-04-06
• DEV — A Claude Code Skills Stack: Combine Without the Chaos — Chen, 2026-04-06

Creator narrative

• Andrej Karpathy, No Priors podcast, 2026-03 — "I don't think I've typed like a line of code probably since December"
• Peter Steinberger / OpenClaw — 247K★, effectively a solo build
• Ben Vinegar / slop-scan — the tool that measured gstack at 5.24 → a 62% cut
• Garry Tan — Twitter / X

Other pieces in the series

• Agent Framework category overview — where the three frames Superpowers · GSD · gstack stand
• Superpowers — the process-gate axis
• GSD — the context-separation axis