You ask an AI assistant to make a little game. The character needs to run across a ledge and jump a gap. By lunch you can land the jump in a panel beside the chat. You send it to a friend, who plays it twice and asks if she can add a moving platform.
You want to keep working too. You have a red jacket in mind for the character, and the jump could feel a little less floaty. A few requests later the character is falling short of a gap you cleared at lunch. Which request changed the jump?
The game has one working copy, and it lives in a conversation. Some chat tools keep earlier versions of the panel, and you can step back through them one at a time. That history is a row of snapshots inside one thread. You have to remember which version cleared the gap and which request changed the way the character moves. Start a new thread and you are pasting the code back in by hand.
For years, Git asked for more effort than my own work seemed to justify. I would finish a query or a notebook, then stop doing the actual work so I could administer the history of the work. Which files belong in this commit? What should the message say? If you do not come from a developer background, much of that happens behind a command line that makes every mistake feel more consequential than it probably is.
Agents changed that calculation. They made Git necessary at the same moment they made it almost effortless.
Final_FINAL_v2
You do what you have always done with a file that matters. You download the page, call it jump-game.html and email it to your friend.
By Thursday there are three. She has a moving platform. You have the red jacket. A friend she forwarded it to is still playing the original. Bringing the changes together means opening two files side by side and copying lines across by hand, hoping you caught all the code that makes the platform move.
Word documents went through this for years. Proposal_Final_FINAL_v2.docx is the same problem with a smaller blast radius: everyone has a copy, nobody has the copy, and the history is whatever someone remembered to save under a new name.
One live copy
Google Docs solved it by giving up on copies. There is one document, everyone edits it, and the version history keeps a running record of who changed what. For a memo, that is exactly right.
Halfway through adding the platform, it might look right and still drop the character through it because the collision code is missing. If your agent changes the only copy of the game, anyone trying that build runs into the same problem. In a document, two people can write separate paragraphs in place. The game needs a version everyone can play while work is still in progress.
One very long page
There is a second problem, and you would meet it working alone.
Every request so far has gone into the same page. The drawing, the level layout, the keyboard handling and the code that makes the character fall all live in jump-game.html, and by the time the platform works the file runs to a couple of thousand lines. Each request gives the assistant more to read and more to rewrite, so a change that took seconds at lunch now takes minutes. When the platform goes in, the assistant writes a new landing check for it and leaves the one the ledge uses where it was. Now the game decides whether the character has landed in two places, and a fix to one leaves the other wrong.
I see this at work now. A team builds a useful app as an artifact in a chat, and the whole application is one enormous file that they want to keep adding features to.
Software that keeps growing gets divided. The art goes in one file, the level in another and the movement code in a third. The landing check is written once, and both the ledge and the platform use it. A change to the jump then touches the movement file and leaves the rest alone. The agent reads the part it needs. You and your friend can work in different files on the same afternoon.
The panel beside the chat holds a page. A project is a folder, and a working version is a moment when all of its files agree.
So code needs something of both, and room to grow. It needs a copy of your own to make a mess in, the way Word gave you, a shared history that shows where each change came from, and a place where one page can become many files. A Git repository gives the crew all three. The team decides what has to pass review before it goes into the shared version.
Open the original jump-game.html you emailed at lunch. Clear the gap once more, then ask the agent to put that file in Git and call this version “First playable.” Now you and your friend have a starting point you can both come back to.
Save the jump you can land
Open the exported jump-game.html and clear the gap. Save that file as “First playable” on your laptop, then push the commit to GitHub.
- Commit
Where a fork fits. If someone outside the team wants to help and lacks push access to the shared repository, they can make a fork on GitHub. It gives them a repository of their own. They can clone it, create branches, and propose a change back to the original project through a pull request.
Your copy and the shared one
The agent creates a repository on your laptop. It is an ordinary folder with the game’s files in it, and Git keeps the history of how they changed alongside them. Today the folder holds one page. It can hold as many files as the game grows into. You’ll share the folder and its history with your friend through GitHub.
A commit records a checkpoint. “First playable” holds the HTML file you just tested. Later, when the art and movement code live in separate files, a checkpoint can still bring them back together exactly as you played them. Git records a snapshot of the project with the changes you selected, along with a message saying what they were for. You decide when you’ve reached a version worth keeping.
That checkpoint is what makes dividing the long page safe to ask for. In the chat, a rewrite that goes wrong has replaced the only copy. Here you can ask the agent to split the page, play the level and go back to “First playable” if the jump feels different. When it still lands, the split is the next commit.
With an agent, I rarely type any of it. I ask for a change, review what came back, and if it makes sense I say two words: "Commit this."
We did exactly that while revising another post on this site. The repository also held unrelated image work and resume edits. The agent looked at what had changed, separated the post we had been working on from everything else, checked the diff, wrote the message and committed only that. I did not have to work out which file belonged to the conversation. The agent already knew.
The agent handles the procedure. The manager chooses the checkpoint.
Then the agent pushes: the new commits go up to GitHub. Until then they exist only on your laptop. After it, there is a second copy somewhere else, and your colleague can get it.
Getting it is the other half. The first time, she clones the repository, which gives her a local copy of the project and its history. After that she pulls to bring updates from the shared branch into her local copy. Her copy and yours stay separate while you each work. GitHub holds the one you both agree on.
The prompt defines the work. The diff shows what changed. The commit preserves what you accepted.
Try it on a branch
The shared repository has a main line called main. In this project, it’s where the team puts the work it’s ready to share.
You and your friend start from the same checkpoint, the one where the page was split. You commit the red jacket on one branch. She commits the moving platform on another. You can each try your version, and the shared version stays at the checkpoint you started from.
A branch gives work its own line of commits, starting from a particular checkpoint. Both branches share the history up to that point. That gives Git a way to see what each person changed. If the platform idea doesn’t work out, your friend can abandon that branch and the shared version will still be playable.
The emailed copies gave you separate places to work. A branch gives Git the common starting point it needs to combine the two changes.
Suggesting mode for code
You push your jacket branch to GitHub, and your friend pushes her platform branch. Your agent can now get both sets of changes. It combines them on a branch called level-preview, pushes it, and opens a pull request asking to merge that branch into main. If you have used suggesting mode in Google Docs, you know the idea. You can look over a proposal while everyone else keeps using the accepted version.
An automated check builds the preview and loads the level. It passes. You review the change by playing it. The character in the red jacket lands on the moving platform. You ride it toward the ledge. Is there enough time to jump off? You make the landing. Someone playing main right now would still see the original jacket and the empty gap.
You approve the pull request and merge it. Now main points to the version you just played. The next time your friend pulls main, her copy has both changes too.
An agent can open the pull request, write its description and write the check. Accepting it is the part that stays with a person, because the check only knows what it was told to look for.
The copy people play
The friend who was forwarded the game is still playing the file from that first email. Nothing you merged has reached that copy.
So you put the game at a web address. A hosting service connects to the repository on GitHub, takes whatever is on main, builds it and serves the result to anyone with the link. That is a deployment, and it is one more copy. In this setup every merge to main starts a new one. Other teams release on a schedule or by hand.
Count the copies now. Yours is on your laptop, where you and the agent try things. Your friend has hers. GitHub holds the shared one, where changes are proposed, reviewed and accepted. The hosting service runs the live site, the one players see. A change moves between them one deliberate step at a time: a commit saves it in your copy, a push sends it to GitHub, a merge puts it on main, and a deployment puts main in front of players.
When someone says they changed the app and the site looks the same, the change is usually sitting in one copy while they look at another. It was made in the chat and never committed, or committed and never pushed, or pushed to a branch nobody has merged.
The last step can fall behind too. This site deploys from main. Two merges in one day passed their checks on GitHub, built, and were then refused at the deploy step. The public site kept serving the earlier build, and nothing on GitHub said so. The shared copy and the running copy are separate, so it helps to know how to ask each one which version it has.
Once people depend on that address, it needs more behind it. From Prototype to Production picks up there.
When two changes collide
Later you both move the same landing ledge. You put it closer so a player can step off the platform sooner. Your friend pushes it farther out to make the jump harder. In the level file, you both edit the line that sets the horizontal position, landingX. You change 411 to 382. She changes 411 to 520.
When Git tries to combine the branches, it can’t reconcile the two edits to the same line in the level file. It marks the overlapping changes and stops the merge. The shared version keeps its original ledge. This is a conflict.
Some conflicts are mechanical. An agent can often work out how to keep both edits. Here you have a choice about the game. Try the same jump with each ledge position. The character lands on the nearer ledge and falls short of the farther one. You want the first level to be forgiving, so you keep the nearer position, test the resolved build, and merge it. The two proposals still show up in the history.
The team also tries a double jump, then shelves it on its own branch while work on main continues.
Which version did you trust?
Back to the jump that stopped working. In the chat, you could step back through snapshots and try the gap again.
In a single file, Undo takes you back through edits in order. That works when you know which file changed and how far back to go. An agent can change the data logic, a component, a configuration file and a test in one pass. By the time you notice something broke, several more requests may have landed on top of it, some of them good.
Undo asks how many steps back. Git asks which version I trusted.
Across the gap, you can see the finish flag your friend added. You run toward it and fall short of the moving platform. Two commits have landed on main since you picked the nearer ledge. Which changed the jump?
Ask the agent to open the build where you resolved the ledge. You make the jump. Try the same input one commit later and you miss. That commit raised gravity to make the character feel less floaty. The flag came afterward, and the jump was already broken by then. You can try both older builds on your laptop while your friend and the live site stay on the flagged version.
Ask the agent to reverse the gravity change and play the level again. This time you ride the platform, jump to the ledge and reach the flag.
Revert does that for a commit: it adds a new commit reversing the selected change while retaining the later history. Independent improvements can stay; changes that depend on the broken work may need a decision of their own. The change that broke something, and the reasoning that produced it, remain in the record.
There are other ways to recover too. Roll the deployment back to the last good release while you look, or branch from a known-good commit and fix forward. The useful question is which change to reverse or which version to run, rather than how many times to press Undo.
“Commit this” saves the version I reviewed. The team can then decide what to merge and when to release it to players. Here, automated checks run before merge and a deployment pipeline delivers the release.
The history remembers what the chat forgot
A new chat can lose the context of the last one. The project’s history stays with the repository.
In Private Journal, I used agents to break a large entry editor into smaller parts over a series of commits. Then a fresh review found behavior that had slipped: the caret no longer stayed visible while someone typed a long entry, and mood and tag suggestions had stopped responding. The application still built, and much of the refactor was sound. Without history, the problem would have been "the editor is wrong now." With it, the question became "what changed during the editor work?", and the commits answered it. The repair was a few focused commits, and nothing else had to be treated as suspect.
The history can carry a fix forward as well as back. In Vicente's Arcade, one commit fixed a game's layout when it started in landscape. When a second game developed the same problem, the fix reused the first one's approach instead of solving it again, because the earlier commit said exactly what had been wrong and why the fix worked.
Git gives the agent a memory longer than the conversation.
The same record is a ledger of the work. When I want to know what changed last week, the commits have already organized it into finished pieces, each with a message, an author and a time. An agent can read them back and explain how the project moved. For changes that went through a pull request, GitHub also records the checks that ran and who approved the change.
Commit this
The game began as a page in a conversation. It is now a folder of files with a history, and each copy of it has a job: yours for trying things, the shared one for deciding, the running one for players. A prototype that people keep adding to needs that much of a home.
The jump will break again someday. Ask the agent what changed since the last commit where you could clear the gap. You can try that version, look at the changes since then, and decide which part needs fixing.
Git asks one habit of you in return. Finish a piece of work. Review it. Commit it. Then move on from something the project can remember.
The agent can operate Git. The manager decides which moments are worth keeping.

