gstack: Y Combinator CEO's Claude Code Setup (23K Stars)

TL;DR

gstack is Y Combinator CEO Garry Tan’s open-source Claude Code setup that turns AI into a virtual engineering team. Key highlights:

23K+ GitHub stars in less than two weeks since March 12, 2026
28 slash-command skills covering CEO review, engineering, design, QA, security, and shipping
Process, not tools — follows Think → Plan → Build → Review → Test → Ship → Reflect
MIT licensed — free, no premium tier, no waitlist
Cross-agent support — works with Claude Code, OpenAI Codex, and other agents supporting the SKILL.md standard
Covered by TechCrunch, Product Hunt trending, and debated intensely across Reddit and HN

Install with one paste in Claude Code:

Install gstack: run git clone https://github.com/garrytan/gstack.git 
~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup

What is gstack?

gstack is not a new model or a secret technique. It’s a collection of opinionated Claude Code “skills” — reusable prompts stored in SKILL.md files that instruct the AI how to behave in specific roles. Think of it as prompt engineering packaged as a development workflow.

The core idea: instead of treating Claude Code as a single assistant, gstack gives it multiple specialist roles — CEO, eng manager, designer, code reviewer, QA lead, security officer, release engineer — each triggered by a slash command.

What makes it interesting isn’t the individual prompts. It’s the structured process that connects them:

/office-hours → /plan-ceo-review → /plan-eng-review → Build → /review → /qa → /ship

Each skill feeds into the next. The office hours session writes a design doc that the CEO review reads. The eng review writes a test plan that QA picks up. The code review catches bugs that ship verifies are fixed. Nothing falls through because every step knows what came before.

Who Built This and Why

Garry Tan is the President and CEO of Y Combinator. Before that, he was one of the first eng/PM/designers at Palantir, cofounded Posterous (acquired by Twitter), and built Bookface, YC’s internal social network.

He claims gstack lets him ship 10,000-20,000 lines of production code per day, part-time, while running YC full-time. In his last /retro across 3 projects: 140,751 lines added, 362 commits, ~115K net lines in one week.

At SXSW on March 14, 2026, Tan told Bill Gurley he’s barely sleeping because he’s so excited about AI coding:

“I have cyber psychosis, but I think a third of the CEOs that I know have it as well.”

He shared his setup on GitHub two days before that interview, and it exploded.

The 28 Skills: Your Virtual Engineering Team

gstack’s skills break down into three categories: specialists (role-playing experts), power tools (utility commands), and safety guardrails.

Specialist Skills

Skill	Role	What It Does
`/office-hours`	YC Office Hours	Six forcing questions that reframe your product before writing code. Pushes back on framing, challenges premises
`/plan-ceo-review`	CEO / Founder	Rethinks the problem. Four modes: Expansion, Selective Expansion, Hold Scope, Reduction
`/plan-eng-review`	Eng Manager	Locks architecture with ASCII diagrams, data flow, edge cases, test matrices
`/plan-design-review`	Senior Designer	Rates each design dimension 0-10, explains what a 10 looks like, detects “AI slop”
`/design-consultation`	Design Partner	Builds a complete design system from scratch with competitive research
`/review`	Staff Engineer	Finds bugs that pass CI but break in production. Auto-fixes obvious issues
`/investigate`	Debugger	Systematic root-cause debugging. Iron law: no fixes without investigation
`/design-review`	Designer Who Codes	Audits design then fixes issues with atomic commits
`/qa`	QA Lead	Tests your app in a real browser, finds bugs, fixes them, re-verifies
`/qa-only`	QA Reporter	Same methodology as /qa but report only — no code changes
`/cso`	Chief Security Officer	OWASP Top 10 + STRIDE threat model with exploit scenarios
`/ship`	Release Engineer	Syncs main, runs tests, audits coverage, opens PR
`/land-and-deploy`	Release Engineer	Merges PR, waits for CI, verifies production health
`/canary`	SRE	Post-deploy monitoring for console errors and performance regressions
`/benchmark`	Performance Engineer	Baselines page load times and Core Web Vitals
`/document-release`	Technical Writer	Updates all project docs to match what shipped
`/retro`	Eng Manager	Team-aware weekly retro with per-person breakdowns and shipping streaks
`/autoplan`	Review Pipeline	Runs CEO → design → eng review automatically in one command

