home / skills / outfitter-dev / agents / stacks

stacks skill

/plugins/gt/skills/stacks

This skill helps you manage trunk-based development with stacked PRs using Graphite CLI, ensuring correct gt workflows and fast recovery.

npx playbooks add skill outfitter-dev/agents --skill stacks

Review the files below or copy the command above to add this skill to your agents.

Files (3)
SKILL.md
4.4 KB
---
name: graphite-stacks
description: This skill should be used when the user asks to "create a stack", "submit stacked PRs", "gt submit", "gt create", "reorganize branches", "fix stack corruption", or mentions Graphite, stacked PRs, gt commands, or trunk-based development workflows.
metadata:
  version: "1.0.0"
  author: outfitter
  category: version-control
---

# Graphite Stacks

Trunk-based development with stacked PRs using Graphite CLI.

<when_to_use>

- Creating or managing branch stacks
- Submitting stacked PRs
- Reorganizing branch relationships
- Addressing PR feedback across a stack
- Recovering from stack corruption
- Any `gt` command usage

</when_to_use>

## Core Principle

**Use `gt` commands exclusively.** Mixing `git` and `gt` causes sync issues and divergent stacks. The only exception: `git add` for staging (or use `-a` flags).

## This, Not That

| Task | This | Not That |
| ---- | ---- | -------- |
| Create branch | `gt create 'name' -am "msg"` | `git checkout -b name` |
| Commit changes | `gt modify -acm "msg"` | `git commit -m "msg"` |
| Push to remote | `gt submit` | `git push` |
| Rebase stack | `gt restack` | `git rebase` |
| View stack | `gt status` or `gt ls` | `git log --graph` |
| Switch branches | `gt checkout` | `git checkout` |
| Amend commit | `gt modify -a` | `git commit --amend` |
| Multi-PR feedback | `gt top && gt absorb -a` | Cherry-pick commits manually |

## Stack Lifecycle

```
Create stack → Implement features → Submit PRs → Address feedback → Merge
     │              │                  │               │            │
     ▼              ▼                  ▼               ▼            ▼
 gt create     gt modify -acm     gt submit      gt absorb     gt sync
```

## Creating Stacks

```bash
# New branch with staged changes
gt create 'feature/step-1' -am "feat: first step"

# Continue stacking
gt create 'feature/step-2' -am "feat: second step"
gt create 'feature/step-3' -am "feat: third step"

# Insert branch between current and child
gt create 'feature/step-1.5' --insert -am "feat: inserted step"
```

## Navigation

| Command | Action |
| ------- | ------ |
| `gt up` | Move up the stack (toward children) |
| `gt down` | Move down the stack (toward parent) |
| `gt top` | Jump to stack top |
| `gt bottom` | Jump to stack bottom |
| `gt checkout` | Interactive branch picker |

## Modifying Branches

```bash
# Amend current branch (stages all)
gt modify -a

# New commit within same branch
gt modify -acm "fix: address review feedback"

# Commit to a different branch in the stack
git add path/to/file.ts
gt modify --into target-branch -m "feat: add file"
```

<rules>

**ALWAYS:**
- Use `gt create` for new branches
- Use `gt modify` for commits
- Use `gt submit` to push
- Use `gt restack` after parent changes
- Check `gt status` when uncertain

**NEVER:**
- Mix `git commit/push/rebase` with `gt` workflows
- Force push without understanding stack state
- Use `git rebase -i` (breaks Graphite metadata)

</rules>

## Addressing Review Feedback

**Single PR**: Navigate to branch, modify directly

```bash
gt checkout target-branch
gt modify -acm "fix: address review comment"
gt submit
```

**Multiple PRs in stack**: Use absorb from top

```bash
gt top
git add .
gt absorb -a
gt submit --stack
```

Graphite routes changes to correct branches based on file history.

## Reorganizing Stacks

```bash
# Move branch to different parent
gt move --onto new-parent

# Move specific branch
gt move --source branch-name --onto target

# After reorganization
gt restack
```

## Submitting

```bash
# Current branch + downstack
gt submit

# Entire stack
gt submit --stack

# Non-interactive (automation)
gt submit --no-interactive
```

## Stack Visualization

```bash
# JSON with parent relationships (preferred for scripts)
gt status

# Visual tree
gt ls

# Recent history
gt log
```

## Sync and Maintenance

```bash
# Pull trunk, rebase stacks, clean merged
gt sync

# Rebase branches onto updated parents
gt restack

# Undo last gt operation
gt undo
```

## When Things Go Wrong

Stack corruption symptoms:
- Branches appear as siblings instead of parent-child
- PRs contain wrong files
- `gt status` shows unexpected structure

See [recovery.md](references/recovery.md) for step-by-step recovery procedures.

<references>

- [commands.md](references/commands.md) - Quick command reference
- [recovery.md](references/recovery.md) - Stack corruption recovery

</references>

Overview

This skill helps create, manage, and recover Graphite stacked-PR workflows using the gt CLI. It enforces using gt commands (with git add allowed for staging) to avoid stack divergence and simplifies creating, submitting, and reorganizing branch stacks.

How this skill works

The skill guides developers through lifecycle actions like gt create, gt modify, gt submit, gt restack, and gt status. It inspects the requested operation (create stack, submit stacked PRs, reorganize branches, fix corruption, or run gt commands) and returns the correct gt commands and recovery steps tailored to the scenario.

When to use it

  • Creating a new stacked branch or inserting a branch into a stack
  • Submitting a single PR or an entire stacked PR series (gt submit / gt submit --stack)
  • Reorganizing parent-child relationships or moving branches onto a different parent
  • Addressing review feedback across one or multiple PRs in a stack
  • Recovering from stack corruption or unexpected gt status output
  • Any interaction that involves gt commands or trunk-based stacked PR workflows

Best practices

  • Use gt commands exclusively for branch, commit, rebase, and submit operations (git add is allowed for staging)
  • Run gt status or gt ls before operations when uncertain about stack shape
  • After changing a parent, run gt restack to rebase child branches cleanly
  • When addressing multi-PR feedback, use gt top + gt absorb -a rather than cherry-picking
  • Avoid git rebase -i or manual git pushes that can break Graphite metadata

Example use cases

  • Create a three-step feature stack with gt create 'feature/step-1' -am ... then gt create subsequent steps
  • Insert a branch between two stack nodes using gt create --insert -am "msg"
  • Submit the entire stack for CI with gt submit --stack or submit a single branch with gt submit
  • Move a branch to a new parent and fix ordering with gt move --source name --onto parent && gt restack
  • Recover from stack corruption by inspecting gt status, identifying siblings where parent-child expected, and following recovery steps

FAQ

Can I mix git and gt commands?

No. Mixing git commit/push/rebase with gt causes divergence. The only allowed git command is git add for staging.

How do I apply review feedback across multiple PRs?

Jump to the top of the stack (gt top), stage changes, run gt absorb -a to route changes into the right branches, then gt submit --stack.