gstack Review: A Universal Skill Stack for AI Coding Agents, Not Just a Claude Code Setup

Introduction: Tool Overview and What It Does

gstack is an open-source workflow framework for AI-assisted software development created by Garry Tan, President and CEO of Y Combinator. At first glance, it looks like a highly opinionated Claude Code setup: a collection of slash commands that turn Claude into a product thinker, engineering manager, reviewer, QA tester, security officer, release engineer, and documentation writer. But that description undersells it.

The more useful way to understand gstack is as a portable workflow layer for AI coding agents. Instead of relying on one giant prompt or a loose set of project rules, gstack packages a startup-style software process into reusable skills. Those skills cover planning, design review, engineering review, QA, browser testing, security auditing, documentation, benchmarking, release management, deployment, retrospectives, and cross-agent coordination.

Its central argument is simple: AI coding agents do not only need better models; they need better process. gstack tries to provide that process by giving agents roles, constraints, handoff points, and quality gates.

This review looks at gstack as a practical development system: what it does well, where it is overkill, who should use it, how it compares with alternatives, and whether it is really a universal skill stack rather than just a Claude Code customization.

Quick Verdict: TL;DR Summary

Rating: 8.6/10

gstack is one of the most ambitious open-source workflow layers for AI coding agents. It is especially compelling for technical founders, solo builders, staff engineers, and teams already using Claude Code who want repeatable planning, review, QA, and release discipline around AI-generated code.

Its biggest strength is structure. gstack turns vague AI-assisted coding into a staged sprint process: think, plan, build, review, test, ship, and reflect. Its biggest weakness is also structure. For small edits, simple scripts, or developers who prefer lightweight prompting, gstack can feel heavy, opinionated, and occasionally over-engineered.

What Is gstack?

gstack is a collection of AI agent skills, slash commands, scripts, browser tools, and workflow conventions designed to make AI coding agents behave more like a coordinated software team. The project describes itself as Garry Tan’s exact Claude Code setup, but the current scope is broader: it installs into Claude Code and can also target other coding-agent environments such as OpenAI Codex CLI, Cursor, OpenCode, Factory Droid, Slate, Kiro, Hermes, and GBrain integrations. OpenClaw support is also documented through Claude Code session spawning and native methodology skills.

The core idea is role decomposition. Instead of asking an agent to simply build a feature, you can run commands such as /office-hours, /plan-ceo-review, /plan-eng-review, /review, /qa, /cso, /ship, and /document-release. Each command represents a specialist role with a narrow responsibility.

For example, /office-hours behaves like a YC-style product interrogation. It asks forcing questions, challenges the user’s assumptions, and reframes the requested feature into a sharper product opportunity. /plan-eng-review then evaluates architecture, data flow, edge cases, test strategy, and failure modes. /qa can use a real browser to click through an application, report bugs, fix issues, and generate regression tests. /ship syncs the branch, runs tests, audits coverage, and prepares a pull request.

That pipeline is what makes gstack interesting. It is not just a prompt pack. It is closer to a process template for agentic development.

Key Features

1. Role-Based Skills for the Full Software Lifecycle

gstack’s most important feature is its set of opinionated skills. The exact list continues to evolve, but the project includes roles for product strategy, design, engineering planning, code review, QA, security, documentation, release management, deployment, benchmarking, browser automation, and retrospectives.

2. A Sprint Process, Not Just Commands

The typical gstack loop is: think, plan, build, review, test, ship, and reflect. This matters because many AI coding failures happen before code is written. The agent misunderstands the goal, implements the wrong abstraction, adds unrelated changes, or skips validation. gstack tries to prevent this with up-front product and engineering review.

A practical workflow might look like this:

1. Run /office-hours to clarify the product problem.
2. Run /autoplan to generate a reviewed plan.
3. Approve or edit the plan.
4. Let the coding agent implement the feature.
5. Run /review to catch production-risk issues.
6. Run /qa against a staging URL.
7. Run /ship to create a tested pull request.
8. Run /document-release if documentation needs updating.

3. Browser-Based QA and Visual Testing

gstack gives agents browser capabilities through commands such as /browse, /qa, and /open-gstack-browser. This is a major improvement over purely text-based code review because many frontend bugs are only visible in real interaction: broken forms, layout overflow, authentication redirects, missing loading states, or JavaScript errors in the console.

