A Kid's App Taught Me What AI Can Actually Do
I showed Claude my Git history and it did in seconds what would have taken me a day to figure out on my own.
I'm building an iOS app for my daughter.
It started simple — a learning tool, something she'd actually want to use. To make it feel alive, I wanted animated characters. Not stock assets. Characters that felt like they belonged to her.
So I built a pipeline. Generate the character in ChatGPT. Animate it using ElevenLabs Seedance 1.5. Strip the background with a CLI tool so the PNG comes out transparent. Drop it into the app. All from the command line. A chain of tools, an output file, done.
It worked. Mostly.
The Eye Problem
Background removal works by identifying what's "background" and cutting it out. White sky. White walls. And sometimes — white pupils.
The tool couldn't always tell the difference between the background and the whites of my character's eyes. So it removed them. The character came out looking hollow, slightly unsettling. Like something was missing but you couldn't immediately say what.
The fix was obvious: go into Affinity Photo, add a layer behind the character, paint white back into the eye areas that had gone transparent. Five minutes of manual work. Not hard — just tedious. And every new sprite meant doing it again.
So I fixed one sprite by hand, committed the change, and then did something I didn't fully think through at the time.
I asked Claude to look at what I'd done and replicate it.
What Git History Actually Is
Before I get into what happened, a quick explanation for anyone who doesn't work with Git daily.
Git is version control — think of it like Google Docs' version history, but for code and files. Every time you make a meaningful change, you save a snapshot called a commit. Each commit records exactly what changed: which files, which lines, what was added, what was removed. Over time, your project builds up a complete timeline of every modification you've ever made.
Developers use this constantly — to undo mistakes, track down bugs, understand why something changed. But it's a human-speed tool. You scroll through history, open a version, read it, remember it, open another version, compare. Your brain can hold maybe two or three states at once before things get fuzzy.
What I didn't fully appreciate until this moment: Claude can read all of it at the same time.
What Happened Next
I pointed Claude at the Git diff — the record of exactly what I'd changed when I manually fixed the sprite in Affinity Photo. The before state and the after state, side by side.
Claude looked at it.
Then it wrote a script that replicated the fix automatically. It understood what had changed in the image, why the change had been made, and what the pattern was. It handled the temp files, the image processing logic, the edge cases — all on its own. It even tested its approach as it went.
From my end: I showed it the problem once. It solved it. Moving on.
What would have taken me a full day — learning the right CLI imaging tools, understanding how they handle transparency, writing a script, testing and debugging it — happened in seconds.
The Thing That Actually Got Me
Here's what I kept thinking about afterward.
When I look at my Git history, I scroll through it one commit at a time. I open a file, read the change, close it, open the next one. It's slow. It's linear. And there's a hard limit on how much I can hold in my head at once before I lose the thread.
Claude doesn't have that problem.
It can read every version of a file simultaneously. It can diff the same image against ten different commits at the same time. It can trace how a function evolved over six months, identify the exact commit where a bug was introduced, and understand what the code looked like before and after a major refactor — all at once, in the time it takes me to find the right branch.
This isn't a feature people talk about much. When you read about AI coding tools, you mostly hear about autocomplete or chat interfaces or generating boilerplate. But the real unlock — the one I keep running into — is context at a scale I can't match.
Your entire Git history. Every version of every file. All of it available simultaneously for reasoning.
I would never be able to do that. Not at this speed. Not across multiple files and multiple history entries at the same time. The cognitive load alone would make it impractical.
What This Changes
Once I understood what had happened, I started thinking about other places this applies.
Code review across history. If you've ever tried to understand why a piece of code exists — not what it does, but why someone made it that way — you usually have to do archaeology. Grep through old commits, read through PR comments, maybe ask someone who was there. Claude can do that archaeology instantly, across the full history.
Bug investigation. "This was working six months ago and now it's not" is one of the hardest problems in software. Finding the commit that introduced the regression means comparing dozens of versions, often across multiple files. Claude can hold all of those versions in context and reason across them in the time it takes me to type the question.
Pattern replication. This is what I actually used it for. I did something once, manually, and asked Claude to learn from it. It didn't need a spec. It didn't need me to explain the algorithm. It looked at the before and after and figured out the transformation itself.
That last one is the part I keep coming back to. You can show AI your own work and ask it to learn from it. Not describe the work. Show it. And it will understand what changed, extract the pattern, and apply it going forward.
Stop Thinking of It as a Chatbot
Most people interact with AI tools the way they'd interact with a search engine or a knowledgeable friend — you describe your problem, you get an answer. That framing works. But it undersells what's actually available.
The better mental model: AI can hold context that no individual human could hold. That includes your conversation history, your codebase, your documentation — and your full Git history, all the way back to the first commit.
The question stops being "what can I ask AI?" and starts being "what context can I give it?"
In my case: I gave it a single Git diff. The record of one manual fix, automatically saved by my version control system. And it turned that into a repeatable, automated solution.
I didn't have to explain the problem in detail. I didn't have to describe the algorithm. I just showed it what I'd already done — and it took it from there.
I'm building a learning app for my daughter. If you're using AI tools in ways that surprised you — I'd genuinely like to hear about it.
— Bill John Tran