Orbit

Git, explained by a musician who had no idea what it was back in February

Chris Rupp

Back in February I didn’t know what Git was… I’d seen the word around, vaguely knew it was a programmer thing, and figured I’d never need it cuz I wasn’t a coder. I’ve been a professional musician for about 30 years (I did spend two years at Ensemble Studios in college on the Age of Empires games, but that was playtest and design, not code). Then I vibe coded my first project over a weekend, got hooked within days, and now I’m spending around $600 a month on AI and building a massive AI orchestration program called Orbit (in Alpha now for free! more below). Still not an expert by any stretch, but somewhere along the way Git went from a word I nodded along to, to something every vibe coder should at least know the basics about.

At some point your agent is going to break something that was working fine… you ask it to improve the login page, it goes off and touches a bunch of files you’ve never even opened, and now the app that worked yesterday is broken and you have NO idea which change did it. If you’ve been using Git, getting yesterday back is honestly not a big deal, and if you haven’t… well, it can be a very long night.

It’s not always a big obvious break either… a while back Orbit started having performance issues that kept getting worse and worse, and we couldn’t figure out why. So we did a git bisect (basically a binary search through your save points, where you test the middle and cut the history in half each time) going back 500+ prompts to find when performance was last “good”, and then figured out what changed at that point. Without those save points that would have been a total guessing game.

The easiest way I know to think about Git is save points in a game. It takes a snapshot of your whole project, but not constantly in the background like autosave… it only saves when you or your agent tell it to. Each save point is called a commit, and each one carries a short note about what changed, like “fix login page”. You can jump back to any of them, so if the login broke after the last one you go back to the one before it and you’re standing in yesterday again.

Worth knowing too that Git and GitHub are two different things, even though people say them like they’re interchangeable. Git runs on your computer… GitHub is a website that keeps a copy of your save points online, where your project is called a repository (or repo for short). That online copy is your backup if your laptop dies, and it’s also what sites like Vercel pull from when they put your app live, so it matters more than it might seem at first.

The actual commands

The day to day loop is that you (or realistically your agent) change some files, commit to make a save point, and then push to send it up to GitHub. In a terminal it looks like this:

You don’t need to memorize any of that though… you can just tell your agent “commit and push” and it’ll handle it. What trips a lot of people up is that a commit only saves on YOUR computer, and until you push, GitHub has no idea it exists. So your agent can tell you it committed everything, all cheerful about it, and you go open GitHub and… nothing’s there. Your work didn’t vanish though, it’s just sitting on your machine waiting to be sent up. If anything depends on GitHub having the latest version (like a deploy), make sure the push actually happened and not just the commit.

My advice is to commit a LOT. Ask your agent to commit and push after every change that works, so GitHub always has a recent copy. Then when something breaks (and it will…), tell your agent to go back to the last commit that worked, and if you wanna be extra safe, which I’d recommend, have it do that on a new branch so nothing gets thrown away. Pretty much the only time Git can’t bail you out is if you never committed in the first place.

Why this ended up baked into Orbit

That whole “the agent says it’s done, but is it actually done” gap is a big part of why Orbit works the way it does. Orbit is the orchestration and management system I built for running my agents (Claude Code, Codex, Gemini and others all working from one queue), and at this point I genuinely can’t function without it… the ultimate dogfooding. Each agent can work in its own isolated git worktree, basically its own copy of the project, which means I can have several agents going on the same project at the same time, even in the same files, without them running into each other. After a prompt ships, Orbit checks the actual commit diff for ghost ships, where the agent says it shipped something and the commit doesn’t back that up.

Every prompt gets logged with its commit and the model that ran it, so there’s a permanent record of what shipped, and Orbit warns you if you’ve got local commits that never made it to the remote, which is literally the committed-but-not-pushed thing from above. I can also watch any agent’s CLI session live inside Orbit, which is pretty great when I’m up at 4 am chasing ONE more bug. (It also keeps my API keys in an encrypted vault on my own machine, but that’s a whole other post.)

If you wanna go deeper, the rest of the Git words like staging area and remote are in the free Learning Atlas on the Orbit site, along with the full video, and you don’t need Orbit to use any of it.

And if you’re curious about Orbit itself, it’s a desktop app for Windows and macOS, in Alpha and free right now, and you can grab an invite here: Get the free Orbit Alpha at orbitdev.app

Would love to hear what you think, good or bad.