Power Tools

Skill	Purpose
`/browse`	Real Chromium browser automation (~100ms per command)
`/setup-browser-cookies`	Import cookies from Chrome/Arc/Brave/Edge for authenticated testing
`/codex`	Second opinion from OpenAI Codex CLI (cross-model analysis)
`/setup-deploy`	One-time deploy configuration
`/gstack-upgrade`	Self-updater

Safety Guardrails

Skill	Purpose
`/careful`	Warns before destructive commands (rm -rf, DROP TABLE, force-push)
`/freeze`	Restricts file edits to one directory
`/guard`	/careful + /freeze combined for maximum safety
`/unfreeze`	Removes the freeze boundary

How a gstack Session Actually Works

Here’s a real workflow example from the README that shows how skills chain together:

Step 1: Define the problem

You: I want to build a daily briefing app for my calendar.
You: /office-hours

Claude doesn’t just build what you asked for. It pushes back:

“I’m going to push back on the framing. You said ‘daily briefing app.’ But what you actually described is a personal chief of staff AI.”

It extracts 5 capabilities you didn’t realize you were describing, challenges 4 premises, and generates 3 implementation approaches.

Step 2: CEO review

You: /plan-ceo-review

Reads the design doc from office-hours, challenges scope, runs a 10-section review.

Step 3: Engineering review

You: /plan-eng-review

ASCII diagrams for data flow, state machines, error paths. Test matrix, failure modes, security concerns.

Step 4: Build

You: Approve plan. Exit plan mode.

Writes 2,400 lines across 11 files in ~8 minutes.

Step 5: Code review

You: /review

Auto-fixes 2 issues, flags a race condition for your approval.

Step 6: QA

You: /qa https://staging.myapp.com

Opens a real browser, clicks through flows, finds and fixes a bug.

Step 7: Ship

You: /ship

Tests: 42 → 51 (+9 new). PR opened. Done.

Seven commands. End to end. That’s the pitch.

The Controversy

gstack didn’t just get love. It got a lot of hate, and the debate reveals interesting fault lines in the developer community.

The “God Mode” Tweet

Shortly after releasing gstack, Tan posted that a CTO friend called it “god mode” after it instantly found a security flaw. The internet did not take this well.

One founder responded: “Garry should be embarrassed for tweeting this. If it’s true, that CTO should be fired immediately.”

Vlogger Mo Bitar released a video called “AI is making CEOs delusional,” pointing out that gstack is essentially “a bunch of prompts in text files.”

The Actual Criticism

The serious critiques boil down to:

“It’s just prompts” — Experienced Claude Code users already have their own versions of these role-based skills. gstack packages what many developers do independently.
“Lines of code isn’t a metric” — Tan’s claim of 10-20K lines per day sounds impressive but says nothing about code quality, maintainability, or business value. As one Reddit commenter put it: “10K LOC/day is a red flag, not a feature.”
“Overengineered” — Some developers find the 28-skill setup more process than they need. A common reaction on r/ClaudeCode: “It’s a little overengineered for what it is.”
“Celebrity effect” — Would this have 23K stars if anyone other than the YC CEO released it? The Hacker News thread split between “this is genius” and “this is cargo culting with extra steps.”

The Defense

Supporters counter:

“The value IS the packaging” — Most developers don’t have structured, reproducible AI workflows. gstack provides a ready-made process that beginners can use immediately.
“Process matters more than prompts” — The chaining of skills (plan → build → review → test → ship) is what makes it work. Individual prompts are commodity; workflow is not.
“It’s free and open source” — You can fork it, modify it, or ignore what you don’t need. No subscription, no lock-in.
“The retro data is real” — Tan’s commit history shows measurably increased output. Whether that output is valuable is a different question, but the productivity claim is backed by data.

Installation and Setup

For Claude Code (30 seconds)

Open Claude Code and paste:

