"I don't think I've typed like a line of code probably since December, basically, which is an extremely large change." — Andrej Karpathy, No Priors podcast, March 2026

When I heard Karpathy say this, I wanted to find out how. How does one person ship like a team of twenty? Peter Steinberger built OpenClaw — 247K GitHub stars — essentially solo with AI agents. The revolution is here. A single builder with the right tooling can move faster than a traditional team.

I'm Garry Tan, President & CEO of Y Combinator. I've worked with thousands of startups — Coinbase, Instacart, Rippling — when they were one or two people in a garage. Before YC, I was one of the first eng/PM/designers at Palantir, cofounded Posterous (sold to Twitter), and built Bookface, YC's internal social network.

gstack is my answer. I've been building products for twenty years, and right now I'm shipping more products than I ever have. In the last 60 days: 3 production services, 40+ shipped features, part-time, while running YC full-time. On logical code change — not raw LOC, which AI inflates — my 2026 run rate is ~810× my 2013 pace (11,417 vs 14 logical lines/day). Year-to-date (through April 18), 2026 has already produced 240× the entire 2013 year. Measured across 40 public + private garrytan/* repos including Bookface, after excluding one demo repo. AI wrote most of it. The point isn't who typed it, it's what shipped.

The LOC critics aren't wrong that raw line counts inflate with AI. They are wrong that normalized-for-inflation, I'm less productive. I'm more productive, by a lot. Full methodology, caveats, and reproduction script: On the LOC Controversy.

2026 — 1,237 contributions and counting:

2013 — when I built Bookface at YC (772 contributions):

Same person. Different era. The difference is the tooling.

gstack is how I do it. It turns Claude Code into a virtual engineering team — a CEO who rethinks the product, an eng manager who locks architecture, a designer who catches AI slop, a reviewer who finds production bugs, a QA lead who opens a real browser, a security officer who runs OWASP + STRIDE audits, and a release engineer who ships the PR. Twenty-three specialists and eight power tools, all slash commands, all Markdown, all free, MIT license.

This is my open source software factory. I use it every day. I'm sharing it because these tools should be available to everyone.

Fork it. Improve it. Make it yours. And if you want to hate on free open source software — you're welcome to, but I'd rather you just try it first.

Who this is for:

• Founders and CEOs — especially technical ones who still want to ship
• First-time Claude Code users — structured roles instead of a blank prompt
• Tech leads and staff engineers — rigorous review, QA, and release automation on every PR

1. Install gstack (about 30 seconds of setup — see below)
2. Run /office-hours — describe what you're building
3. Run /plan-ceo-review on any feature idea
4. Run /review on any branch with changes
5. Run /qa on your staging URL or an isolated local API, CLI, job or webhook
6. Stop there. You'll know if this is for you.

./setup took 31 seconds after the clone on a 4-vCPU Linux cloud machine (v1.91.13.0, clean HOME, including the binary build and the Chromium download). Slower networks and laptops take longer.

Requirements: Claude Code, Git, Bun v1.0+, Node.js (Windows only). Recommended on macOS: the Aside browser (macOS 15+) — browser skills, /make-pdf, and /diagram drive it first, with your real logged-in sessions. Without it, ./setup builds gstack's own bundled browser and the same skills use that. /cso additionally needs a Bun release with all four --no-compile-autoload-* build flags plus a native toolchain: a static-capable C compiler on Linux, Xcode command-line tools on macOS, or Visual Studio 2022 Build Tools with Desktop development with C++ on Windows. If those are absent, setup installs everything else, removes stale CSO helpers, and /cso reports not assessed with the prerequisite.

When qualified CSO runtime images are published, setup gives each automatic preload a 30-second window plus a bounded setup allowance for the declared catalog. For slower registries, set an integer such as GSTACK_CSO_IMAGE_PULL_TIMEOUT_SECONDS=120 (accepted range: 5–300 seconds). One image timing out does not consume the remaining images' windows; setup reports partial progress and a later run resumes from exact digests already present in local Docker. The complete preload is capped at one hour.

Open Claude Code and paste this. Claude does the rest.

Install gstack: run git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup then add a "gstack" section to CLAUDE.md that says to use the /browse skill from gstack for all web browsing, never use mcp__claude-in-chrome__* tools, and lists the available skills: /office-hours, /plan-ceo-review, /plan-eng-review, /plan-design-review, /design-consultation, /design-shotgun, /design-html, /review, /deslop-shared-libs, /test-audit, /ship, /land-and-deploy, /canary, /benchmark, /browse, /connect-chrome, /qa, /qa-only, /design-review, /scrape, /setup-browser-cookies, /setup-deploy, /setup-gbrain, /retro, /investigate, /document-release, /document-generate, /codex, /cso, /autoplan, /plan-devex-review, /devex-review, /careful, /freeze, /guard, /unfreeze, /gstack-upgrade, /learn. Then ask the user if they also want to add gstack to the current project so teammates get it.

From inside your repo, paste this. Switches you to team mode, bootstraps the repo so teammates get gstack automatically, and commits the change:

(cd ~/.claude/skills/gstack && ./setup --team) && ~/.claude/skills/gstack/bin/gstack-team-init required && git add .claude/ CLAUDE.md && git commit -m "require gstack for AI-assisted work"

No vendored files in your repo, no version drift, no manual upgrades. Every Claude Code session starts with a fast auto-update check (throttled to once/hour, network-failure-safe, completely silent).

Swap required for optional if you'd rather nudge teammates than block them.

OpenClaw spawns Claude Code sessions via ACP, so every gstack skill just works when Claude Code has gstack installed. Paste this to your OpenClaw agent:

Install gstack: run git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup to install gstack for Claude Code. Then add a "Coding Tasks" section to AGENTS.md that says: when spawning Claude Code sessions for coding work, tell the session to use gstack skills. Include these examples — security audit: "Load gstack. Run /cso", code review: "Load gstack. Run /review", QA test a URL: "Load gstack. Run /qa https://...", build a feature end-to-end: "Load gstack. Run /autoplan, implement the plan, then run /ship", plan before building: "Load gstack. Run /office-hours then /autoplan. Save the plan, don't implement."

After setup, just talk to your OpenClaw agent naturally:

See docs/OPENCLAW.md for advanced dispatch routing and the gstack-lite/gstack-full prompt templates.

Four methodology skills that work directly in your OpenClaw agent, no Claude Code session needed. Install from ClawHub:

clawhub install gstack-openclaw-office-hours gstack-openclaw-ceo-review gstack-openclaw-investigate gstack-openclaw-retro

These are conversational skills. Your OpenClaw agent runs them directly via chat.

gstack runs on more agents than Claude. Bare ./setup installs for Claude Code only. Pick another agent with --host <name>, or install for every agent setup detects on this machine with --host auto:

git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/gstack
cd ~/gstack && ./setup --host auto      # or: ./setup --host codex
./setup --status                         # one row per install: host, tier, scope, version, path

An explicit --host X installs for X only and never changes another agent's install. /gstack-upgrade refreshes every install it registered, one row per host, and says which ones failed.

Tiers: full is certified by a real workflow run (see Certify your host); experimental installs and passes the conformance tests but has no certification run yet; instruction-only installs nothing: setup prints what to copy.

Copilot invokes gstack skills by their prefixed names (/gstack-review) because /review is a Copilot built-in. Copilot ignores skill hooks, so /careful and /freeze only advise there, and COPILOT_HOME other than ~/.copilot is not supported yet (setup refuses and changes nothing).

Outside reviews require the selected CLI to be installed and authenticated: Claude Code when using gstack in Codex, or Codex on other harnesses. External harnesses discover these commands as /gstack-claude-code and /gstack-codex; each harness omits its own wrapper. Explicit provider requests keep that provider. The existing codex_reviews setting controls automatic outside reviews where supported, regardless of the provider selected.

/claude has been renamed to /claude-code. Re-run ./setup --host <name> to migrate managed installations, including other harnesses sharing the checkout. Setup preserves the previous installation if replacement generation or installation fails and prints repair instructions.

Instruction-only tier (any rules-reading agent — Zed, Amp, Jules, side projects): copy the 2KB digest at agents-digest/gstack-AGENTS.md into a location your agent reads (for example, append it to your project's AGENTS.md). It carries gstack's ethos, reuse ladder, and voice rules — no install required. The digest's first line shows its gstack version; re-copy it after upgrading.

For Codex, setup reads the top-level model from ${CODEX_HOME:-~/.codex}/config.toml and generates the matching behavioral profile, falling back to gpt-6-astra when no usable model is configured. gpt-5.6-sol automatically receives bounded-scope instructions that finish the requested lake without expanding into adjacent cleanup or speculative hardening. The Sol profile is exact-match only: dated snapshots and other 5.6 variants get the generic GPT profile, and setup warns on near-misses like gpt-5.6-sol-2026-08-01. Override detection with ./setup --host codex --model <id> — the override applies to that run only; set model in your Codex config.toml to make it stick across upgrades. After changing your Codex model, rerun ./setup --host codex to regenerate the skills.

Which Codex model gstack uses. For every Codex call (outside voices, /codex, review and ship adversarial passes), gstack picks the model in this order: a model you name for that request, then GSTACK_CODEX_MODEL, then model in your Codex config.toml (for native codex review, review_model first; a custom CODEX_HOME is honored), and only then gstack's default, gpt-6-astra. Before spending anything, it prints the choice and where it came from, for example CODEX_MODEL: gpt-5.6-terra (exec; source: ~/.codex/config.toml model). If your choice is invalid or your account cannot use it, gstack stops with a repair message and reports the outside review as unavailable. It never silently switches to its default. Nested Codex reviews also run with installed skills hidden (-c skills.include_instructions=false), so a review cannot turn into a whole nested skill run. Runtime model selection is separate from the setup-time behavioral profile above. /claude-code (gstack-claude-code on Codex) preserves Claude's configured model. Set GSTACK_CLAUDE_MODEL=<model> or name a model in your request to override it for the invocation, including resumed consultations. See eval defaults and overrides for capture, judge, and benchmark model selection.

The design binary ($D) uses OpenAI's gpt-5.5 by default, with image generation through gpt-image-2. Set GSTACK_DESIGN_MODEL=<model> to use another gpt-5-class model for both image generation and screenshot analysis; if OpenAI rejects it, the error names GSTACK_DESIGN_MODEL. Check a key against the defaults with bun run design/scripts/live-model-check.ts.

Want to add support for another agent? See docs/ADDING_A_HOST.md. Rendering a new agent is one TypeScript config file; installing it also needs a setup arm and the conformance kit, and it starts as experimental.

You:    I want to build a daily briefing app for my calendar.
You:    /office-hours
Claude: [asks about the pain — specific examples, not hypotheticals]

You:    Multiple Google calendars, events with stale info, wrong locations.
        Prep takes forever and the results aren't good enough...

Claude: 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.
        [extracts 5 capabilities you didn't realize you were describing]
        [challenges 4 premises — you agree, disagree, or adjust]
        [generates 3 implementation approaches with effort estimates]
        RECOMMENDATION: Ship the narrowest wedge tomorrow, learn from
        real usage. The full vision is a 3-month project — start with
        the daily briefing that actually works.
        [writes design doc → feeds into downstream skills automatically]

You:    /plan-ceo-review
        [reads the design doc, challenges scope, runs 10-section review]

You:    /plan-eng-review
        [ASCII diagrams for data flow, state machines, error paths]
        [test matrix, failure modes, security concerns]

You:    Approve plan. Exit plan mode.
        [writes 2,400 lines across 11 files. ~8 minutes.]

You:    /review
        [AUTO-FIXED] 2 issues. [ASK] Race condition → you approve fix.

You:    /qa https://staging.myapp.com
        [opens real browser, clicks through flows, finds and fixes a bug]

You:    /ship
        Tests: 42 → 51 (+9 new). PR: github.com/you/app/pull/42

You said "daily briefing app." The agent said "you're building a chief of staff AI" — because it listened to your pain, not your feature request. Eight commands, end to end. That is not a copilot. That is a team.

gstack is a process, not a collection of tools. The skills run in the order a sprint runs:

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

Each skill feeds into the next. /office-hours writes a design doc that /plan-ceo-review reads. /plan-eng-review writes a test plan that /qa picks up. /review catches bugs that /ship verifies are fixed. Nothing falls through the cracks because every step knows what came before it.

Use the same commands for browser and non-browser software. Start in a repository with its documented native command and an isolated local fixture; name the target and the behavior you want checked. For example:

/qa-only Test this repo's CLI using its documented local fixture. Check valid and invalid input, exit codes, stdout/stderr, and cancellation. Report only; do not change code or tests. For each finding, include the exact command, expected and actual results, and which checks remain untested. Keep requests inside the fixture; ask before contacting an external service.

/qa Test this repo's local webhook and worker fixture. Explore duplicate deliveries and recovery after a partial failure. Keep all effects inside the fixture; preserve reproduced bugs in native regression tests before repairing them.

QA first tells you which surface, tools and write permissions it will use. A CLI or API does not need a browser. Browser targets keep real browser testing; developer experience audits load only when onboarding, installation or ergonomics are in scope. If the native tools or safe fixture are unavailable, the report names the blocker and untested contracts instead of inventing a pass or installing another framework.

Exploration means learning from each result and choosing the next useful challenge, not running random commands. Before the next discovery probe, QA saves a short exploration-NNN.json evidence note with the previous result, the assumption being tested and the next command. The final report links these notes; they do not require an extra chat message between probes. A discovered bug must be reproducible, and its new test must fail for the bug before the repair and pass afterward. Unit tests protect logic; integration and end-to-end tests protect real boundaries that mocks would hide. /qa-only proposes those tests without writing them.

Normal /review and /ship run a bounded version on changed behavior and nearby risks automatically, including small diffs without a plan or web server. Existing fix/test approval rules still apply. Missing dependencies, denied actions and time limits remain visible coverage gaps; a short smoke pass never means exhaustive QA. Production access and destructive or external effects require specific permission.

Bounded exploration uses an executable deadline guard, not an estimated clock: it refuses late probes and stops owned foreground work at the limit. Unfinished checks stay visible in the report. Required plan checks remain outside the review/ship smoke budget. See QA deadlines for command, platform and cleanup limits.

Every ship also runs the existing documentation audit, including repeat ships and existing PR updates. Clear factual corrections join the final checked change; risky rewrites need approval. A failed audit stops for recovery or explicit acceptance of the named risk rather than silently dropping its result. Ship owns versioning, Git and PR publication; the docs helper does not commit or push independently.

Beyond the slash-command skills, gstack ships standalone CLIs for workflows that don't belong inside a session:

The private paid CSO evaluation producer is a packaging contract, not an ordinary bun run build artifact. On macOS or Linux, a release operator compiles cso-eval-producer with the documented hardened Bun flags in the same clean build session as bun run build:cso, then installs it beside gstack-cso-launcher, gstack-cso-core, gstack-cso-watchdog, and the hidden .gstack-cso-generation manifest as one root-owned, nonwritable five-artifact unit. The producer rejects root execution, writable/symlinked/incomplete installations, and unreviewed provider CLI versions; each receipt binds all five artifact hashes, and collection rejects receipts from different unit identities. See the clean producer procedure. Paid producer evaluation remains unavailable on Windows because the detached watchdog has no Windows build.

Each producer gets a curated one-cell source copy with directories sealed to 0555 and files to 0444, plus pre/post content, Git, and mode checks. Claude receives that exact copy as a restricted read-only add-directory so its constrained launcher command can reach it. Gemini receives no source working directory or include-directory. Codex technically receives read-only filesystem access to the exact curated source root because the trusted helper inherits the Codex permission profile; its private provider work directory and exact cso-home artifact directory are the only write roots, every other root path remains denied, and the producer prompt requires source access through the helper. This is evaluation containment for an immutable public fixture, not a claim that Codex cannot directly read that fixture.

Copy each completed cell's receipt together with state/cso-home/security/cso/ to the trusted adjudication host. Receipt entries are sorted paths relative to that directory and bind every retained file's size and SHA-256 plus an aggregate inventory hash. Provider homes, settings, sessions, and credentials live under separate disposable directories and are removed after the cell; they are never part of the retained artifact tree. The adjudicator must re-hash the transported tree against the receipt before trusting reports or repair bundles.

Paid producer qualification uses this explicit host matrix:

Every setup-blocked comprehensive cell remains a miss in release-gate denominators. The evaluator does not silently count a host or workflow as supported when its containment policy prevents required setup.

./setup also registers one default-on Stop hook in ~/.claude/settings.json: gstack-timeline-stop (closes dangling session-timeline entries when a session is interrupted; fail-open — 2s internal budget, always exits 0, can never block a session). Opt out persistently with ./setup --no-timeline-stop-hook — the choice lands in the timeline_stop_hook config key, survives upgrades, and an explicit "no" removes a live registration. GSTACK_TIMELINE_STOP_HOOK=no and gstack-config set timeline_stop_hook no work too (flag > env > config). ./setup --no-team skips it for that run, gstack-settings-hook remove-source --source gstack-timeline-stop removes it by hand, and gstack-uninstall removes it too.

Hook registration is canonical-only: every hook command points at the stable ~/.claude/skills/gstack install, never the tree setup ran from, so deleting a worktree or Conductor workspace can't leave dead hooks erroring in your sessions. Every ./setup run also heals first: gstack-settings-hook prune-stale --repoint removes dead gstack hook entries, re-points stale ones at the stable install, and collapses duplicates, printing one line (and writing a backup beside the file) only when it changed something.

Two browser primitives in gstack's own engine (the fallback path when Aside isn't there) compound the agent over time:

• $B domain-skill save — agent saves a per-site note (e.g., "LinkedIn's Apply button lives in an iframe") that fires automatically next time it visits that hostname. Quarantined → active after 3 successful uses → optional cross-project promotion via $B domain-skill promote-to-global. Storage lives alongside /learn's per-project learnings file. Full reference: docs/domain-skills.md.
• $B cdp <Domain.method> — raw Chrome DevTools Protocol escape hatch for the rare case curated commands miss. Deny-default: methods must be explicitly added to browse/src/cdp-allowlist.ts with a one-line justification. Two-tier mutex serializes browser-scoped CDP calls against per-tab work. Output for data-exfil methods is wrapped in the UNTRUSTED envelope.

Want raw CDP with no rails, no allowlist, no daemon — just thin transport from agent to Chrome? browser-use/browser-harness-js is a different philosophy (agent-authored helpers vs gstack's curated commands) and a good fit if you don't want gstack's security stack. The two can coexist: gstack's $B cdp and harness can both attach to the same Chrome via Playwright's newCDPSession.

Deep dives with examples and philosophy for every skill →

Andrej Karpathy's AI coding rules (17K stars) nail four failure modes: wrong assumptions, overcomplexity, orthogonal edits, imperative over declarative. gstack's workflow skills enforce all four. /office-hours forces assumptions into the open before code is written. The Confusion Protocol stops Claude from guessing on architectural decisions. /review catches unnecessary complexity and drive-by edits. /ship transforms tasks into verifiable goals with test-first execution. If you already use Karpathy-style CLAUDE.md rules, gstack is the workflow enforcement layer that makes them stick across entire sprints, not just single prompts.

gstack works well with one sprint. It gets interesting with ten running at once.

Design is at the heart. /design-consultation builds your design system from scratch, researches what's out there, proposes creative risks, and writes DESIGN.md. But the real magic is the shotgun-to-HTML pipeline.

/design-shotgun is how you explore. You describe what you want. It generates 4-6 AI mockup variants using GPT Image. Then it opens a comparison board in your browser with all variants side by side. You pick favorites, leave feedback ("more whitespace", "bolder headline", "lose the gradient"), and it generates a new round. Repeat until you love something. Taste memory kicks in after a few rounds so it starts biasing toward what you actually like. No more describing your vision in words and hoping the AI gets it. You see options, pick the good ones, and iterate visually.

Works with impeccable. If you use impeccable too, gstack does not fight it. gstack runs impeccable's deterministic engine as a pre-pass in /design-review, /review, /ship, and /design-html when you have it installed (gstack never runs impeccable's installer or launcher; the first time a design skill finds no engine it asks once whether to download the engine binary, checksum-pinned and logged, into ~/.impeccable, and remembers your answer), speaks the same 61 rule ids in its own voice, reads PRODUCT.md, writes DESIGN.md in the open DESIGN.md format both tools read, and hands deferred findings to /impeccable <command>. Say no and nothing changes: no nag, no missing step. gstack-config set design_detector off turns the pre-pass off. Attribution for the material gstack derived from impeccable and the DESIGN.md spec is in NOTICE.md.

/design-html makes it real. Take that approved mockup (from /design-shotgun, a CEO plan, a design review, or just a description) and turn it into production-quality HTML/CSS. Not the kind of AI HTML that looks fine at one viewport width and breaks everywhere else. This uses Pretext for computed text layout: text actually reflows on resize, heights adjust to content, layouts are dynamic. 30KB overhead, zero dependencies. It detects your framework (React, Svelte, Vue) and outputs the right format. Smart API routing picks different Pretext patterns depending on whether it's a landing page, dashboard, form, or card layout. The output is something you'd actually ship, not a demo.

/qa was a massive unlock. It let me go from 6 to 12 parallel workers. Claude Code saying "I SEE THE ISSUE" and then actually fixing it, generating a regression test, and verifying the fix — that changed how I work. The agent has eyes now.

Smart review routing. Just like at a well-run startup: CEO doesn't have to look at infra bug fixes, design review isn't needed for backend changes. gstack tracks what reviews are run, figures out what's appropriate, and just does the smart thing. The Review Readiness Dashboard tells you where you stand before you ship.

Test everything. /ship bootstraps test frameworks from scratch if your project doesn't have one. Every /ship run produces a coverage audit. /qa creates native regressions when infrastructure is available and explicitly reports missing test coverage; CSS-only fixes may use browser evidence instead. 100% test coverage is the goal — tests make vibe coding safe instead of yolo coding.

/document-release is the engineer you never had. It audits relevant authored docs against the release diff and corrects factual drift before final verification. Risky changes return for approval. /ship invokes it on every run and owns TODOS, release metadata, generation and publication; the child reports updated, current or blocked documentation.

Aside is the browser gstack drives first. For browser surfaces, on a Mac with the Aside AI browser open, /qa, /qa-only, /design-review, /canary, /benchmark, /scrape, and /browse all run there — your real browser, with your real logged-in sessions, in tabs the agent opens for itself and closes when it's done. No cookie import, no "open the browser" step, no CAPTCHA handoff dance: hit a sign-in wall, sign in inside Aside, say "done", and the agent continues. Anything a page returns is treated as untrusted content — the agent takes syntax from it, never instructions. /make-pdf, /diagram, and design previews print and screenshot through Aside too (served from your machine on loopback, one render per script), and the planning skills do their web research through Aside's own agent before reaching for a search tool.

When Aside isn't there, gstack's own browser takes over — automatically. Linux, Windows, or a Mac with Aside closed: the same skills use the bundled headless Chromium that ./setup builds, produce the same evidence, and light up the features below that only make sense when the browser is gstack's rather than yours.

Real browser mode. /open-gstack-browser launches GStack Browser, an AI-controlled Chromium with anti-bot stealth, custom branding, and the sidebar extension baked in. Sites like Google and NYTimes work without captchas. The menu bar says "GStack Browser" instead of "Chrome for Testing." Your regular Chrome stays untouched. All existing browse commands work unchanged. $B disconnect returns to headless. The browser stays alive as long as the window is open... no idle timeout killing it while you're working.

Sidebar agent — your AI browser assistant. Type natural language in the Chrome side panel and a child Claude instance executes it. "Navigate to the settings page and screenshot it." "Fill out this form with test data." "Go through every item in this list and extract the prices." The sidebar auto-routes to the right model: Sonnet for fast actions (click, navigate, screenshot) and Opus for reading and analysis. Each task gets up to 5 minutes. The sidebar agent runs in an isolated session, so it won't interfere with your main Claude Code window. One-click cookie import right from the sidebar footer.

Personal automation. The sidebar agent isn't just for dev workflows. Example: "Browse my kid's school parent portal and add all the other parents' names, phone numbers, and photos to my Google Contacts." Two ways to get authenticated: (1) log in once in the headed browser, your session persists, or (2) click the "cookies" button in the sidebar footer to import cookies from your real Chrome. Once authenticated, Claude navigates the directory, extracts the data, and creates the contacts.

Prompt injection defense. Hostile web pages try to hijack your sidebar agent. gstack ships a layered defense: content filters (datamarking, hidden-element stripping, ARIA scrubbing, URL blocklist) on every page read, plus a 22MB ML classifier running locally in a sidecar subprocess that scans page-derived content before the agent sees it, with a verdict combiner that requires classifier agreement before blocking (prevents single-model false positives on Stack Overflow-style instruction pages). Everything runs on your machine, no network calls. Emergency kill switch: GSTACK_SECURITY_OFF=1. See ARCHITECTURE.md for the full stack.

Browser handoff when the AI gets stuck. Hit a CAPTCHA, auth wall, or MFA prompt? $B handoff opens a visible Chrome at the exact same page with all your cookies and tabs intact. Solve the problem, tell Claude you're done, $B resume picks up right where it left off. The agent even suggests it automatically after 3 consecutive failures.

/pair-agent is cross-agent coordination. You're in Claude Code. You also have OpenClaw running. Or Hermes. Or Codex. You want them both looking at the same website. Type /pair-agent, pick your agent, and a GStack Browser window opens so you can watch. The skill prints a block of instructions. Paste that block into the other agent's chat. It exchanges a one-time setup key for a session token, creates its own tab, and starts browsing. You see both agents working in the same browser, each in their own tab, neither able to interfere with the other. If ngrok is installed, the tunnel starts automatically so the other agent can be on a completely different machine. Same-machine agents get a zero-friction shortcut that writes credentials directly. This is the first time AI agents from different vendors can coordinate through a shared browser with real security: scoped tokens, tab isolation, rate limiting, domain restrictions, and activity attribution.

Multi-AI second opinion. In Codex, gstack sends outside reviews to Claude Code through /claude-code. In Claude Code, /codex sends them to OpenAI Codex. Other harnesses expose both skills and use Codex where automatic outside reviews are supported. Each skill supports code review, adversarial challenge, and consultation with session continuity. Routing follows the harness, so changing your configured model does not change the outside reviewer. Reports identify the provider that actually completed each review; unavailable outside coverage remains visible.

Safety guardrails on demand. Say "be careful" and /careful warns before any destructive command — rm -rf, DROP TABLE, force-push, git reset --hard. /freeze locks edits to one directory while debugging so Claude can't accidentally "fix" unrelated code. /guard activates both. /investigate auto-freezes to the module being investigated.

Proactive skill suggestions. gstack notices what stage you're in — brainstorming, reviewing, debugging, testing — and suggests the right skill. Don't like it? Say "stop suggesting" and it remembers across sessions.

gstack is powerful with one sprint. It is transformative with ten running at once.

Conductor runs multiple Claude Code sessions in parallel — each in its own isolated workspace. One session running /office-hours on a new idea, another doing /review on a PR, a third implementing a feature, a fourth running /qa on staging, and six more on other branches. All at the same time. I regularly run 10-15 parallel sprints — that's the practical max right now.

The sprint structure is what makes parallelism work. Without a process, ten agents is ten sources of chaos. With a process — think, plan, build, review, test, ship — each agent knows exactly what to do and when to stop. You manage them the way a CEO manages a team: check in on the decisions that matter, let the rest run.

gstack skills have voice-friendly trigger phrases. Say what you want naturally — "run a security check", "test the website", "do an engineering review" — and the right skill activates. You don't need to remember slash command names or acronyms.

If gstack is installed on your machine:

~/.claude/skills/gstack/bin/gstack-uninstall

This handles skills, symlinks, global state (~/.gstack/), project-local state, browse daemons, and temp files. Use --keep-state to preserve config and analytics. Use --force to skip confirmation.

If you don't have the repo cloned (e.g. you installed via a Claude Code paste and later deleted the clone):

# 1. Stop browse daemons
pkill -f "gstack.*browse" 2>/dev/null || true

# 2. Remove per-skill directories whose SKILL.md points into gstack/
#    (rm -rf, not rmdir — installed dirs also contain runtime-asset links)
find ~/.claude/skills -mindepth 1 -maxdepth 1 -type d ! -name gstack 2>/dev/null |
while IFS= read -r dir; do
  link="$dir/SKILL.md"
  [ -L "$link" ] || continue
  target=$(readlink "$link" 2>/dev/null) || continue
  case "$target" in
    gstack/*|*/gstack/*)
      rm -rf "$dir"
      ;;
  esac
done
# Directories gstack created carry a .gstack-owned marker (the only signal on
# Windows, where installs are file copies with no symlink to read)
for marker in ~/.claude/skills/*/.gstack-owned; do
  [ -f "$marker" ] && rm -rf "$(dirname "$marker")"
