The Coe Lab
← Back to Opinion

Jujutsu Makes Git Workflows Flexible. Keep Reviews Rigorous.

By November 20, 20269 min read read
developer-toolsgitinfrastructure
A technology notebook with visual symbols for AI, cybersecurity, infrastructure, and automation

Jujutsu offers a different way to organize Git-backed work. Here is how to evaluate stacked changes, recovery, and integrations without weakening reviews.

Your version-control tool should make it cheaper to change your mind. Too often, the opposite happens: a developer spots a needed cleanup, remembers the branch juggling and history surgery involved, and postpones it. Jujutsu, the Git-compatible version-control system usually called jj, is interesting because it challenges that tax without requiring a team to abandon its existing remote repository. Its renewed attention is a useful moment to ask a practical question: can a better local workflow produce smaller, safer changes rather than merely faster commits?

A Jujutsu primer reached 122 points on Hacker News when checked on November 20. That is a signal of developer interest, not proof of production readiness or evidence that Git is obsolete. The useful story is narrower. Teams can evaluate a different model for organizing unfinished work while retaining Git-based collaboration. The Coe Lab's view is that this makes jj worth a bounded experiment, especially for infrastructure repositories where several dependent changes must remain understandable under review. Source: Hacker News discussion.

Background: a different interface, not a mandatory forge migration

The project's own documentation describes Git-backed repositories and interoperability with ordinary Git users. That distinction matters more than another list of keyboard shortcuts. Replacing a hosting platform touches authentication, permissions, automation, and organizational habits. Trying a local client can be a much smaller decision. Compatibility does not guarantee that every extension or workflow behaves identically, however; the official compatibility page documents partial support for some features and configuration. Source: Git compatibility documentation.

For a pilot, separate three questions. Can jj represent the repository's content? Can it coexist with the team's local tools? Can the resulting commits pass the existing review and delivery process? A yes to the first question does not settle the other two. An editor extension, release script, or compliance check may depend on behavior that is invisible during a simple clone-and-edit demonstration.

There is also an important difference between personal adoption and team standardization. One experienced contributor may use a new client successfully while everyone else continues unchanged. Requiring every contributor to learn it introduces training and support obligations. Treat those as separate rollout stages. The first experiment should discover whether the workflow fits, not manufacture momentum for a migration nobody has justified.

The working copy becomes a change you can organize

Jujutsu automatically snapshots working-copy changes during most commands, and newly added files are automatically tracked by default unless excluded. There is no conventional Git staging area. These are documented behaviors, not background autosave that records every keystroke. The distinction is important: files become part of a repository snapshot when the relevant command runs, rather than merely because they were typed into an editor. Source: Working-copy documentation.

The practical implication is that checkpointing and preparing a reviewable unit become different activities. A snapshot can preserve work before it is polished. The developer still has to decide which edits belong together and explain why. Removing the staging ritual does not remove editorial responsibility; it shifts that responsibility toward shaping changes after or while they are created.

Imagine a homelab repository containing a reverse-proxy configuration, an application manifest, and monitoring rules. You discover during an application update that a monitoring label is wrong. The tempting outcome is one large change mixing the upgrade and the unrelated fix. A better outcome is two coherent changes with distinct explanations. Evaluate whether the new workflow makes that separation easier when you are interrupted halfway through, not just when following a tutorial from a clean directory.

Automatic tracking also changes the moment at which exclusions need attention. Put generated output, local environment files, and credentials outside the tracked set before experimenting. Inspect the diff before sharing. A snapshot stored locally is not the same as a push, but accidentally recording sensitive material still creates cleanup work. The right response is an intentional repository layout and review habit, not an assumption that a more forgiving interface makes every file safe to capture.

Dependent changes need engineering judgment, even with automatic rebase

The project documents automatic rebasing of descendants when a commit is modified. For stacked work, that can remove repeated mechanical steps. Consider a three-part infrastructure change: introduce a configuration field, update the service to read it, and change deployment manifests to set it. A reviewer asks for a better field name in the first part. Updating downstream changes is exactly the kind of bookkeeping that can distract from the actual design discussion. Source: Project overview.

The benefit should be measured as less coordination overhead, not as permission to maintain an enormous stack. A long chain still creates review dependencies. If its foundation is uncertain, everything above it may need another look. Automation can move commits through a graph; it cannot establish that the interface chosen at the bottom is sensible or that reviewers understand the sequence.

Jujutsu can represent unresolved conflicts in commits rather than forcing every conflict to be resolved immediately. This provides scheduling flexibility, but the ability to keep working is not evidence that the code is ready. A merge that is textually clean can still be semantically wrong. Two changes may agree on syntax while disagreeing about a timeout unit, a default value, or who owns a resource. Source: Git comparison.

For deployment repositories, keep a concrete acceptance rule: every revision offered as independently deployable must validate independently. If a stack is intended to land together, state that explicitly and test the combined result. Do not let a convenient local history imply a release strategy. The operational question is whether there is a safe sequence of states in production, including rollback, rather than whether the graph looks tidy on a laptop.

Undo improves recovery, but it is not an external rollback

The operation log records repository-state changes and supports undo, reverting particular operations, and restoring an earlier repository view. This is a meaningful usability feature because it gives developers another way to inspect how they reached their current local state. The official documentation explains that the view includes pointers such as bookmarks and the working-copy commit. It is broader than simply remembering the text of the latest patch. Source: Operation-log documentation.

