I once wrote an article with the optimistic title GitHub for the rest of us. The idea was that everyone who works with others on collections of shared documents needs a powerful and easy way to see and manage change. The foundational tool for software version control — git — is incredibly powerful, and the GitHub interface layered on top of it does make git a lot easier to use. But my optimism was premature. There are some non-programmers who make effective use of GitHub but it’s still mostly for programmers working on code and documentation.
If you read that article you might have assumed that git and GitHub are easy for coders to use. No! These are wildly complex tools. I’ve worked with them every day for years, have barely mastered the basics, struggle mightily with advanced features, and dread making mistakes that will affect team members. Even if you can become adept at using them it will have been an arduous climb up the learning curve, and daily use imposes cognitive burden. You’d rather focus on whatever you’re actually trying to do, not how to resolve a merge conflict.
Now, suddenly, that cognitive burden has lifted. LLMs don’t just write code, they also wield tools like git and GitHub while doing so. You don’t hear about this in mainstream stories about the end of computer programming. Coders assign tasks to teams of agents, we’re told, then wait for results to appear. What then? Those results need to be integrated safely into complex systems. That’s a job for git and GitHub, and the LLM boost occurs there too.
Yesterday I was working on a project whose ingredients are spread across three different GitHub repositories. I need to keep track of multiple branches in each of my local copies, and be aware of the state of those branches in the remote copies. I know there are plenty of coders who can navigate this complexity, though they pay a cognitive task to do so. For me, until recently, the daunting logistics brought progress to a crawl.
I asked Claude to report how it has been helping me do these things, here’s part of the answer.
Branch archaeology
- Tracing where work lives across branches: You had wrapping work spread across judell/wrap-component, wrap-component-2, -3, and -4. I ran git branch –contains <sha> and git log –all –oneline — <file> to determine that TextBox wrapping was on the original wrap-component branch (not -2 as you initially thought), FileInput wrapping was also on wrap-component, and Slider was on -2.
- Diffing across branches: git diff judell/wrap-component-2…judell/wrap-component-4 –name-only to see 117 component files changed between branches, understanding what work had accumulated where.
- Finding orphaned commits: git log –all –oneline — xmlui/src/components/TextBox/TextBox.tsx revealed the full history across all branches, showing which commits were on which branches.
Assessing divergence before porting work
- Determining cherry-pick feasibility: Diffed the wrap-component branch’s TextBox against wrap-4’s version and discovered significant divergence (responsive layout changes, CSS regression fixes had landed in between), ruling out cherry-picking and leading to the decision to re-apply the wrapping pattern manually.
- Checking if core infrastructure changed: Compared wrapComponent.tsx history on both branches (4 commits on wrap-4 vs 9 on the original) to understand whether the API had shifted.
One of the tools in git’s kit is called bisect. Bugs aren’t always immediately evident. What if there have been 30 new versions since the one you are certain was working properly? The bisect command enables a divide-and-conquer strategy: split at the midpoint, check if the bug still exists, then keep splitting until you find the last version that worked. The next version is the culprit.
I’ve always known about bisect and always struggled to use it well. As with all git commands the syntax is arcane and use is tricky. When I mentioned to a friend that Claude had empowered me to be a better user of git bisect he objected. “I might be old-school,” he said, “but I feel like I need to know how these things work.” I agreed! What I brought to the table was the knowledge that git bisect was the right tool for the job. Claude Code brought the ability to wield the tool effectively. And as it did so, I watched and learned. This aspect of LLM use is not a black box. When agents run commands on your behalf you can see and approve them.
“I should probably take an online course,” my friend said, “or watch some videos.” You can, I said, but there’s no better learning experience than to be guided through the use of a tool in a situation where you need it to solve a problem in the work you’re actually doing.
One my first posts at the dawn of the LLM era was entitled Radical just-in-time learning. In Using AI Effectively As A Student, Carson Gross (yes, that’s the HTMX guy) implores his students to use LLMs properly. I’ll paraphrase:
You are playing with fire, you can use these things in a ways that help or harm your intellectual development, I can’t choose for you, be aware.
It won’t be an easy choice, and concerns about de-skilling are real and valid. (From today’s NYT story: “If you don’t use it, you lose it.”) But nothing requires us to cede autonomy to our freakishly talented LLM assistants. We direct their efforts, and they learn from us. As we do the work they wield tools on our behalf. We can, if we choose, learn from them how best to use those tools, even as we often delegate the use to them.