done
# Alias skills install as copies (no symlink to detect) — remove by name
rm -rf ~/.claude/skills/_gstack-command ~/.claude/skills/connect-chrome 2>/dev/null

# 3. Remove gstack
rm -rf ~/.claude/skills/gstack

# 4. Remove global state
rm -rf ~/.gstack

# 5. Remove integrations (skip any you never installed)
rm -rf "${CODEX_HOME:-$HOME/.codex}/skills/gstack"* 2>/dev/null
rm -rf ~/.factory/skills/gstack* 2>/dev/null
rm -rf ~/.kiro/skills/gstack* 2>/dev/null
rm -rf ~/.openclaw/skills/gstack* 2>/dev/null
rm -rf ~/.cursor/skills/gstack* 2>/dev/null
rm -rf ~/.config/opencode/skills/gstack* 2>/dev/null

# 6. Remove temp files
rm -f /tmp/gstack-* 2>/dev/null

# 7. Per-project cleanup (run from each project root)
rm -rf .gstack .gstack-worktrees .claude/skills/gstack 2>/dev/null
rm -rf .agents/skills/gstack* .factory/skills/gstack* 2>/dev/null

Manual removal leaves gstack's hook entries behind in ~/.claude/settings.json (the uninstall script removes all of them for you, including entries whose _gstack_source tag was stripped). Edit that file and delete every hook whose command path points into .claude/skills/gstack/: the SessionStart auto-update hook, the AskUserQuestion PreToolUse/PostToolUse hooks, and the Stop hooks (session timeline, plus verify-gate if you opted in). Left in place, they error on every matching event once the install directory is gone.

