gt-stack
Analyze changes and organize them into a Graphite stack of logically isolated PRs
Best use case
gt-stack is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Analyze changes and organize them into a Graphite stack of logically isolated PRs
Teams using gt-stack should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/gt-stack/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How gt-stack Compares
| Feature / Agent | gt-stack | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Analyze changes and organize them into a Graphite stack of logically isolated PRs
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
Analyze the current changes and organize them into a Graphite stack of logically isolated branches, each becoming its own PR.
## Steps
### Phase 1: Assess
1. Run `gt ls` to see the current stack state
2. Run `git status` to see staged, unstaged, and untracked files
3. Run `git diff --stat` and `git diff --staged --stat` for an overview
4. Run `git diff` and `git diff --staged` to read the actual diffs
5. If $ARGUMENTS contains `commits:N`, also run `git log --oneline -N` and `git diff HEAD~N..HEAD`
6. Run `git log --oneline -5` to understand the commit style
### Phase 2: Propose a split plan
7. Group changes into logically isolated units. Each unit should:
- Touch a single concern (one feature, one fix, one refactor)
- Be independently reviewable
- Have a clear conventional commit message
8. Present the plan (bottom → top):
```
Proposed stack (bottom → top):
1. feat(scope): description — files: path/to/file.lua
2. fix(scope): description — files: path/to/other.zsh
```
9. Ask the user to confirm, modify, or reorder before proceeding
### Phase 3: Execute the stack
10. For each entry (bottom to top):
- Stage the specific files with `git add <file>`
- Run `gt create <branch-name> -m "type(scope): description"`
- Verify with `gt ls`
11. Show the final stack with `gt ls`
### Phase 4: Optional submit
12. Ask if the user wants to submit the stack as PRs
13. If yes: `gt submit --stack` (or `gt submit --stack --draft` for drafts)
14. Output the stack summary
## Handling commits:N
When reorganizing existing commits:
- Ensure working tree is clean (stash if needed)
- Use `gt branch split --by-commit` to decompose
- Always show a dry-run plan and get explicit confirmation
## Rules
- NEVER run `gt submit` without explicit user confirmation
- NEVER use `git add .` or `git add -A` — always add specific files
- ALWAYS present the split plan and wait for confirmation before creating branches
- ALWAYS use conventional commits: feat, fix, chore, docs, refactor, test
- ALWAYS end commit messages with: `Co-Authored-By: Claude <noreply@anthropic.com>`
- If the working tree is dirty and there is an existing stack, warn before modifying
- If `gt` is not installed, suggest: `brew install withgraphite/tap/graphite`
- Prefer smaller, focused branches — that's the whole point of stacking
- When unsure how to split, ask the userRelated Skills
tech-stack
Specifies the technologies to be used for backend development, including Node.js, Express.js, MongoDB, and Mongoose.
stacks
Stack-specific skills organized by technology category (backend, frontend, infrastructure, mobile)
senior-fullstack
Comprehensive fullstack development skill for building complete web applications with React, Next.js, Node.js, GraphQL, and PostgreSQL. Includes project scaffolding, code quality analysis, architecture patterns, and complete tech stack guidance. Use when building new projects, analyzing code quality, implementing design patterns, or setting up development workflows.
laravel-tall-stack-best-practices-cursorrules-prom-cursorrules
Apply for laravel-tall-stack-best-practices-cursorrules-prom. --- description: Laravel specific best practices for different modules and features. globs: /**/*.php
fullstack-validation
Comprehensive validation methodology for multi-component applications including backend, frontend, database, and infrastructure
fullstack-guardian
Use when implementing features across frontend and backend, building APIs with UI, or creating end-to-end data flows. Invoke for feature implementation, API development, UI building, cross-stack work.
fullstack-feature
Load PROACTIVELY when task involves building a complete feature across multiple layers. Use when user says "build a feature", "add user profiles", "create a dashboard", or any request spanning database, API, UI, and tests. Orchestrates multi-agent work sequentially: schema and migrations, API endpoints, UI components, tests, and review. The runtime engine handles WRFC chains automatically via <gv> directives. Handles dependency ordering and cross-layer type sharing.
Fullstack Developer
End-to-end development covering both frontend (React/Vue) and backend (Node.js/Python/etc.), API design, and database integration.
fullstack-dev-skills
Use when building full-stack applications requiring frontend, backend, DevOps, security, AI Agent, or ML expertise. Invoke for Vue, React, Node.js, Docker, Kubernetes, authentication, database optimization, RAG, or long-running agent patterns.
agent-fullstack-developer
End-to-end feature owner with expertise across the entire stack. Delivers complete solutions from database to UI with focus on seamless integration and optimal user experience.
stackone-agents
Build AI agents that call StackOne-linked accounts using TypeScript SDK, Python SDK, MCP server, or A2A protocol. Use when user asks to "add StackOne tools to my agent", "set up MCP with StackOne", "list employees from BambooHR in my agent", "integrate StackOne with OpenAI", "build a multi-tenant agent", or "use StackOne with LangChain". Supports OpenAI, Vercel AI SDK, Claude, LangChain, CrewAI, PydanticAI. Do NOT use for account linking setup (use stackone-connect) or platform management (use stackone-platform).
bgo
Automates the complete Blender build-go workflow, from building and packaging your extension/add-on to removing old versions, installing, enabling, and launching Blender for quick testing and iteration.