Screenshot-style demonstration: In a typical /qa run, you would expect the browser window to open against a staging URL. The agent navigates through the application, clicks buttons, submits forms with test data, captures screenshots, notes console errors, and reports findings. For a dashboard app, for instance, a useful QA report might show that the empty state renders correctly, but the settings modal overflows on a narrow viewport and the save button remains enabled after submission.

4. Security Review with /cso

The /cso skill acts as a Chief Security Officer. It is designed to apply frameworks such as OWASP Top 10 and STRIDE-style threat modeling. The project emphasizes low-noise findings, confidence thresholds, false-positive exclusions, and concrete exploit scenarios. That is exactly the right direction for AI security review because generic security prompts often produce vague warnings that developers ignore.

That said, /cso should be treated as an additional review layer, not a replacement for professional security testing, dependency scanning, SAST tooling, penetration testing, or formal compliance review.

5. Multi-Agent Coordination

One of gstack’s more forward-looking features is /pair-agent, which allows multiple AI agents to share browser access while keeping separate tabs, scoped tokens, rate limits, and activity attribution. In practice, this means Claude Code, Codex, OpenClaw, Cursor, Hermes, or another HTTP-capable agent can coordinate around the same browsing environment.

This is where the universal skill stack framing becomes credible. gstack is no longer only a Claude Code preference file; it becomes a coordination layer for heterogeneous AI development tools.

6. Documentation and Release Automation

Documentation is a common casualty of AI-assisted development. Code changes quickly, README files drift, and architecture notes become stale. gstack’s /document-release and /document-generate skills address this directly by reading project docs, comparing them against recent changes, and generating or updating documentation.

The release flow also matters. /ship can run tests, audit coverage, bootstrap test frameworks when missing, push changes, and open a pull request. /land-and-deploy and /canary extend that workflow into deployment and post-deploy checks.

Pros: Strengths and Advantages

• Excellent process discipline: gstack brings structure to AI coding, reducing the risk of chaotic one-shot generation.
• Broad lifecycle coverage: It covers product, design, engineering, QA, security, documentation, and release workflows.
• Free and open source: The MIT license makes it easy to inspect, fork, customize, and adopt.
• Strong fit for technical founders: Solo builders can simulate several startup roles without hiring a full team.
• Useful quality gates: Review, QA, security, and shipping steps help catch issues that simple code generation misses.
• Browser-aware workflows: Real browser interaction makes it more useful for frontend and full-stack applications.
• Portable direction: Support for several coding-agent hosts makes it more than a single-agent configuration.
• Good team-mode concept: Shared repositories can standardize AI-assisted workflows across teammates.

Cons: Weaknesses and Limitations

• Can feel over-engineered: For simple bug fixes or small scripts, the workflow may be heavier than necessary.
• Claude Code remains the best-supported path: Although gstack supports multiple hosts, the most polished experience is still centered on Claude Code.
• Learning curve: Developers need to learn which skill to use, when to use it, and how to interpret the outputs.
• Not a substitute for human judgment: AI-generated plans, reviews, and security findings still require careful human review.
• Toolchain dependencies: Bun, Git, browser automation, agent-specific directories, and host integrations add moving parts.
• Possible workflow mismatch: Teams with established engineering processes may find gstack’s opinions too prescriptive.
• Security and privacy due diligence required: Browser automation, cookie import, repo memory, and telemetry settings should be reviewed before enterprise use.

Pricing: Cost Structure and Plans

gstack itself is free. It is open source under the MIT license, with no premium tier, waitlist, or subscription fee for the framework.

However, using gstack is not necessarily cost-free in practice. You still need access to the underlying AI coding agents and model providers. For many users, that means Claude Code and Anthropic model usage. If you use OpenAI Codex CLI, Gemini, image generation, browser automation, Supabase-backed memory, or other integrations, those services may introduce separate costs.

Use Cases: Who Should Use gstack and When

Technical Founders and Solo Builders

This is gstack’s clearest audience. If you are building a product mostly alone, gstack can help you slow down at the right moments: clarify the product, review the architecture, test the UI, update docs, and ship with more confidence.

AI-Native Engineering Teams

Teams already using coding agents can use gstack as a shared operating procedure. Instead of each developer inventing their own prompting habits, a repo can standardize around skills such as /review, /qa, /cso, and /ship.

Staff Engineers and Tech Leads

Senior engineers can benefit from gstack as a review amplifier. It does not replace architectural ownership, but it can force edge cases, tests, failure modes, and documentation into the conversation earlier.

Frontend and Full-Stack Developers

The browser-based QA workflow is particularly useful for web apps, dashboards, onboarding flows, and admin tools. AI agents are much more useful when they can inspect real pages rather than only source files.

