gstack

Claude Code's Software Factory — 21 Skills for Structured AI Development

by Garry Tan (Y Combinator CEO) • MIT Licensed • Open Source

agent37.club

Who is Garry Tan?

  • President & CEO of Y Combinator since 2023
  • Early engineer at Palantir — designed their logo, served as PM/designer
  • Co-founded Posterous (acquired by Twitter)
  • Built Bookface — YC's internal social network (2013)
  • Managing Partner at Initialized Capital — early Coinbase, Instacart, Flexport

The Claim

600K

lines of production code in 60 days — while running YC full-time.

1,237+ GitHub contributions in 2026 vs. 772 building Bookface in 2013.

What is gstack?

A skill library that turns Claude Code into a structured engineering team

  • 21 slash commands organized around a sprint workflow
  • Each skill is a SKILL.md file — pure Markdown, no proprietary platform
  • Skills feed sequentially: upstream outputs become downstream context
  • Works across Claude Code, Codex, Gemini CLI, Cursor
# Installation (30 seconds)
git clone https://github.com/garrytan/gstack.git \
  ~/.claude/skills/gstack
cd ~/.claude/skills/gstack && ./setup

# Lives in .claude/skills/
# No PATH changes, no daemons
# Just Markdown + Bash/TS

Architecture: The Sprint Pipeline

Think → Plan → Build → Review → Test → Ship → Reflect

Think/office-hours, /design-consultation
Plan/plan-ceo-review, /plan-eng-review, /plan-design-review
BuildClaude Code (direct implementation)
Review/review, /design-review, /investigate
Test/qa, /qa-only, /browse
Ship/ship, /document-release
Reflect/retro

Each phase produces artifacts (design docs, test plans, review findings) that become context for the next phase. No information silos.

Think Phase: /office-hours

Problem reframing before a single line of code

Challenges your assumptions through six forcing questions:

  • What problem are you actually solving?
  • Who is the user and what do they really need?
  • What are the hidden capabilities this implies?
  • What is the simplest version that proves the concept?
  • What could go wrong at scale?
  • What are three radically different approaches?
# You say:
"Build me a daily briefing app"

# /office-hours reframes as:
"Personal chief of staff AI"
  + 5 hidden capabilities
  + 3 implementation approaches
  + risk matrix
  + scope boundaries

Design Consultation

/design-consultation researches competitive landscape, proposes creative risks, and generates realistic mockups.

Plan Phase: Three Review Lenses

/plan-ceo-review

Founder perspective: scope management, strategic alignment, four operational modes for different project sizes.

/plan-eng-review

Architecture diagrams, data-flow analysis, edge case enumeration, dependency mapping, and test matrix generation.

/plan-design-review

Design system audit with 0-10 ratings on consistency, accessibility, and specific improvement targets.

Sequential Knowledge Flow

Each review reads artifacts from prior reviews. The eng review reads the CEO scope decisions. The design review reads the architecture constraints.

This is the key architectural insight: skills are not independent — they form a directed acyclic graph of context.

Smart Routing

Not every change needs every review. Infrastructure fixes skip CEO review. Backend changes skip design review. The system tracks which reviews have run.

Review Phase: Staff-Level Code Review

/review — production-grade bug detection

  • Auto-fixes obvious issues — typos, missing imports, formatting
  • Flags complex issues for human approval — race conditions, security concerns
  • Produces structured findings with severity levels
  • Findings feed into downstream /qa and /ship

/investigate

  • Systematic debugging with hypothesis testing
  • Root-cause analysis, not just symptom fixing
  • Generates a hypothesis tree and tests each branch

/design-review

  • Audits design implementation vs. design system
  • Produces atomic commits — one fix per commit
  • Checks spacing, typography, color consistency, responsive behavior
# Review output example:
SEVERITY: HIGH
TYPE: Race condition
FILE: src/briefing/fetch.ts:47
ISSUE: Concurrent calendar fetches
       can corrupt shared state
FIX: Requires human approval

Test Phase: Real Browser Testing

/qa, /qa-only, and /browse

/qa

  • Opens a real Chromium browser via Playwright
  • ~100ms latency per browser command
  • Finds bugs, fixes them, auto-generates regression tests
  • Every bug fix produces a corresponding test

