gitstackBETA
Sign in

Code is moving faster than review.

GitStack splits one branch into small, ordered reviews that humans and agents can finish, then lands them in order. Underneath it is plain Git, synced both ways with GitHub, so anyone still on GitHub can keep opening pull requests.

gitstack BETA A acme / billing-service
Navigate 1 files
Stack -
main base
Files 1 · vs R1
M store.go billing/ +486 -3
Comments 0 open · 1 resolved
store.go:14 resolved
Wrap the insert in a transaction.
add-billing browse files · OPEN R2 · acme · pushed patch 2 Sep 24
billing: persistence layer
1 file · +486 -3
@@ -1,11 +1,19 @@
1 1 package billing
2 2
3 3 import (
4 4 "context"
5 "fmt"
5 6 )
6 7
7 // CreateSubscription stores a subscription.
8 // CreateSubscription stores a subscription and its plan in one transaction.
8 9 func (s *Store) CreateSubscription(ctx context.Context, sub Subscription) error {
9 _, err := s.db.ExecContext(ctx, insertSubscription, sub.ID, sub.Plan)
10 return err
10 tx, err := s.db.BeginTx(ctx, nil)
11 if err != nil {
12 return fmt.Errorf("begin: %w", err)
13 }
14 defer tx.Rollback()
15 if _, err := tx.ExecContext(ctx, insertSubscription, sub.ID, sub.Plan); err != nil {
16 return err
17 }
18 return tx.Commit()
11 19 }
Patch 2 of 2 ▾ vs parent R1 ▾ 0 LGTM ▾

Try it: click a review, LGTM, then Land.

A 2,000-line pull request is a review nobody finishes.

You open it, see it is too much to hold in your head, skim for anything that looks dangerous, and approve. GitStack keeps the one branch you work on and carves it into small reviews, one idea each, each small enough to read properly.

Stack add-billing
main base
R1 open LGTM+312
billing: subscription model
R2 open LGTM+486 -3
billing: persistence layer
R3 open LGTM+540
billing: POST /api/billing
R4 open LGTM+703 -2
billing: webhook handler
4 reviews ·+2,041 -5 Land Land 4 reviews

One review for everything. Nobody finishes it. Same branch, four reviews. Each one lands on its own.

Commit normally. Carve reviews. Land in order.

If you know git add, git commit and git switch, you know most of gs. Commit as you go, group commits into reviews when they make one idea, and keep working on the same branch.

$ gs switch -c add-billing
$ gs add internal/billing/model.go
$ gs commit -m "billing: subscription model"
$ gs add internal/billing/store.go
$ gs commit -m "billing: persistence layer"
$ gs review create -t "billing: model and storage"
R1 patchset 1 (initial, 2 commits)
$ gs stack
> R2 wip billing: subscription API ps1 1 thread
R1 ready billing: model and storage ps1 LGTM 1
next: gs submit R1
# later, once R2 is approved too
$ gs submit --stack
submitted R1 → 3f9c2e1
submitted R2 → a41d7b0

Still a plain Git repo.

Your code lives in an ordinary Git repository, and GitStack speaks the Git protocol, so stock Git can clone, fetch and push it with no gs installed. Reviews, comment threads and LGTMs are kept on the server, where gs, the web UI and the API read them.

$ git clone https://gitstack.sh/you/app.git
# every branch and commit, with stock Git and no gs installed

GitHub stays in the loop.

Link a repository and GitStack keeps it in step with GitHub. Teammates who haven't switched keep opening pull requests there, and those show up in GitStack as reviews. Your comments, merges and closes go back to GitHub as you, and issues and CI checks stay in sync.

GitStack System of record
GitHub Synced both ways
  • Issue #42 flaky login
    Issue #42 flaky login
  • Review gh-pr/128 · add retries
    PR #128 add retries
  • Comment "needs a test"
    Comment "needs a test" as you
  • Check ci passed
    Check ci passed
  • Merged gh-pr/128
    Merged #128 add retries
  • Landed R3 fixes #42
    Closed #42 flaky login

Fix a lower review. Everything above follows.

Check out the review with the comment, amend it, push. Reviews above it rebase automatically, and approvals stick when only the base moved. You never run git rebase by hand.

# reviewer on r2: "this isn't constant-time."
$ gs checkout r2
$ gs amend -m "use crypto/subtle" --resolves C008
amended r2. r3 rebased.
$ gs push
r2 patchset 2 (revised, slice content changed)
r3 patchset 2 (rebased, slice content unchanged)
$ gs top
Stack -
main base
R1 open LGTM auth: user model
R2 open LGTM resolved revised auth: password hashing
R3 open LGTM rebased auth: login endpoint
Back at the top. Nothing to re-review in R3.
extended New commits on top of the slice. Read the new part.
revised The slice's own content changed, so the approval resets.
rebased Only the base moved, so the approval stays.