The uninstall script does not edit CLAUDE.md. In each project where gstack was added, remove the ## gstack and ## Skill routing sections.

~/Library/Caches/ms-playwright/ (macOS) is left in place because other tools may share it. Remove it if nothing else needs it.

gstack never installed Aside, so it never uninstalls it. Keep it or remove it like any other app.

Free, MIT licensed, open source. No premium tier, no waitlist.

I open sourced how I build software. You can fork it and make it your own.

We're hiring. Want to ship real products at AI-coding speed and help harden gstack? Come work at YC — ycombinator.com/software Extremely competitive salary and equity. San Francisco, Dogpatch District.

GBrain is a persistent knowledge base for AI agents — think of it as the memory your agent actually keeps between sessions. GStack gives you a one-command path from zero to "it's running, my agent can call it."

/setup-gbrain

Four paths, pick one:

• Supabase, existing URL — your cloud agent already provisioned a brain; paste the Session Pooler URL, now this laptop uses the same data.
• Supabase, auto-provision — paste a Supabase Personal Access Token; the skill creates a new project, polls to healthy, fetches the pooler URL, hands it to gbrain init. ~90 seconds end-to-end.
• PGLite local — zero accounts, zero network, ~30 seconds. Isolated brain on this Mac only. Great for try-first; migrate to Supabase later with /setup-gbrain --switch.
• Remote gbrain MCP — your brain runs on another machine (Tailscale, ngrok, internal LAN) or a teammate's server; paste an MCP URL and bearer token. Optionally pair with a local PGLite for symbol-aware code search in split-engine mode. Best for cross-machine memory without standing up a local DB.