/qa-only

  • Bug reporting without code changes
  • Useful for QA passes before release

/browse

  • Direct Chromium control for interactive testing
  • Handles CAPTCHAs with $B handoff / $B resume
  • Preserves cookies and tab state across handoffs
# Auth flow for testing
/setup-browser-cookies
# Imports sessions from:
#   Chrome, Arc, Brave, Edge

# When agent hits a wall:
$B handoff  # opens visible Chrome
# human solves CAPTCHA
$B resume   # agent continues

Ship Phase: Automated Release

/ship — the final gate

  • Syncs branch with upstream
  • Runs full test suite
  • Coverage audit — reports gaps, generates missing tests
  • Bootstraps test framework if project has none
  • Creates pull request with structured description
  • Test count tracked: e.g., 42 → 51 tests per sprint

/document-release

  • Reads all project docs, cross-references diffs
  • Updates READMEs, ARCHITECTURE, CONTRIBUTING files
  • Runs automatically on every /ship

Test Coverage Philosophy

The goal is 100% coverage as a safety mechanism. Every /qa bug fix auto-generates a regression test. Every /ship produces a coverage audit.

If no test framework exists, /ship bootstraps one before the first run.

# /ship output
SYNC:    main ← feature/briefing
TESTS:   51 passed, 0 failed
COVER:   87% (+6% this sprint)
PR:      #142 created
DOCS:    README.md updated

Safety & Governance

Speed without guardrails is dangerous

CommandProtection
/carefulWarns before rm -rf, DROP TABLE, force-push
/freezeRestricts edits to one directory during debug
/guardCombines /careful + /freeze
/unfreezeRemoves edit restrictions
/codexSecond opinion from OpenAI Codex CLI

Review Readiness Dashboard

Before shipping, the system shows which reviews have been completed and which are missing. CEO review is not needed for infra fixes. Design review skips backend changes.

Cross-Model Verification

/codex sends code to OpenAI's Codex for independent review — a second pair of AI eyes from a different model family.

Parallelization: 10-15 Agents at Once

The Conductor pattern for massive throughput

Each Claude Code session runs an independent sprint on a separate branch. The Conductor orchestrates:

  • Session 1: /office-hours on a new feature idea
  • Session 2: /review on an open PR
  • Session 3: Feature implementation on feature/auth
  • Session 4: /qa on staging environment
  • Sessions 5-15: Six more branches in parallel

Why It Works

"Without a process, ten agents is chaos. With a process — think, plan, build, review, test, ship — each agent knows exactly what to do."

Solo dev
~500 LOC/day
1 agent
~2K LOC/day
gstack parallel
10-20K LOC/day

Technical Implementation

How skills actually work under the hood

Runtime

  • Bun v1.0+ as primary runtime
  • Node.js fallback on Windows
  • Playwright-driven Chromium for browser skills
  • All skills live in .claude/skills/

Skill Format

  • Each skill is a SKILL.md file
  • Pure Markdown with structured prompts
  • Loaded as slash commands in Claude Code
  • No proprietary DSL — portable across platforms
# File structure
~/.claude/skills/gstack/
  setup              # install script
  skills/
    office-hours/
      SKILL.md       # the prompt
    review/
      SKILL.md
    qa/
      SKILL.md
      browser.ts    # Playwright
    ship/
      SKILL.md
    careful/
      SKILL.md
    ... 21 skills total

Zero Infrastructure

No PATH modifications, no background services, no config files outside .claude/. Git clone + setup = done.

Knowledge Flow: The Artifact DAG

How upstream decisions flow to downstream skills

/office-hours
  |
  +--> design_doc.md          # product requirements, user stories
  |
  v
/plan-ceo-review                  # reads design_doc.md
  |
  +--> scope_decisions.md     # what's in/out of scope
  |
  v
/plan-eng-review                  # reads design_doc + scope_decisions
  |
  +--> architecture.md        # data flow, edge cases, test matrix
  |
  v
Claude Code (build)               # reads all upstream artifacts
  |
  v
/review --> /qa --> /ship    # each reads prior findings

Why This Matters