Your agent drives the same gs commands.

There is no separate agent API. Install the skill once and a coding agent learns the gs workflow. Ask it in plain language, and it uses gs status and the next: hints to stay oriented.

$ gs skill install ~/.claude/skills/
# writes ~/.claude/skills/gitstack/SKILL.md
# that path is where Claude Code looks.
# pass another directory for a different agent.

Install it before you hand an agent a repo. Without it, agents reach for git commit and git rebase out of habit, which goes around the stack.

"Split this branch into reviews." gs autostack
"Respond to the comments on r2." gs review comments r2
"Land the stack." gs submit --stack

Search, review and land from the browser.

Find code from one search box, follow a name to every use, comment on a line, approve and land. Every step also works from gs, so each person and agent can use what suits them.

Click to try the live demo Tap to open the live demo
Open the live demo

Free for open source and small teams.

Every feature is included, and you pay only for the people on your private repos.

Start free
Compare features See every limit and price for Free, Pro and Enterprise.
FeatureFreeProEnterprise
Price
Per member, monthly$0$12Custom
Per member a month, billed annually$0$10Custom
Stacking workflow
gs CLI: split, fold, reorder, amend mid-stack
Worktrees and one-command recovery
Review UI: comments, threads, LGTM
Live updates over SSE
Automerge
Re-review requests
GitHub issues and PRs mirrored in (read-only)
Two-way GitHub sync
Post to GitHub as yourself
Agent skill install
Repos and limits
Members on private repos310Unlimited
Members on public reposUnlimitedUnlimitedUnlimited
Repos and storageFair useFair useCustom
Plan
Priority support
Custom pricing and invoicing

Prices are in USD. Fair-use limits apply to repos, storage, traffic and automation, and the docs have the details.

Questions from GitHub users

What is GitStack?

GitStack is a code host like GitHub, built around reviewing stacked changes. You work on one branch as usual, split it into small reviews that each do one thing, and the reviews land in order from the bottom of the stack up.

Does GitStack store a copy of my code?

Yes, GitStack is a code host, so it stores a full copy of your repo the way GitHub does. When you link a GitHub repo, the copy on GitStack becomes the main one and GitHub keeps a mirror of it in sync.

How is a review different than a pull request?

A pull request covers every commit on a branch, so the reviewer has to read all of it at once. A GitStack review covers one small slice of a branch, and a branch holds a stack of them that reviewers read and approve one at a time. When you fix a lower review, GitStack rebases the reviews above it, and they keep their approvals if only their base moved.

Do I have to leave GitHub?

You don't have to leave GitHub, because GitStack keeps a linked repo in sync with it. GitStack holds the main copy and the GitHub repo stays connected as a mirror, so issues, comments and CI checks move in both directions.

Can my teammates keep using GitHub?

Teammates who haven't switched can still open pull requests on GitHub, and GitStack shows those as reviews. Your comments, merges and closes post back to GitHub under your account.

Does my CI keep working?

Your CI runs on GitHub as it does today, and GitStack syncs the check results back in.

Do I need to learn a new tool?

GitStack adds one CLI, gs, whose commands mirror Git's, such as gs add, gs commit and gs push. You can also review, comment and land from the browser, and a coding agent learns gs from a skill you install once.

What if I stop using it?

Your repo is an ordinary Git repo. If you leave, you can clone it with stock Git and push it anywhere, and you keep every branch and commit. Reviews and comment threads are kept on GitStack's server, and the API returns every one of them. Every plan, including Free, can export at any time.

Can I self-host it?

GitStack doesn't offer a self-hosted build today, and the gs CLI is closed source.

Questions about pricing

Is any feature paid?

Every plan includes stacking, review, automerge, two-way GitHub sync and agent skills. Paid plans raise the number of people who can work in your private repos.

Is open source free?

Public repos are free on every plan, and anyone can review and contribute to them without taking a seat. Fair-use limits on storage and traffic still apply.

Does the free plan expire?

The free plan doesn't expire because it isn't a trial, and you don't need a card to sign up.

What does Pro cost?

Pro costs $12 per member a month, or $10 billed annually, for up to 10 members on your private repos.

What does fair use mean?

Repos, storage and traffic have ceilings that keep one account from slowing GitStack down for everyone else, and the limits page lists them. If you need more, email [email protected] and we can raise them.

Why does GitStack cost money?

A solo developer builds GitStack, so it can't fund a large free tier with revenue from big customers the way large companies do, and paid plans cover the cost of running it. In return, all of the work goes into making GitStack better to use, and GitStack doesn't sell your data or use it for anything except running the service.

What if I need more than Pro?

Enterprise has unlimited members, storage sized to your team, priority support and invoicing. Email [email protected] to set it up.

Try it on your next branch.

Install the CLI curl -fsSL https://gitstack.sh/install.sh | sh