Garry Tan's gstack: AI Engineering Workflow Where One Developer Equals a 20-Person Team

One Developer Like a Twenty-Person Team? I Deep-Dived Into Garry Tan's gstack

This morning, while browsing GitHub Trending, I stumbled upon gstack. My first reaction: another AI coding tool? But when I saw the founder is Y Combinator's current CEO Garry Tan, and the README opened with Karpathy's quote "I probably haven't typed a single line of code since last December," I decided to take a closer look.

What Problem Does This Project Actually Solve

Honestly, after years of backend development, I've seen countless "AI-assisted programming" tools. Most are either simple code completion or a chatbox for asking questions. But gstack is different—it doesn't just help you write code; it simulates an entire engineering team's workflow.

Garry Tan provides an intuitive metric in the README: his code output efficiency in 2026 is 810x what it was in 2013 (calculated by logical lines of code). This isn't about AI writing more code—it's about the volume of work one person can complete undergoing a qualitative shift. The core issue: traditional development requires multiple roles collaborating from product conception to launch—PMs defining requirements, architects designing solutions, engineers implementing, QA testing, security review, and release management. gstack AI-ifies all these roles into 23 specialized slash commands.

Architecture Design: Why 23 Tools Instead of One Big Model

After carefully reviewing the skill list in the README, I discovered an interesting design philosophy: each tool has clear boundaries and responsibilities. This contrasts sharply with the current "one model handles everything" approach.

## Product Phase
/office-hours      # YC-style product interrogation, 6 mandatory questions to refine requirements
/plan-ceo-review   # CEO perspective review, 4 scope modes (expand/contract/maintain/cut)
/plan-design-review # Designer review, 0-10 scoring on each dimension

## Development Phase  
/plan-eng-review   # Engineering manager locks architecture, data flow diagrams, state machines, edge cases
/review            # Senior engineer code review, automatically fixes obvious issues
/cso               # Chief Security Officer, OWASP Top 10 + STRIDE threat modeling

## Testing & Deployment
/qa                # QA lead, real browser testing, discovers and fixes bugs
/ship              # Release engineer, sync branches, run tests, submit PR
/land-and-deploy   # Merge PR, wait for CI, verify production environment

What's the benefit of this design? From my real-world experience: when you ask a general-purpose model "help me build a feature," it often skips requirements analysis and jumps straight to coding. But gstack forces you to follow the process—first /office-hours to clarify pain points, then /plan-ceo-review to confirm scope, before entering development. This is essentially enforcing engineering discipline through tooling.

Tech Stack Analysis: TypeScript + Claude Code Ecosystem

From a technology selection perspective, gstack is built on several key components:

1. Claude Code: Core execution engine—all skills are triggered via slash commands initiating Claude Code sessions
2. TypeScript/Bun: The toolchain itself is written in TS, with Bun as the runtime (better performance)
3. Playwright: Browser automation for /qa, /browse, and other scenarios requiring real UI testing
4. Multi-Agent Support: Beyond Claude Code, supports 10+ AI coding assistants including Cursor, OpenCode, Factory Droid

## 30-second installation command
git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/.claude/skills/gstack \
  && cd ~/.claude/skills/gstack && ./setup

The installation logic is straightforward: clone the repo to ~/.claude/skills/gstack, then run the setup script. Setup does several things:

• Creates symlinks for each skill under ~/.claude/skills/
• Modifies CLAUDE.md to add gstack configuration section
• Detects installed AI assistants and auto-configures corresponding paths

In team mode, it also adds a .claude/ directory with required or optional markers to ensure team members automatically sync the latest version.

Several Features That Blew My Mind

1. Design-Development Loop: /design-shotgun → /design-html

This workflow solves the problem of AI-generated UIs that "look good but don't work." /design-shotgun generates 4-6 design variants displayed side-by-side in the browser, where you can provide real-time feedback like "more whitespace" or "bold the title," and it iterates. Once selected, /design-html uses the Pretext engine to generate truly responsive HTML/CSS—text reflows, heights adapt, layouts are dynamic, not fixed-pixel demos.

2. Real Browser Testing: /qa

This is the feature I find most valuable. It doesn't simulate clicks—it launches a real Chromium browser, opens your staging environment, walks through test flows, discovers bugs, fixes them directly, and generates regression tests. Garry says this feature let him scale from 6 parallel sprints to 12—because the agent truly has "eyes" now.

## Complete QA workflow
/qa https://staging.myapp.com
## Output: Open browser → Click key flows → Discover Race Condition → Submit fix → Re-verify → Generate regression test

3. Cross-Model Review: /codex

After Claude completes /review, you can run /codex with OpenAI's Codex CLI for independent verification. Review results from two different models are merged and displayed—overlaps are identified, and unique findings from each are highlighted. It's like having two senior engineers with different backgrounds reviewing your code.

4. Safety Guardrails: /careful + /freeze

Saying "be careful" activates /careful, forcing confirmation before executing dangerous commands like rm -rf, DROP TABLE, or force-push. /freeze restricts edits to a single directory, preventing AI from "casually fixing" unrelated code during debugging. /guard combines both.

Use Cases and Limitations

Ideal Scenarios:

• Technical founders/CTOs who want hands-on product development but lack time
• Small teams (1-5 people) looking to amplify capacity with AI
• Startups needing standardized engineering processes
• Heavy users of Claude Code or similar tools

Limitations:

• Heavily dependent on Claude Code ecosystem—experience may suffer with other IDE integrations
• 23 skills require learning curve—not truly "out of the box"
• Features requiring real browser testing depend on Playwright; Windows users need extra Node.js configuration
• For ultra-large projects (hundreds of developers), this "one-person-as-team" model may not apply

My Take

As a Java backend developer, I was initially skeptical of this "full-stack AI workflow." But on closer inspection, gstack's greatest value isn't the number of skills—it's that it productizes engineering processes. In traditional companies, how many meetings, documents, and review cycles does it take to ship a feature from idea to production? gstack compresses these processes into a series of commands, each backed by a validated methodology.

Of course, it's not a silver bullet. AI-generated code still requires human judgment for final approval, and security reviews can't fully replace professional security teams. But for entrepreneurs wanting to rapidly validate ideas, or small teams looking to boost efficiency with AI, this toolkit offers a referenceable paradigm.

I'll close with a quote from the README: "The point isn't who typed it, it's what shipped."—This may be the mindset shift engineers need in the AI era.