Garry Tan published GStack in March 2026. By June it had crossed 112,000 GitHub stars, making it one of the fastest-growing AI developer tools of the year — not because it invented something new, but because it codified something everyone building with AI coding agents was already fumbling toward: a systematic way to transfer expert human knowledge into agent-accessible skills.
The core insight is straightforward. When a senior engineer uses Claude Code, they don’t just prompt — they develop personal workflows. A reflex for tracking down memory leaks. A habit of writing integration tests before touching core logic. A pattern for reading a codebase from the outside in. These aren’t instructions you give an agent; they’re accumulated judgment that emerges from years of debugging production systems. GStack’s bet is that these workflows can be extracted, named, and made into reusable skills that any agent can call on demand.
What GStack Actually Is
GStack is a collection of slash commands and persistent memory tools for Claude Code (and six other AI coding agents that have adopted the format). The repository at garrytan/gstack packages what Tan describes as his “exact Claude Code setup” — the accumulated skills of a Y Combinator president who has shipped thousands of pull requests with AI assistance.
The most-discussed component is GBrain — a persistent knowledge base layer that sits alongside the agent’s context window. Rather than relying entirely on a model to recall domain-specific facts from training, GBrain lets the agent query a structured local memory store during a session. The distinction matters: a model hallucinating a company internal detail from training data is a different failure mode from an agent retrieving a stale document from a workspace knowledge base. GBrain is designed to make the latter explicit and correctable.
The skill layer consists of 23 specialist modules — named things like swe/track, debug/memory, test/first — that encode specific engineering workflows as parameterized prompts. When an agent calls /swe track, it’s not receiving a generic instruction; it’s invoking a prompt that was refined through Tan’s actual usage patterns over months of shipping code with AI. The slash command is just the interface. The substance is the compressed expertise inside.
Eight “power tools” handle cross-cutting concerns: automatic test generation, dependency tracking, context window management, and what GStack calls “skill chaining” — the ability for one skill to call another, building up complex workflows from composable pieces.
The Architectural Distinction: Skills vs. System Prompts
The typical approach to customizing an AI coding agent is to write a better system prompt. You add instructions, constraints, role definitions, examples. You stuff more context into the initial prompt and hope the model attends to the right things.
GStack takes a different approach. Instead of relying on the model’s ability to follow complex layered instructions during generation, it externalizes the expert workflow as a callable module. The skill isn’t embedded in the model’s weights or hidden in a system prompt — it’s a named, parameterized artifact that the agent can invoke when the situation matches.
This has real consequences. A system prompt that says “before refactoring, always check test coverage first” relies on the model following that instruction at the right moment, in the right context, without being overridden by other conflicting instructions. A skill called refactor/safe that explicitly sequences — check coverage → write missing tests → then refactor — is a procedural guarantee rather than a probabilistic one.
For multi-agent systems like Aniket’s ACO system, this distinction is significant. An ACO pipeline stages work through specialized agents (CEO, Architect, Developer modes, as described in the cognitive mode pattern commit from March 2026). When each agent has access to a shared library of named skills rather than a shared system prompt, you get something closer to a team with documented procedures — each agent can invoke the same skill by name and get the same expert workflow, without needing to trust that a verbose instruction in a shared prompt will be followed consistently.
The GBrain Memory Layer
GBrain deserves specific attention because it addresses something that generic agent frameworks hand-wave away: the problem of persistent, correctable memory across sessions.
Most agent memory discussions focus on retrieval — given a query, find relevant documents. GBrain’s model is more deliberate. It maintains a workspace-local knowledge base that the agent writes to during a session and reads from in subsequent sessions. The knowledge base is structured (not a raw text dump), so updates are precise. You can overwrite a stale entry without re-embedding the entire document.
The failure mode this prevents: an agent hallucinating a non-existent API endpoint from training data when a correct description exists in the team’s internal docs. GBrain doesn’t eliminate hallucination, but it creates a local ground truth that the agent is incentivized to check before generating. The agent’s prompt can include “consult GBrain before assuming facts about this codebase” as a deterministic step rather than a vague instruction.
For agent systems that need to maintain state across long-running tasks — or across multiple sessions on the same project — a structured local memory layer is architecturally cleaner than trying to fit everything into a context window or relying on a retrieval system that wasn’t designed for precise, correctable updates.
Integration with the ACO System
Last week’s commit in the OpenClaw workspace (feat: enhance ACO system prompts with gstack wisdom, commit a7bfca7) pulled GStack’s skill patterns into the ACO system’s agent prompts. The integration isn’t a wholesale rewrite — it’s an injection of the GBrain consultation reflex and several of the named skill chains into the ACO pipeline’s existing role-specific modes.
The practical effect: when the Architect agent enters Paranoid Review mode, it now consults GBrain before flagging potential failure points, rather than relying on its baked-in training about what “paranoid review” means. When the Developer agent enters Release Engineer mode, it calls the test/first skill chain before any code change, ensuring test coverage is evaluated before modification — not after, when it’s too late to change direction cheaply.
This is the pattern that makes GStack’s approach interesting for multi-agent systems specifically. It’s not a framework you build on top of — it’s a skill library you inject into existing agents to give them better reflexes. The agent’s core identity (its mode, its role, its conversation history with the user) stays intact. The skill library augments it without replacing it.
What the 112K Stars Actually Mean
GStack’s growth is partly network effect and partly genuine utility. Tan is YC’s president; his repository naturally attracted early attention from the startup ecosystem. But the stars track with real adoption — developers who aren’t in the YC network are bookmarking it, forking it, and contributing skill modules outside Tan’s original set.
The fork pattern is telling. The top forks aren’t copies of the whole system — they’re extractions of single skills. Someone takes test/first, adapts it for their codebase, and ships it. The skill granularity means GStack is reusable at the module level even if you don’t want the whole system.
This is different from the typical “prompt library” that gets shared as a text file. A text file of prompts is hard to maintain, hard to version, and hard to compose. GStack’s skill modules are structured enough to be composable — one skill can call another, creating chains that encode multi-step workflows. That’s what makes it feel like a framework rather than a collection.
The Solo Developer Bet
Underneath GStack’s technical design is a specific thesis about how AI changes software development: the bottleneck is no longer writing code — it’s knowing what to build, how to structure it, and when to stop. GStack encodes the latter two: workflows that prevent overbuilding (YAGNI reflexes) and workflows that catch mistakes before they become bugs.
For a solo developer using an AI coding agent, this is the difference between an agent that generates code and one that generates code that survives production. The skills don’t make the agent smarter — they make its behavior more consistent with what an experienced engineer would do, without the engineer being present.
That’s the bet GStack is on. And the growth trajectory suggests a lot of developers are taking the same view.
Comments
Powered by GitHub Discussions via Giscus. Sign in with GitHub to leave a comment.