Quick Start

This guide will get you productive with LazyJJ in 5 minutes. Mastering the mental model takes 4-8 hours, but it’s worth it—JJ makes version control finally make sense.

Understanding JJ’s Model (Read This First!)

Before diving into commands, understand the key difference:

In Git:

Edit files → git add → git commit
(staging area prepares for future commit)

In JJ:

Edit files → (changes automatically in commit)
jj new → (start next commit)

Your working copy IS a commit, not a staging area preparing for one. When you edit files, you’re editing the commit directly. No git add needed—everything is automatic.

This feels strange for the first few hours. Then it clicks, and you’ll wonder how you tolerated Git’s complexity. Give it time.

Want deeper explanation? Read the Mental Model guide after finishing this quickstart.

Your First Commands

After installing LazyJJ, try these commands in any JJ repository:

# Check status (shortcut: jj st)
jj status

# View recent history (shortcut: jj l)
jj log-short

# View changes (shortcut: jj d)
jj diff

Creating Commits

# Create a new commit
jj new -m "Add awesome feature"

# Edit your changes
vim src/feature.js

# View them
jj diff
# ✨ Notice: No `git add` needed!
# Your changes are automatically part of the commit

# Describe your commit (you can do this multiple times)
jj describe -m "Add awesome feature

- Implement core logic
- Add error handling"

# Create next commit
jj new -m "Add tests"

Key insight: jj new seals the current commit and starts a fresh one. Think of it as “finalize and move to next.”

Basic Revsets You’ll Use Daily

Revsets are JJ’s query language for selecting commits. You’ll use these constantly:

Revset	Meaning	Example Use
`@`	Current commit (where you are now)	`jj diff -r @`
`@-`	Parent of current commit	`jj new @-` (new commit from parent)
`@+`	Child of current commit (if only one)	`jj edit @+`
`main..@`	Commits between main and current	`jj log -r "main..@"`
`stack`	Your current stack (LazyJJ alias)	`jj log -r stack`

Examples:

# See commits in your current stack
jj log -r stack

# Diff against main
jj diff -r "main..@"

# Create new commit from parent
jj new @-

# See what's in current commit
jj diff -r @

Need more complex queries? See Advanced Revsets.

Working with Stacks

A “stack” is the series of commits from trunk to your current position:

# View your current stack
jj stack-view

# Navigate to the top of your stack
jj stack-top

# Navigate to the bottom
jj stack-bottom

# Sync your stack with the latest trunk
jj stack-sync

Starting Fresh

# Fetch latest and start from trunk
jj stack-start

Viewing All Your Work

# View all your stacks (all mutable commits you own)
jj stacks-all

GitHub Workflow

If you have GitHub CLI (gh) installed:

# View current PR
jj pr-view

# Open PR in browser
jj pr-open

# Create/update stacked PRs
jj pr-stack-create

Experimentation is Safe

Made a mistake? Undo it:

jj undo

Everything in JJ is recorded in the operation log. You can undo any operation. This makes JJ one of the safest version control systems ever created.

# See your operation history
jj op log

# Restore to any previous state
jj op restore <operation-id>

Learn more: Operation Log guide

Common Beginner Mistakes

Avoid these pitfalls during your first few hours:

Don’t use git commands - Use jj equivalents. Git doesn’t understand JJ’s operation log. Details
Bookmarks don’t auto-follow - Unlike Git branches, you must manually move bookmarks with jj bookmark set. Details
Use jj new to finalize commits - jj describe just sets the message. Use jj new to start the next commit. Details
Trust jj undo - Experiment freely. The operation log makes everything reversible. Details

Full list: Common Mistakes guide

The Learning Curve (It’s Worth It)

Research across 20+ guides shows a consistent pattern:

Minutes 1-30: Confusion (“Where’s git add?”)
Hours 1-4: Awkwardness (muscle memory fights you)
Hours 4-8: The “click” (suddenly it makes sense)
After 8 hours: “I’ll never go back to Git”

One developer: “I became comfortable enough with jj to replace git entirely in one day.”

Don’t fight the model. Let it feel strange for a few hours. Your Git habits will adapt.

Next Steps

Essential Reading (10 minutes)

Mental Model - Understand why JJ works this way
Operation Log - Your safety net explained
Common Mistakes - Avoid frustration

Learn the Workflow (30 minutes)

Create a Stack - Build stacked PRs
Navigate Stacks - Move between commits
Edit Mid-Stack - JJ’s killer feature

Reference Material

All Aliases - Command shortcuts
Stack Commands - Complete stack workflow
Advanced Revsets - Complex queries

Integrations

GitHub Integration - Stacked PRs
Claude Integration - AI-assisted development

Give yourself 4-8 hours with JJ. The “aha moment” is real, and it’s worth the initial learning curve.

Project by Ernesto Jiménez Bluesky GitHub