Traditional AI coding is stateless — each prompt starts from scratch. gstack's artifact chain creates persistent context across the entire development lifecycle. The reviewer knows what the architect intended. The QA system knows what the reviewer flagged.

Privacy & Telemetry

Opt-in only, minimal data, local-first

  • Telemetry is off by default
  • First run asks for explicit consent
  • If enabled, collects only: skill name, duration, success/fail, gstack version, OS
  • Never collected: code, file paths, repo names, prompts, credentials
# Disable telemetry
gstack-config set telemetry off

# Local-only analytics dashboard
gstack-analytics
# No remote calls, all local data

Backend

Supabase for opt-in telemetry. Open source stack end-to-end. No vendor lock-in.

Data PointCollected?
Skill name & durationOpt-in
Success / fail statusOpt-in
OS & gstack versionOpt-in
Source codeNever
File paths / repo namesNever
Prompts / credentialsNever

Full Walkthrough: Daily Briefing App

From idea to shipped PR in ~30 minutes

/office-hours — Reframes "daily briefing app" as "personal chief of staff AI" with 5 hidden capabilities and 3 approaches
/plan-ceo-review — Scopes to MVP: calendar integration + AI summary
/plan-eng-review — Architecture diagrams, API contracts, test matrix
Build — 2,400 lines across 11 files in ~8 minutes
/review — Auto-fixes 2 issues, flags 1 race condition (needs human approval)
/qa — Opens staging in Chromium, finds and fixes 1 visual bug
/ship — Tests go from 42 to 51, PR #142 created, README updated

How gstack Compares

Feature Raw Claude Code Cursor / Copilot gstack
Structured workflow None None 7-phase sprint
Code review Manual prompting Basic suggestions Staff-level with auto-fix
Browser testing None None Real Chromium via Playwright
Safety guardrails Permission prompts Sandboxed /careful + /freeze + /guard
Parallelization Manual Single session 10-15 concurrent sprints
Cross-model review None None /codex (OpenAI second opinion)
Platform lock-in Anthropic only Vendor-specific Markdown, works everywhere

Design-First Development

Design decisions flow through the whole system

Unlike most AI coding tools, gstack embeds design at every phase:

  • /design-consultation — Researches competitive landscape, proposes creative risks, generates mockups
  • /plan-design-review — Audits design quality on a 0-10 scale
  • /design-review — Verifies implementation matches the design system

Design artifacts persist through the pipeline. The engineer sees the designer's intent. The reviewer checks against the design spec.

Garry Tan's Background

This design-first approach makes sense given Tan's history: he was a designer-engineer hybrid at Palantir, not just a coder. gstack reflects the view that design and engineering should be tightly coupled, not siloed.

# Design review output
SCORE: 7/10
SPACING: Consistent
TYPOGRAPHY: 2 mismatches found
COLOR: On-brand
RESPONSIVE: Breaks at 480px
FIXES: 3 atomic commits generated

Reflect Phase: /retro

Weekly analytics and team-aware retrospectives

  • Per-person contribution breakdowns
  • Test health trends over time
  • Sprint velocity tracking
  • Identifies recurring patterns (same file breaking, same type of bug)
  • Suggests process improvements for next sprint

Closing the Loop

The retro phase feeds insights back into future /office-hours and /plan-* sessions, creating a continuous improvement cycle.

# /retro output (weekly)
SPRINT: Week 12
FEATURES: 8 shipped
BUGS FOUND: 14 (12 auto-fixed)
TEST DELTA: +47 tests
COVERAGE: 82% → 91%

PATTERNS:
  auth/session.ts broke 3x
  → Recommend: add integration test

VELOCITY:
  Week 10: 4,200 LOC
  Week 11: 8,100 LOC
  Week 12: 12,400 LOC

The SKILL.md Standard

Why Markdown is the right abstraction

  • Skills are just Markdown files — no compiled code, no binary blobs
  • Readable by humans, executable by AI agents
  • Version-controlled with git like any other code
  • Portable: same file works in Claude Code, Codex, Gemini CLI, Cursor
  • Composable: skills can reference other skills' outputs

No Proprietary Platform

gstack avoids the trap of building a walled garden. If Claude Code disappears tomorrow, the SKILL.md files still work with any agent that reads Markdown.

