Stacked Changes

Stacked changes are JJHub’s premiere feature and a core reason to use jj over git. They’re essential for AI workflows, where agents naturally produce incremental, dependent changes at machine speed.

Why Stacked Changes?

In git, managing dependent branches requires constant rebasing, conflict resolution, and force-pushing. Each rebase produces new commit hashes, breaking downstream references. In jj:

Rebase is automatic - edit any change in the stack and descendants rebase seamlessly
Change IDs are stable - no matter how many times you rewrite, the Change ID persists
Conflicts are tracked - if a rebase creates a conflict, jj records it rather than blocking

This means agents can produce a chain of 10 incremental changes, and the platform tracks, reviews, and lands them without the friction git imposes.

Creating a Stack

# Start from main
jj new main -m "Add user model"
# ... make changes to define the User struct ...

jj new -m "Add auth middleware"
# ... make changes to implement auth ...

jj new -m "Add login endpoint"
# ... make changes to wire up the route ...

jj new -m "Add tests"
# ... add test files ...

Each jj new creates a child change. The result is a linear stack:

main
  └── Add user model (qzknlmop)
        └── Add auth middleware (rvwxyz)
              └── Add login endpoint (abcdef)
                    └── Add tests (ghijkl)

Viewing the Stack

Use jj log to see your stack:

jj log

Or use the JJHub CLI to see changes:

jjhub change list
jjhub change show qzknlmop
jjhub change diff qzknlmop

Pushing a Stack

Push all bookmarks (and the stack) to JJHub:

jj git push --all

Landing a Stack

Create a landing request for the entire stack:

jjhub land create --title "User authentication" --target main --stack

The --stack flag automatically detects all changes in the stack and includes their Change IDs. The landing request will display:

stack_size - number of changes in the stack
change_ids - the stable IDs for every change

Reviewers can see each change individually and review the incremental diffs.

Editing a Change Mid-Stack

One of jj’s strengths is editing any change in the stack without disrupting the rest:

# Edit a specific change by its Change ID
jj edit qzknlmop

# Make your modifications...

# Return to the latest change
jj edit ghijkl

All descendant changes automatically rebase on top of your edit. If the edit creates a conflict, jj records it in the graph rather than blocking - you can resolve it later.

Stacked Changes and AI Agents

Stacked changes are essential for AI workflows:

An agent produces a plan as a sequence of incremental changes
Each change is a discrete, reviewable unit
The human reviews the plan (the stack structure) rather than line-by-line diffs
The agent executes, producing the full stack
CI validates each change independently
The stack lands as a unit via jjhub land land

This is the workflow JJHub is built for - agents working at speed, humans reviewing at the plan level, and the platform handling the mechanics.

Overview

Getting Started

Guides

Stacked Changes

Stacked Changes

Why Stacked Changes?

Creating a Stack

Viewing the Stack

Pushing a Stack

Landing a Stack

Editing a Change Mid-Stack

Stacked Changes and AI Agents

​Stacked Changes

​Why Stacked Changes?

​Creating a Stack

​Viewing the Stack

​Pushing a Stack

​Landing a Stack

​Editing a Change Mid-Stack

​Stacked Changes and AI Agents

Stacked Changes

Why Stacked Changes?

Creating a Stack

Viewing the Stack

Pushing a Stack

Landing a Stack

Editing a Change Mid-Stack

Stacked Changes and AI Agents