Who Should Skip It?

Skip gstack if you only want a lightweight autocomplete tool, if your work is mostly small isolated edits, or if your organization prohibits unapproved agentic browser automation. Also be cautious if your team already has mature internal release, QA, and security processes that would conflict with gstack’s assumptions.

Comparison: How gstack Stacks Up Against Alternatives

The key distinction is that gstack is optimized for day-to-day software shipping with coding agents. It is less of a general-purpose agent framework and more of a practical operating system for AI-assisted development.

Hands-On Experience: Practical Testing Insights

Disclosure: I have no affiliation with gstack, Garry Tan, Y Combinator, Anthropic, OpenAI, or any competing tool. This review is based on the public repository documentation, installation flow, feature descriptions, and workflow analysis rather than a long-term production deployment inside a private engineering team.

The installation flow is straightforward for Claude Code users. The documented path clones the repository into the Claude skills directory and runs a setup script. For a default Claude Code setup, the process is designed to take under a minute:

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

For other agents, setup can target specific hosts, placing skills into locations such as Codex, Cursor, OpenCode, or other agent-specific directories. This is powerful, but it is also where friction can appear. Agent ecosystems do not yet have a universal standard for skills, memory, browser control, and slash commands, so portability is real but not completely seamless.

The strongest workflow demonstration is the product-to-PR path. Imagine building a daily briefing app. A typical AI prompt might produce a calendar summary feature immediately. gstack’s /office-hours approach is different: it first asks what problem the user is actually solving. It may reframe the request from a daily briefing app into a personal chief-of-staff workflow, then recommend a narrow first wedge. That design document can feed into CEO, design, and engineering review before code is written.

This is exactly where gstack shines. The value is not that every generated answer is automatically correct. The value is that the agent is forced to expose assumptions before implementation. In real AI coding workflows, that can save hours of cleanup.

The review and QA loop is similarly practical. A useful /review run should look for bugs that pass CI but fail in production: race conditions, missing error handling, incomplete migrations, unhandled empty states, or unsafe assumptions. A useful /qa run should open the app, interact with it, capture visible issues, and verify fixes. These are concrete behaviors, not abstract productivity claims.

The main caveat is operational complexity. Once you add browser sessions, cookie import, multi-agent pairing, persistent memory, telemetry options, and deployment automation, you need to treat gstack like real infrastructure. Teams should review what is installed, what data is stored locally, whether telemetry is off or on, and how browser authentication is handled.

Final Verdict: Overall Recommendation

gstack is worth reviewing as a universal skill stack for AI coding agents because it addresses a real gap in AI-assisted development: process. Most coding agents can generate code. Fewer can reliably decide what should be built, critique the plan, test the result in a browser, audit security implications, update documentation, and prepare a release.

For technical founders and AI-native developers, gstack can be a major productivity multiplier. It gives solo builders a repeatable workflow that resembles a small product and engineering team. For professional teams, it can standardize agent behavior and add useful quality gates around AI-generated changes.

But gstack is not magic. It does not remove the need for engineering judgment, product taste, security review, or production monitoring. It is also not the lightest option. If you only need quick code completions, gstack may be too much. If you are trying to run multiple parallel AI-assisted sprints with real review and QA, it is one of the most compelling open-source options available.

Recommendation: Try gstack if you already use Claude Code or another supported coding agent and want a structured, end-to-end workflow. Start with /office-hours, /autoplan, /review, /qa, and /ship. If those commands improve your work within the first few sessions, then explore the deeper design, security, documentation, memory, and multi-agent features.

Alternatives: Other Options to Consider

• Custom Claude Code or Cursor rules: Best if you want lightweight project-specific instructions without adopting a full workflow framework.
• Superpowers-style TDD systems: Best if your priority is strict test-driven development and preventing untested production code.
• GSD-style planning workflows: Best if your main problem is context rot and oversized AI sessions.
• Cursor: Best for developers who want an integrated AI coding IDE with rules, context, and fast editing workflows.
• OpenAI Codex CLI: Best for teams standardizing around OpenAI models and terminal-based agent workflows.
• CrewAI, LangGraph, or AutoGen: Best for developers building custom multi-agent systems rather than using a ready-made software development process.

gstack’s advantage over most of these alternatives is that it combines product thinking, engineering governance, QA, browser automation, security, documentation, and shipping into one coherent workflow. Its disadvantage is that adopting all of that requires commitment. For the right user, that tradeoff is exactly the point.