After init, the skill offers to register gbrain as an MCP server for Claude Code (claude mcp add gbrain -- gbrain serve) so gbrain search, gbrain put, etc. show up as first-class typed tools — not bash shell-outs.

Keeping the brain current. Run /sync-gbrain from any repo to re-index its code into gbrain (incremental by default, --full for a full reindex, --dry-run to preview). The skill registers the cwd as a federated source via gbrain sources add, runs gbrain sync --strategy code, and writes a ## GBrain Search Guidance block to your project's CLAUDE.md so the agent prefers gbrain search/code-def/code-refs over Grep. The block is removed automatically if the capability check fails — no stale guidance pointing at tools that aren't installed.

Per-remote trust policy. Each repo on your machine gets one of three tiers:

• read-write — agent can search the brain AND write new pages back from this repo
• read-only — agent can search but never writes (best for multi-client consultants: search the shared brain, don't contaminate it with Client A's work while in Client B's repo)
• deny — no gbrain interaction at all

The skill asks once per repo. The decision is sticky across worktrees and branches of the same remote.

GStack memory sync (different feature, same private-repo infra). Optionally pushes your gstack state (learnings, CEO plans, design docs, retros, developer profile) to a private git repo so your memory follows you across machines, with a one-time privacy prompt (everything allowlisted / artifacts only / off) and a defense-in-depth secret scanner that blocks AWS keys, tokens, PEM blocks, and JWTs before they leave your machine.

gstack-artifacts-init

Running gstack in Conductor? Conductor explicitly strips ANTHROPIC_API_KEY and OPENAI_API_KEY from every workspace's process env, so paid evals and gbrain embeddings won't work out of the box. Set GSTACK_ANTHROPIC_API_KEY and GSTACK_OPENAI_API_KEY in Conductor's workspace env config instead — gstack's TS entry points promote them to canonical names at runtime. Full details and the contributor checklist for adding the import to new entry points: Conductor + GSTACK_* env vars.

Full monty — every scenario, every flag, every bin helper, every troubleshooting step: USING_GBRAIN_WITH_GSTACK.md

Other references: docs/gbrain-sync.md (sync-specific guide) • docs/gbrain-sync-errors.md (error index)

gstack includes opt-in usage telemetry to help improve the project. Here's exactly what happens:

• Default is off. Nothing is sent anywhere unless you explicitly say yes.
• On first run, gstack asks if you want to share anonymous usage data. You can say no.
• What's sent (if you opt in): skill name, duration, success/fail, gstack version, OS. That's it.
• What's never sent: code, file paths, repo names, branch names, prompts, or any user-generated content.
• Change anytime: gstack-config set telemetry off disables everything instantly.
• Every off-machine send is receipted. Any gstack-initiated network send — telemetry included — writes a hash-chained, tamper-evident receipt to ~/.gstack/security/egress.jsonl before the send; sensitive sinks refuse to send at all if the receipt can't be written. Audit with gstack-egress list, verify the chain with gstack-egress verify (exit 3 on tamper), see the standing consent settings with gstack-egress grants. The ledger records attempted sends so accidents are auditable — it's an audit trail, not a network firewall.
• Optional third-party bridges are off by default and receipted too. The one that exists today, the Memorable recall bridge, hands your prompt to a locally installed vendor binary only after you run gstack-memorable enable; every hand-off writes a receipt first, the consent shows up in gstack-egress grants, and what the vendor then sends is documented as the vendor's claim.

Data is stored in Supabase (open source Firebase alternative). The schema is in supabase/migrations/ — you can verify exactly what's collected. The Supabase publishable key in the repo is a public key (like a Firebase API key) — row-level security policies deny all direct access. Telemetry flows through validated edge functions that enforce schema checks, event type allowlists, and field length limits.

Local analytics are always available. Run gstack-analytics to see your personal usage dashboard from the local JSONL file — no remote data needed.

Skill not showing up? Run ./setup --status from your gstack checkout. It prints every install (host, scope, version, skills directory, source checkout) and, for a stale, missing or unregistered row, the exact command that fixes it. The usual fix is to re-run setup from that row's source for that host, e.g. cd ~/.claude/skills/gstack && ./setup (Claude) or cd ~/gstack && ./setup --host codex. A project install lives in the project's .claude/skills/gstack or .agents/skills/gstack; run its setup from inside the project.

/browse (or /qa, /design-review) says NEEDS_ASIDE or ASIDE_NOT_RUNNING? That's the probe telling you it's about to use the fallback browser. Want Aside? Open the app and sign in — aside --version should print a version and aside repl 'console.log("ok")' should print ok — then re-run. gstack never installs it for you. Want the fallback on purpose while Aside is open? GSTACK_SKIP_ASIDE=1 makes every skill, the renderer, and ./setup treat Aside as absent.

/browse fails on the fallback browser? cd ~/.claude/skills/gstack && bun install && bun run build

/make-pdf or /diagram can't render? Same two paths: with Aside open they print through Aside (bun run ~/.claude/skills/gstack/bin/gstack-render.ts some.html --screenshot /tmp/out.png tests it directly, and its first line, ENGINE=aside or ENGINE=browse, names the browser that actually rendered); without it they use the bundled browser, so bun run build is the fix.

Stale install? Run /gstack-upgrade — or set auto_upgrade: true in ~/.gstack/config.yaml

State in the wrong place, or a setting that won't stick? ~/.claude/skills/gstack/bin/gstack-paths --explain shows which directory gstack uses for its state and why. See docs/state-root.md.

Want shorter commands? cd ~/.claude/skills/gstack && ./setup --no-prefix — switches from /gstack-qa to /qa. Your choice is remembered for future upgrades.

Don't use some skills? gstack-config set disabled_skills make-pdf,pair-agent stops registering them on every host, so their descriptions stop loading into each session. Claude Code updates right away; other hosts on their next ./setup --host <name> or /gstack-upgrade. Their files stay installed, so a skill that calls a disabled one still works (you get a warning). Typos are rejected with the closest skill name, gstack-upgrade can't be disabled, and gstack-config set disabled_skills "" re-enables everything.

Want namespaced commands? cd ~/.claude/skills/gstack && ./setup --prefix — switches from /qa to /gstack-qa. Useful if you run other skill packs alongside gstack.

Codex says "Skipped loading skill(s) due to invalid SKILL.md"? Your Codex skill descriptions are stale. ${CODEX_HOME:-~/.codex}/skills/gstack is a runtime directory, not the checkout: ./setup --status shows the Codex row's source checkout. Fix: cd <that source> && git pull && ./setup --host codex — for a repo-local install, run it from inside the project.

Windows users: gstack works on Windows 11 via Git Bash or WSL. Aside is macOS-only, so on Windows (and Linux) the browser skills, /make-pdf, and /diagram always use gstack's bundled browser. Node.js is required in addition to Bun — Bun has a known bug with Playwright's pipe transport on Windows (bun#4253). The browse server automatically falls back to Node.js. Make sure both bun and node are on your PATH. Native /cso additionally requires Windows PowerShell and Visual Studio 2022 Build Tools with the Desktop development with C++ workload; setup leaves that skill explicitly unavailable when they are absent.

On Windows without Developer Mode (MSYS2 / Git Bash), setup falls back to file copies instead of symlinks because ln -snf produces frozen copies that don't refresh on git pull. Re-run cd ~/.claude/skills/gstack && ./setup after every git pull so your skill files match the repo. setup prints a one-line note reminding you. Unix and WSL keep symlinks and don't need the re-run.

Chromium install failed or hung during ./setup? The bundled browser is best-effort: setup records the reason, finishes registering every skill, and prints which skills are affected (/qa, /qa-only, /design-review, /browse, make-pdf, /diagram, /pair-agent). With Aside open, the browser skills keep running in Aside and only the fallback engine is missing; /pair-agent always needs the bundled browser. Fix the cause and re-run ./setup. Knobs: GSTACK_PLAYWRIGHT_INSTALL_TIMEOUT=<seconds> raises the download bound (default 600) on slow links; GSTACK_SKIP_PLAYWRIGHT=1 skips the Chromium install entirely (CI, no-browser boxes); GSTACK_CHROMIUM_NO_SANDBOX=1 is the fix when Chromium installs but cannot launch because the host blocks unprivileged user namespaces (Ubuntu 24.04+ AppArmor default, #2157).

Setup ended with "Not registered (a skill you own already uses the name; left untouched)"? gstack only deletes or links over a skill entry it can prove it created: a symlink into gstack, a directory carrying the .gstack-owned marker ./setup writes into every directory it creates, or a SKILL.md that is byte-identical to gstack's or carries the generated <!-- AUTO-GENERATED from ... --> banner. A qa/ or ship/ you wrote yourself is left untouched by ./setup, gstack-relink, and both prefix-mode flips, and the linker names it in the final summary. Rename or move yours, or switch modes (./setup --prefix / --no-prefix) so the names stop colliding. If you started your own skill from a generated gstack SKILL.md and then edited it, that file is moved to ~/.gstack/backups/skills/<timestamp>/<skill>/SKILL.md before gstack's is linked in, never deleted.

Claude says it can't see the skills? Make sure your project's CLAUDE.md has a gstack section. Add this:

## gstack
Use /browse from gstack for all web browsing. Never use mcp__claude-in-chrome__* tools.
Available skills: /office-hours, /plan-ceo-review, /plan-eng-review, /plan-design-review,
/design-consultation, /design-shotgun, /design-html, /review, /deslop-shared-libs, /test-audit, /ship, /land-and-deploy,
/canary, /benchmark, /browse, /open-gstack-browser, /qa, /qa-only, /design-review, /scrape,
/setup-browser-cookies, /setup-deploy, /setup-gbrain, /sync-gbrain, /retro, /investigate,
/document-release, /document-generate, /codex, /cso, /autoplan, /pair-agent, /careful, /freeze,
/guard, /unfreeze, /gstack-upgrade, /learn.

MIT. Free forever. Go build something.