Our recommendation is to teach recovery before teaching clever history editing. In a disposable repository, make a change, perform a deliberate mistaken operation, inspect the log, and recover. Ask the participant to explain what was recovered. This turns undo from an emergency incantation into a skill with a known scope. Record the tool version and commands used so that the exercise remains reproducible.

The limit matters just as much. Restoring local repository state is not a transaction rollback for a remote forge, a deployment system, or another person's checkout. If an earlier push triggered an action elsewhere, local history recovery does not prove that action was reversed. The same distinction applies to database migrations and infrastructure controllers: their effects need their own recovery procedures.

Backups remain necessary for a different reason. A useful operation history on a failed or missing disk is not an accessible recovery copy. Preserve important work in appropriate remote storage, and keep deployment recovery information outside a single workstation. The new interface should reduce the cost of local mistakes without becoming the only place where unfinished but valuable work exists.

Git compatibility is a boundary to test, not a blanket promise

Jujutsu uses bookmarks as named revision pointers and maps them to Git branches when interacting with Git repositories. The documentation also notes that there is no currently checked-out bookmark in the Git sense. This is a conceptual difference worth learning explicitly. Starting work above a named point and publishing the intended result are not interchangeable actions; a pilot should include verifying exactly which revision the remote receives. Source: Bookmark documentation.

Start with a fresh disposable clone of a noncritical repository rather than a checkout already used for releases. Install a released jj version following the project's instructions, read that version's help, and note the version in the pilot record. Use the official Git compatibility and bookmark documentation to choose a workflow. The goal is not to memorize a command from a blog post that might age differently from the installed package.

Then exercise the real integrations. Open the repository in the normal editor, run the usual checks, publish to a test branch, and inspect the result through the normal forge. Check identity, signing requirements where applicable, required status checks, and how review comments behave after a revision changes. Test any repository-specific Git features actually in use instead of assuming that a successful push certifies all of them.

A practical pilot checklist looks like this:

  • Create a small documentation change and inspect the remote diff after publishing to a test branch.
  • Split an intentionally mixed change into two reviewable units and explain each unit without referring to the other.
  • Modify the foundation of a short stack, inspect every affected revision, and run the relevant validation again.
  • Introduce a deliberate conflict, identify it, resolve it, and verify the resulting behavior rather than only removing markers.
  • Rehearse local recovery with the operation log, then separately demonstrate recovery of any external test effects.
  • Return to the team's ordinary Git workflow and confirm that another contributor can continue the work without special intervention.

What This Means for developers, IT leaders, and homelabbers

For developers, the strongest case is reduced friction around keeping work understandable. Track the time spent reorganizing a change, the number of unrelated edits in review, and how often context switching produces recovery work. Compare similar tasks over a short trial. A subjective sense of speed is useful feedback, but it should not outweigh more difficult reviews or increased support requests from collaborators.

For IT leaders, the decision is about the supported delivery contract. A personal tool preference should not bypass protected branches, required checks, or accountability for the resulting artifacts. Allowing an opt-in client can be reasonable when the shared output remains conventional and support boundaries are clear. Making it the standard should require evidence that onboarding, debugging, and integration costs are justified by repeatable gains.

For homelabbers, the attraction is smaller experiments. You can explore a service upgrade without turning a weekend project into an unreadable accumulation of changes. Keep secrets separate, validate manifests, and retain a known-good deployment state. If version-control experimentation and a live network migration happen in the same session, debugging becomes unnecessarily ambiguous. Learn the client on harmless content before using it during an outage.

For AI-assisted development, the same principles apply with more urgency, not less. It is easy to imagine an assistant generating several dependent patches and revising their foundation repeatedly. A flexible history model may make that manageable, but this is an architectural inference, not a benchmark result. Give each worker a clear ownership boundary and require explicit review before remote publication. A capable version-control client is not a substitute for task isolation or authorization.

Looking forward: judge the workflow by the review it leaves behind

What should readers watch next? The useful signals are integration quality, documentation for released versions, predictable recovery, and how effectively teams can explain their workflows to newcomers. A growing discussion thread is a reason to investigate, not a reason to declare a winner. Tool adoption becomes durable when ordinary maintenance becomes easier after the novelty has worn off.

The broader lesson is that version control has two audiences: the person making a change and the person who must understand it later. Optimizing only the first audience can produce fast but exhausting delivery. Jujutsu's model offers an opportunity to make local iteration more forgiving. The payoff, if a pilot succeeds, should be clearer commits, smaller reviews, and less fear of correcting a design before it ships.

Try it on one repository with one collaborator and one explicit exit condition. Keep it if it reduces recovery and review effort without weakening delivery guarantees. Stop if the surrounding tooling or support burden consumes the benefit. Git compatibility makes an incremental evaluation possible; engineering discipline determines whether that evaluation turns into a better way of working.

Related Posts

CVE-2026-123890: VMware vCenter authentication bypass exploited since September — CISA patch deadline is November 23

A critical unauthenticated vCenter Directory Service flaw was used in real intrusions weeks before disclosure. CISA gives federal agencies until November 23 — everyone else should not wait longer.

Nov 22, 2026• 12 min

Your USB-C Dock Is Part of Your Network. Test It That Way.

A trending Ethernet investigation shows why docks belong in your network diagram. Here is how to isolate bottlenecks before replacing routers or adapters.

Nov 22, 2026• 9 min

CVE-2026-129448: Apache Roller XML-RPC deserialization gets CISA KEV deadline — unauthenticated remote code execution in versions before 6.1.5

Apache Roller before 6.1.5 runs unauthenticated XML-RPC deserialization before authentication; it is now on CISA's exploited list with a patch deadline of November 23, 2026.

Nov 21, 2026• 11 min