Remember the early 2000s? You could spend hours crafting a document in Microsoft Word, only to have the application crash and take your work with it. You learned to compulsively hit Ctrl+S every few minutes. Your desktop filled up with files named report_final.doc, report_final_v2.doc, report_ACTUALLY_final.doc. Tracking changes meant emailing attachments back and forth, hoping no one overwrote someone else's edits.

Then Google Docs arrived and quietly eliminated an entire category of anxiety. Auto-save became the default. Every keystroke was preserved. Revision history appeared without anyone needing to think about it. Real-time collaboration replaced the "who has the latest version?" email chain. Today, manually saving a document feels as outdated as defragmenting a hard drive.

I think LLM-assisted coding could create a similar shift in how developers experience source control.

Git gave us distributed workflows, cheap branching, and the ability to collaborate at scale. GitHub launched publicly in April 2008 and brought Git collaboration into a social platform now used by more than 180 million developers.

Git also carries operational overhead. Developers switch between creative work and mechanical operations: staging files, writing commit messages, creating branches, opening pull requests, rebasing, cherry-picking, and managing remotes. Those rituals protect collaboration and recovery, but they also interrupt flow.

LLM coding tools are already starting to absorb parts of this workflow. Claude Code documents workflows for inspecting code and creating pull requests. Cursor automatically saves local checkpoints of Agent-made code changes so users can restore an earlier state, while explicitly distinguishing those checkpoints from version control.

These are meaningful improvements, but they are still incremental. AI is doing the same Git tasks, just faster.

Source control could become largely invisible, much as saving a document did.

At its core, version control is not about commands like git add, git commit, or git push. It is about preserving meaningful states, understanding what changed and why, enabling collaboration without destructive interference, and allowing recovery from mistakes.

LLMs do not just process code. They model intent. When an AI agent makes a change, it already has access to the reasoning behind that change. That context can be captured automatically, without requiring a developer to step out of flow and formalize it in a commit message.

Version control metadata becomes a byproduct of the work itself, not a separate task layered on top.

One possible progression has five stages:

Assisted Git: AI generates commit messages, helps resolve conflicts, and drafts pull requests while developers control each action.

Automatic checkpoints: meaningful changes are preserved without explicit commands, and task context begins to shape branching and merging.

Intent-aware history: the system records that a change adds user authentication, not only that several files changed. Semantic conflict detection supplements line-by-line diffs.

Coordinated collaboration: humans and agents work in parallel while the system helps maintain consistency and surfaces conflicts earlier.

Ambient versioning: decisions, experiments, and changes are preserved in a queryable history. A developer can ask when and why a pricing algorithm changed and receive an answer grounded in recorded intent.

The sequence and timing are uncertain. The useful direction is a version history that preserves more of the reasoning already present in agent-assisted work.

There was early skepticism around auto-save. What if it saves something you did not want? What if you lose control? Those concerns were valid and were addressed through better tooling. Source control may follow a similar pattern, but only if transparency, auditability, and human override remain essential.

For builders today, this shift does not make Git knowledge irrelevant. Concepts like branching strategies, conflict resolution, and release management still matter. But the manual execution of those concepts will increasingly be delegated to AI, just as document structure still matters even though no one manually saves files anymore.

Builders will still need version-control concepts, but may spend less attention on the mechanics. The work shifts toward defining intent, setting guardrails, and reviewing the history that automated systems preserve.

We stopped thinking about saving documents. I expect committing code to become less visible for the same reason: the system will capture meaningful states while we work.