Git is one of the best pieces of software ever written. Branches let you try an idea without touching the real thing. Every working copy is a fully isolated world. Nothing is ever really lost — the history is a perfect, total undo. If you sat down to design the ideal system for changing things without fear, you would land somewhere very close to Git.

And almost nobody who isn't an engineer will touch it.

The usual story is that Git is too powerful for normal people — that designers, founders, and PMs need something simpler. We think that story is exactly backwards. Git isn't hard because of its power. It's hard because of its words. "Detached HEAD." "Stash." "The index." "Rebase." These aren't hard ideas wearing plain names; they're plain ideas wearing hostile names. The power is fine. The vocabulary is a language test at the door.

So most tools "solve" this by hiding Git behind a Save button. It works right up until it doesn't — and the moment something goes wrong, the user is stranded in a system they were never allowed to understand. You can't reason your way out of a machine whose parts were deliberately kept from you. Hiding the power to spare people the words just means they meet the words for the first time in an emergency.

We took the opposite path. Keep every bit of the power. Translate every term into a word a normal person already knows. You don't dumb it down — you build a phrasebook.

Two jobs, not one

Look closely at Git and you find two different kinds of work tangled together, and the trick is to treat them completely differently.

Most of it is machinery. Committing after a change, pushing so the work is backed up, pulling in what moved, stashing before you switch, merging when two copies drift apart — these are steps a computer should simply do. There's no judgment in a commit. Nobody stands at a fork in the road agonizing over whether to run git fetch. Asking a non-engineer to drive these by hand isn't empowering them; it's handing them the manual transmission on a car that could have driven itself. So in medit there's an auto-git mode: it commits, pushes, pulls, stashes, and merges in the background, and surfaces each commit as a quiet card in the chat as it goes. You make changes; the history takes care of itself. Nobody types a Git command, because there was never a decision in typing one.

But some of Git genuinely is judgment, and those moments can't be automated away — only faced. Which working copy becomes the real one. Whether a file is shared across every copy or each keeps its own. Which copies a rule should apply to. Whether to overwrite a version that has drifted. A machine can't answer these, because they're about what you want, not about what Git can do. Automate them and you'd just be guessing on the user's behalf — which is how the Save button strands people in the first place.

That split is the entire design. Hide the machine; translate the decision. Rule 3 below — "hide what needs no decision" — turns out to describe the vast majority of Git, so we fold that whole mechanical layer away. What's left is a short list of real choices, and that is where the phrasebook lives. We never set out to make non-engineers fluent in Git. We set out to make sure the only things they ever have to decide are things a person can actually decide — asked in words they already own.

The phrasebook

Here's a sample of the translation, Git term on the left, the words a person actually thinks in on the right.

• git checkout <branch> → "Make this the main one." Promote the copy you were experimenting in to become the real thing. No "detached head," no ceremony.
• .gitignore → "Private to your machine." Files that stay on your computer and never travel — a local database, secret keys.
• The index / tracked → "In version control." Whether Git is allowed to keep a file's history. It's a permission, so we phrase it as one: a checkbox.
• symlink → "Shared with all." One file every working copy sees. Change it anywhere, all of them see it.
• cp at branch creation → "Its own copy." Each working copy gets a copy of main's file to change alone. Main's is never touched.
• No link / no copy → "Its own, empty." Each working copy starts blank — the right answer for caches the project regenerates.
• release/*, !(prod), regex → "Name starts with…" You describe which copies you mean in words — starts with, contains, is exactly — and watch them match live. No pattern syntax.
• rm -rf <worktree> → "The safety folder." Nothing is ever deleted. A file about to be removed is set aside where you can always retrieve it.

None of this hides Git. Every one of these is still doing the full Git operation underneath. We just stopped making the word the price of admission.

The seven rules of translation

Building the phrasebook taught us that "use plain words" isn't a slogan, it's a craft. Seven rules held up across every screen.

1. Name the one real decision. Don't ask the user to "choose a sharing mode." Ask the actual question: should working copies share this file, or each keep their own? The mode is an implementation detail. The decision is the thing.

2. Put the consequence on the choice. Every option states, in plain words, exactly what will happen — right next to it. "Its own copy" carries "main's is never touched" on the same line. Nobody should have to know the outcome from memory.

3. Hide what needs no decision. Caches and build folders have one obvious answer. Fold them away so the files that actually matter stand alone. A choice with only one sane option isn't a choice; it's noise. Taken to its limit, this rule is what lets auto-git mode exist at all.

4. Make the invisible visible. A setting that only takes effect "later" is a trap. Show each file's real current state now — not what it will be, what it is.

5. Lead with safety, in the first sentence. "Your files are never deleted here" appears before any control does. People act bravely when they know the floor is there. You put the net up first, then invite the walk.

6. Sentences, not syntax. Replace every pattern and flag with a dropdown and a sentence. release/* is a language test; "name starts with release" is a thought anyone can have. Syntax is a gate. A sentence is a door.

7. One word, everywhere. The same idea must never wear three names across three screens. If it's "the main one" here, it is not "the default branch" two clicks away. Consistency isn't tidiness — it's what lets someone build a working model in their head and trust it.

The hardest word — delete

Every rule above was really rehearsal for the hard one.

Switching your main branch, or removing a working copy, runs commands that erase files. An engineer understands the risk — they know a checkout can clobber uncommitted work, they know rm -rf means it. Everyone else hits it as a landmine: one ordinary-looking action, and something irreplaceable is gone. The gap isn't intelligence. It's that the danger was written in a language they were never taught, so the warning never arrived.

You cannot translate delete by softening the word. "Are you sure?" is not a translation; it's a shrug that moves the blame onto the user. The honest translation is to change what the word does.

So we built the safety folder. Nothing is ever actually deleted. A file about to be removed is quietly set aside, and it stays retrievable. "Use main's file" resyncs a copy that has drifted — but first it tucks away whatever was there. The scary operation still happens; the irreversibility doesn't. We didn't make delete sound safe. We made it be safe, and then the plain word is finally telling the truth.

That's the whole philosophy in one feature. Hiding Git tells the user don't worry about it and abandons them when worry arrives. Translating Git tells them the truth in words they own — and builds the world so the truth is one they can live with.

The power was never the problem. We just gave it back its plain name.