Skip to content

Checking in: change vs lane

Once you've met the change model, one practical question still trips almost everyone up on the way over from Git:

"When I check in my work, am I checking in a change or a lane — and what's the difference?"

Git answers with a single action (git commit). TOVIO splits it into two verbs — and that split is the difference between "rebase terrifies me" and "rebase is Tuesday." Ten minutes here saves a lot of confusion later.

The short version

  • A change is the unit of work — a stable chg: id that survives every rewrite.
  • A lane is a movable pointer — a name for "the integrated tip of a line of work."
  • tovio commit checks in the change. tovio land checks in the lane. Git's git commit does both at once.

Mental model

A change is a shipping tracking number: the package's contents and route can change, but the number stays constant, so you can always follow this package. A lane is a bookmark that marks "the latest official version is → here." commit packs and labels the parcel; land slides the bookmark to include it.

Two verbs, not one

People say "check in" for any act of recording work. In Git that's always one action. In TOVIO it's two, and they have different scopes:

You want to… In Git In TOVIO What actually happens
Finalize this unit of work git commit (also moves the branch) tovio commit — check in the change** The current change is frozen as a snapshot and keeps its chg: id; the next change opens on top. No shared lane moves.
Put it on the shared line (already happened, at commit) tovio land --into main — check in the lane** main's pointer advances to include your change; stacked descendants auto-rebase, ids unchanged.
Share it with the team git push tovio sync Lanes (pointers) and the changes they reach are exchanged; refs merge as CRDTs, so there's no "rejected" or "diverged history."

The one line to remember: commit is about your change (a private, named unit of work). land is about a lane (a shared, published pointer). Committing does not, by itself, put your work on main — you land for that. Git blurs this because git commit moves your current branch every single time.

A worked example

# Just start editing — a change opens automatically (no `add`, no lane to pick).
$ tovio status
  on my-lane · chg:xkqm7y
  modified (2 file(s))
    ~ src/net/reconnect.ts
    ~ src/net/backoff.ts

$ tovio commit -m "add reconnect backoff"     # ← CHECK IN THE CHANGE
✓ committed  chg:xkqm7y  9f2c1a
  2 file(s) · new change chg:p4m2n8 · undo with `tovio undo`
  # chg:xkqm7y now exists as a durable, named unit of work — but NO shared lane has moved yet.

$ tovio land my-lane --into main              # ← CHECK IN THE LANE
✓ fast-forwarded main → my-lane  9f2c1a
  same Change IDs — your work kept its identity · undo with `tovio undo`
  # main now includes chg:xkqm7y — this is when the work reaches the shared line.

$ tovio sync                                  # share main (and your changes) with the team

Now revise the same work, and watch the split pay off:

$ tovio commit --amend                        # rewrites the snapshot → a NEW commit hash…
$ tovio log --oneline --no-graph
@ chg:xkqm7y  add reconnect backoff           # …but the Change ID is STILL chg:xkqm7y

The change kept its name; only its underlying commit hash changed, and the lane pointer simply slid to the new commit. Reviews, CI runs, and agent provenance all still resolve to chg:xkqm7y.

This is the whole point

The change is the stable thread through your work; the lane is a pointer that follows. Because they're separate, amend / rebase / split keep the change's identity — exactly the thing Git throws away on every rewrite.

Why Git feels like one thing

Git has no "change" object. It has only:

  1. Commits — immutable snapshots, each identified by a content hash (a1b2c3…). A commit is the unit of work, but its identity is its hash.
  2. Branches — a branch is literally a movable pointer: a tiny file holding one commit hash. main is just "→ this commit."

And git commit creates the commit and slides your current branch to it in one motion. So "checking in" is one act, and the two ideas — the work and the pointer — never separate in your head.

The catch: because a commit's identity is its hash, the instant you amend or rebase, Git produces a brand-new commit with a new hash — "the same change" becomes a different object, and the branch pointer is the only thread tying the line of work together. Lose the branch (a detached HEAD, a botched rebase) and you lose the thread. TOVIO gives the work its own durable name, so the lane goes back to being just a label. The full habit-by-habit translation is in Coming from Git.

Side by side

TOVIO change TOVIO lane Git commit Git branch
What it is The unit of work A movable pointer An immutable snapshot A movable pointer
Identity Permanent chg:… A name; points at what's current The content hash — changes on any edit A name; points at a hash
Survives amend/rebase? Yes — same id Pointer slides along No — new hash Pointer slides along
"Check in" verb tovio commit tovio land git commit (does both) (moved by commit/merge)
Need one to start? Opens automatically No — optional Created by commit Yes — you pick one to live on

Common confusions

Do I have to create a lane before I start working?

No. In Git you git switch -c feature first, then edit. In TOVIO you just edit — a change opens automatically, with no lane and no add. Lanes are landing targets you reach for later, not a prerequisite for work.

When I tovio commit, what lane is my commit on?

None, necessarily. A commit belongs to a change; it reaches a lane only when you tovio land. (In Git, commit always moves your current branch, which is why the question feels obligatory.)

Is a change just a lane with one commit?

No. A change is one evolving unit of work with a stable id — over its life it can produce many commits (every amend/rebase is a new commit, same change). A lane is a pointer that can point at any change's commit. Different kind of thing entirely.

I rebased — did I lose my change, or my place?

No. The chg: id is unchanged, so reviews, CI, and agents still find it; only the underlying commit hash moved, and the lane pointer follows. There is no detached HEAD in TOVIO — you are always in a change, which always has an identity, so there is no way to end up "nowhere."

What's the real difference between commit and land?

Scope. commit finalizes your unit of work (local, identified, possibly stacked). land advances a shared lane to include it (public, gated on protected lanes). One is about the change; the other is about the lane.

Two teammates land onto main at the same time — do I get a diverged lane?

No. Lane refs merge deterministically; concurrent lands converge. Only a genuine content conflict surfaces, and it surfaces as a stored conflict object you resolve once — not as a push you have to retry. To see how lanes branch off and reconverge, use the lane timeline.

Where to go next

Last reviewed September 9, 2026

Suggest an improvement to this page Not for security reports — see disclosure