# Example: SKILL.md structure
---
name: review
description: Staff-level code review
triggers: /review
---

# Code Review Skill

## Context
You are a staff engineer conducting
a production code review...

## Steps
1. Read all changed files
2. Check for: security, perf, logic
3. Auto-fix obvious issues
4. Flag complex issues for human...

## Output Format
SEVERITY: HIGH/MED/LOW
TYPE: bug/security/perf
...

Installation & Team Setup

Personal Install (30 seconds)

# Clone to global skills directory
git clone https://github.com/garrytan/gstack.git \
  ~/.claude/skills/gstack

# Run setup
cd ~/.claude/skills/gstack && ./setup

Team / Per-Project Install

# Copy into project repo
cp -Rf ~/.claude/skills/gstack \
  .claude/skills/gstack

# Remove git history
rm -rf .claude/skills/gstack/.git

# Setup within project
cd .claude/skills/gstack && ./setup

Requirements

DependencyVersion
Claude CodeLatest
GitAny
Bunv1.0+
Node.jsWindows only

Self-Updating

/gstack-upgrade pulls the latest version from GitHub. No manual update process needed.

Complete Skill Reference

All 21 slash commands at a glance

PhaseSkillPurpose
Think/office-hoursProblem reframing
Think/design-consultationDesign system gen
Plan/plan-ceo-reviewScope management
Plan/plan-eng-reviewArchitecture
Plan/plan-design-reviewDesign audit
Review/reviewCode review + auto-fix
Review/design-reviewDesign impl audit
Review/investigateRoot-cause debugging
PhaseSkillPurpose
Test/qaBrowser test + fix
Test/qa-onlyBug report only
Test/browseDirect browser control
Ship/shipTest + PR + docs
Ship/document-releaseAuto-update docs
Reflect/retroWeekly analytics
Safety/carefulDestructive cmd guard
Safety/freezeEdit lock
Safety/guardcareful + freeze
Util/unfreezeRemove lock
Util/codexOpenAI second opinion
Util/setup-browser-cookiesAuth import
Util/gstack-upgradeSelf-update

Implications: The Solo Developer at Scale

"One person shipping at the scale that used to require a team of twenty."

If the productivity claims hold, gstack represents a structural shift in how software gets built:

  • Small teams can compete with large engineering orgs
  • The bottleneck shifts from writing code to defining requirements
  • Process and structure become the differentiator, not headcount
  • Open source means this is accessible to everyone, not just well-funded teams

Skepticism Worth Having

  • 600K lines in 60 days — how much is boilerplate vs. novel logic?
  • LOC is a famously misleading metric
  • Long-term maintainability of AI-generated code is unproven
  • Works best for greenfield — legacy codebases are harder

YC Context

YC is actively hiring engineers for AI-assisted development. gstack is both a tool and a recruiting signal.

Getting Started: Your First Sprint

Step 1: Install gstack
git clone https://github.com/garrytan/gstack.git ~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup
Step 2: Start with /office-hours
Describe your feature idea. Let it challenge your assumptions and reframe the problem.
Step 3: Run /plan-eng-review
Get architecture, data flow, and test matrix before writing code.
Step 4: Build, then /review
Let Claude Code write the code, then run a staff-level review.
Step 5: /qa your staging URL
Real browser testing with automatic bug fixes and regression tests.
Step 6: /ship
Tests, coverage audit, PR creation, documentation updates — all automated.

Key Takeaways

1. Process is the Product

gstack's value is not any single skill — it is the structured pipeline that makes AI agents predictable and safe at scale.

2. Artifacts Create Memory

The sequential knowledge flow (design docs to scope to architecture to code to review) solves the statelessness problem of AI coding.

3. Safety Enables Speed

Review gates, /careful, /freeze, and automatic test generation make it safe to move fast with multiple parallel agents.

4. Open Standards Win

SKILL.md as pure Markdown means no vendor lock-in. The skills are portable across Claude Code, Codex, Gemini, and Cursor.

"Without a process, ten agents is chaos.
With a process, each agent knows exactly what to do."

MIT Licensed • Free • Open Source • 21 Skills

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

agent37.club