Breadcrumbsthe trail you can ride back

Open your documents folder and look for the file you have made four copies of. There is nearly always one. estimates.txt, then estimates-v2.txt, then estimates-final.txt, and then, because life happened on a Thursday, estimates-final-ACTUALLY.txt. Nobody planned that. It grew.

The instinct behind it is exactly right. You wanted to be able to go back, so you copied the file before you changed it. Copying is the only undo most people have ever been handed, and you used it sensibly.

It just does not work very well, and it is worth being precise about why.

• The names lie. Six months on, final and ACTUALLY tell you nothing about which one Dale actually sent to the customer.
• You cannot see what changed. You have four entire files and no record of the difference between any two of them.
• You keep all of them forever, because deleting one feels like the sort of decision you regret on a Tuesday.
• And the one time it mattered, you had already saved over the original before it occurred to you to copy it.

What you want instead is one file with one name, and every version it has ever been kept behind it, automatically, somewhere you cannot delete by accident. That is version control. It has existed for about forty years, it is free, and the only reason it has not reached your desk is that it was built by programmers for programmers.

Copying a file is a wish for an undo. Today you get the undo.

Picture riding a trail you are going to need to come back along. Every so often you stop, drive a marker into the ground, and tie a note to it saying what you had just done. This is where the rate card started being right. Then you ride on, and after the next stretch of work you mark again.

That is the idea, and everything else today is detail. Three things about those markers matter.

• You choose when. A marker is not an autosave. You drop one when a piece of work is finished and you are happy with it — which is exactly what makes the note worth writing.
• The note is for future-you. Six words, said the way you would say them out loud: priced the Tanner job. Not update.
• Nothing is ever removed. Markers only get added. Going back to an earlier one does not throw away the ones after it — the trail is still there, and you can ride forward again.

Now the real words, because you will meet them everywhere from here on. One marker is a commit. A folder that keeps its own markers is a repository, which everybody shortens to repo. The program doing the marking is called git, and it runs entirely on your own machine — no account, no internet, nothing sent anywhere.

The one download

Git is not built into Windows. It is a single install of the same shape as VS Code in session four, and then you never think about it again.

You are not going to type git commands after today. You need it installed for the same reason a kettle needs plumbing in — something else does the work, but the thing has to be there.

This part is worth watching rather than reading. Dale's estimates folder is on the screen, it has four markers behind it, and everything in it is correct. I am going to open the rate card, delete the labor rate, save the file, and then get it back.

The moment to watch is step three, not step five. It could tell me what had changed — not that a file had been touched, but which line went missing. That is worth as much as the undo, because most of the time you do not want to go back. You want to know what happened.

The three ways back

• Back to the last marker. Undo everything since. This is the one you will use.
• Back to a marker further down the trail. Tuesday morning, before any of this started.
• Just look. Show me what changed and leave it alone. That is not a change at all, and it is free.

What it does not do

Being straight about this is the difference between a safety net and a false one.

• It covers the folder you set it up in. Files elsewhere on your machine are not on the trail and never were.
• It does not un-send anything. An email that went out, an invoice that was submitted, a page that went on the internet — those are out in the world. Git covers your files, not the consequences of them.
• No marker, no way back. Work you never marked is work git has never seen. This is the one that catches people, and it is the reason for the rule below.

A mistake stops being a rebuild and becomes a step backwards.

Everything so far lives on one machine — the same machine that can be left in an airport, rained on, or simply decline to turn on one Monday. A trail you can only ride from one spot is not much of a safety net.

So there is a second copy, kept somewhere else, and the two are kept in step. Ours is GitHub: a copy of the repository, markers and notes and all, sitting on the internet. Sending your new markers up there is called a push. Fetching down anything that is up there and not here is a pull. Those two words are most of the vocabulary.

It buys three things, and only the first is about safety.

• A backup that is actually a backup. Not the current version of the file — every version of it, with the notes explaining each one.
• The same work from two machines. The office desktop in the morning, the laptop at the kitchen table at night, one trail between them.
• A way to hand it to somebody. A link, and they have all of it, history included.

Public and private

A repository on GitHub is private unless you say otherwise, and private means private. Public means what it says too: anybody on the internet can read every file in it and every note you ever wrote.

Which brings us to something you have been using since session four without being told what it was. The fallback has always been a folder on the internet you could download a ZIP from when a step defeated you on a Tuesday night. That folder is a public repository, and the dropdown you picked end-of-004 out of was a list of markers. You have been riding somebody else's trail for three sessions.

Here is what all of this looks like on an ordinary Tuesday. You are not going to learn commands, because the working horse from last session already knows them. What you need is to know what to ask for, and when.

There is a fourth you will reach for more than you expect: what has changed since the last marker? It is the question you ask when the assistant has been busy for ten minutes and you would like to know what it actually did.

Better still: make it happen without you

Last session you wrote your house rules into a file in the folder. This is a line for that file, and it turns everything above into something you no longer have to remember at the right moment.

Two sentences of English in a text file. From then on the trail marks itself, and the only thing left for you to do is the riding back.

A word about branches, since somebody will say it

There is a thing called a branch. It is riding a second trail alongside the main one, so you can try something risky without disturbing the work that already functions — and then either bring it back onto the main trail or walk away from it and leave the main trail untouched. It is genuinely useful, and real teams use it every day.

You do not need it in order to have an undo, and we are not doing it today. It is here so that when somebody says branch at you, you know what they mean and you know you have not missed anything.

Before the next session

1. Install git if you have not already. Chapter two has the box, and inside it a click-by-click walkthrough for Windows and Mac — open Show me every step. Nothing else on this list works until this one is done.
2. Open your practice folder from last session and start the assistant in it.
3. Ask for the first marker. “Set this folder up for version control and save a first marker.”
4. Change something. Edit any file at all and save it. Make it obvious.
5. Ask what changed. Read the answer properly. This is the step people skip, and it is the step that builds the trust.
6. Put it back. “Put everything back the way it was at the last marker.” Watch it come back.
7. Then do it once on something real. A folder of yours that matters. You have the undo now, and that is how you can go back to a good point in your project before the error or issue happened.

Step seven is why today exists. Six sessions of working on copies end here.

The rule that carries all of it: mark before you hand it something big, and mark when something comes out right. Ten seconds, twice a day. That is the price of never rebuilding anything again.