git clone https://github.com/garrytan/gstack.git ~/.claude/skills/gstack
cd ~/.claude/skills/gstack && ./setup

The setup script installs all skills as slash commands. Add a gstack section to your project’s CLAUDE.md to make it available to teammates.

For OpenAI Codex

# Per-repo install
git clone https://github.com/garrytan/gstack.git .agents/skills/gstack
cd .agents/skills/gstack && ./setup --host codex

# Global install
git clone https://github.com/garrytan/gstack.git ~/gstack
cd ~/gstack && ./setup --host codex

Auto-detect (any supported agent)

git clone https://github.com/garrytan/gstack.git ~/gstack
cd ~/gstack && ./setup --host auto

Requirements

Claude Code (or compatible agent)
Git
Bun v1.0+
Node.js (Windows only)

gstack vs Rolling Your Own Skills

Aspect	gstack	DIY Skills
Setup time	30 seconds	Hours to days
Process structure	Built-in sprint workflow	You design your own
Skill count	28 ready-to-use	Whatever you build
Cross-model	Claude Code + Codex	Usually one platform
Updates	`/gstack-upgrade`	Manual maintenance
Community	23K stars, active development	Solo maintenance
Customization	Fork and modify	Full control
Opinionatedness	High (by design)	Your call

Parallel Execution with Conductor

gstack gets more powerful with parallelism. Conductor runs multiple Claude Code sessions simultaneously — one on /office-hours, another on /review, a third implementing features, a fourth running /qa.

The structured process is what makes parallelism work. Without it, ten agents is ten sources of chaos. With gstack’s sprint workflow, each agent knows exactly what to do and when to stop.

Honest Take: Should You Use gstack?

Use it if:

You’re new to Claude Code and want structure instead of a blank prompt
You’re a technical founder who ships code alongside other responsibilities
You want a reproducible workflow for AI-assisted development
You lead a team and want standardized AI coding practices

Skip it if:

You already have a mature personal workflow with Claude Code — gstack may feel restrictive
You prefer minimal tooling — 28 skills is a lot to learn
You’re looking for magical productivity gains — the prompts are good, but they’re prompts
You’re not using Claude Code at all — this is deeply integrated with the SKILL.md standard

The real question:

Is gstack revolutionary? No. It’s a well-packaged set of prompts and processes by someone with deep product experience.

Is it useful? Yes — especially for people who haven’t built their own AI coding workflow yet. The structured sprint process (Think → Plan → Build → Review → Test → Ship → Reflect) is genuinely valuable, regardless of what you think about the hype.

Is the controversy overblown? Also yes. It’s free, open source software. Try it, take what works, discard the rest.

Key Stats

Metric	Value
GitHub Stars	23,000+
Forks	2,200+
Skills	28 slash commands
License	MIT
Created	March 12, 2026
Author	Garry Tan (YC CEO)
Agents	Claude Code, Codex, SKILL.md-compatible
Tan’s claimed output	10-20K lines/day
Telemetry	Opt-in, off by default

FAQ

Is gstack free?

Yes. MIT license, no premium tier, no waitlist, no subscription.

Does it work with agents besides Claude Code?

Yes. gstack supports any agent using the SKILL.md standard, including OpenAI Codex. Use ./setup --host codex or ./setup --host auto for auto-detection.

Will gstack make me 10x more productive?

It depends on your baseline. If you’re new to AI coding, the structured workflow will help significantly. If you’re already an experienced Claude Code user with your own skills, the marginal improvement will be smaller.

Is gstack just “a bunch of prompts”?

Technically, yes — all Claude Code skills are prompts in Markdown files. But the value is in the process structure: how skills chain together and feed information downstream. Many developers have individual prompts but lack a structured workflow.

Is Garry Tan’s 10-20K lines/day claim believable?

The commit history is public and verifiable. Whether 10-20K lines per day represents meaningful productivity or inflated metrics from AI-generated code is the real debate. Lines of code has always been a controversial metric.

Can I customize gstack?

Yes. Fork the repo, modify any SKILL.md file, remove skills you don’t want, add your own. The MIT license allows full modification.