threads as branches

On most software teams, a git branch is how you isolate one person’s in-progress work from everyone else’s. You open a branch, make your changes in private, and merge back once they’re done — the isolation is the whole point. Vinculum drops that step. Every session commits straight to main, and the isolation branches provided gets handled by a thread instead: a running, ordered record of one topic, grouped under a branch like platform, product, or growth (#181).

Git keeps doing what it always did — every commit is still a checkpoint, still reversible, still the record you’d reach for to roll a bad change back. What changed is where the coordination happens. It used to live in the branch structure itself, resolved at merge time. Now it lives in the thread, resolved while the work is still in progress.

Branches exist for a specific reason: two people editing the same codebase can’t read each other’s minds, and neither can hold the whole repo in their head at once, so a conflict between their changes only surfaces when one branch merges into another. Isolating each person’s work until that merge point is how you keep a slow-reading human from overwriting a colleague’s edits mid-line.

An LLM reads that same repo in seconds and can grep the whole repo in moments (#181). The premise that justified isolating its work — that it can’t see what else is happening, that a conflict can only be caught after the fact — doesn’t hold. The isolation branches provide is built for a problem this worker doesn’t have.

Vinculum catches an overlapping edit at the moment a worker declares intent to touch a file — hours before a traditional merge conflict would even be discovered (#181). The check runs on the way in: by the time two sessions would have collided on a branch merge, Vinculum has already flagged the overlap and moved on.

That happens while the overlap is live, and it shows. Two workers touching the same file appear together on the dashboard, in real time (#181), while the files themselves are still identical.

Flat-to-main is grounded in more than branches becoming unnecessary. It traces to a specific, observed failure: with linting running on commit, two parallel sessions each reformatted a shared file their own way on their own branches, and the second commit silently overwrote the first session’s work (#181). No error, no warning — the first session’s changes were simply gone once the second commit landed.

A structure built to keep two workers from destroying each other’s edits produced that exact outcome, because the collision stayed invisible until the merge had already happened. Flat-to-main paired with a thread that flags the overlap up front closes the same gap the branch was supposed to close, earlier — before either session has written a conflicting line, rather than after.

The convention is on record, not inferred from behavior. It reads, in part: “git add . && git commit -m ‘...’ && git push origin main. Always. No branches. Git is the checkpoint layer. Vinculum is the coordination layer. Threads are the branches.” (#181) The reasoning behind it, and the collision that motivated it, are recorded in the same entry.