TLDR: The way most of us code now produces more output than our brains can hold. AI tools took the friction out of writing code. They did not take the friction out of remembering it. By Friday afternoon you've shipped a stack of commits and you cannot account for half of them. The fix is a daily digest of what your repo actually did.
Friday, 5 PM. You close your laptop. You shipped a lot this week. A stack of commits, a handful of features, a refactor or two. Feels like a productive run.
Then your teammate asks: “What did you build this week?”
You stare at them. You pause for a second too long. Your brain is empty.
A new pattern, a new problem
The way most of us code now is different from two years ago. We don't write line by line. We describe what we want, accept the patches, scan the diffs. Sometimes we don't even fully scan the diffs. The friction of producing code has basically disappeared.
What hasn't disappeared: the cost of remembering what we actually shipped.
This is what vibe coding looks like in practice. The work feels loose and quick. The cost only shows up when you stop typing. That's when you realize you can't account for half of what you produced.
How vibe coding got its name
Andrej Karpathy coined the term in February 2025, describing a new way of working where you “give in to the vibes, embrace exponentials, and forget that the code even exists.” His framing was about the shift from writing code to steering a model. The cost he didn't dwell on: when you stop typing, the code stops sticking.
A year on, the term has settled in. Most developers I know say “vibe coding” without thinking about where it came from. The shape of work it described is now most software work.
The hidden costs
Mental ownership erodes. When you didn't type the bytes, they don't live in your head the same way. You know the AI built a feature. You don't fully remember what's in it.
Your git log becomes static. Auto-generated commit messages like wip, fix, and update X don't tell you what happened. A normal week now produces a wall of nearly-illegible commits. You can't read your own history.
Monday-morning amnesia. You sit down to keep building and you can't remember what state the codebase was in when you left Friday. You spend the first hour of your week reading your own diffs to onboard yourself.
Standup paralysis. Your team asks what you've been working on. You actually have to think about it. The honest answer (“I don't really remember”) feels bad to say, so you make something up.
You can't onboard yourself. The codebase grew faster than your mental model of it. You become a stranger in a project you wrote.
What the research says about typing and recall
The “I built it but I don't remember it” feeling is not surprising. Psychologists call the underlying effect the generation effect: you remember information better when you produce it yourself than when you passively receive it. Forty years of studies, from word lists to math problems to source code, point in the same direction.
When the AI generates the code and you read and accept it, you're on the worse side of that effect by design. Reading is not generating. Skimming is even further off. The faster the loop, the less of the work your memory captures.
This isn't a reason to type everything by hand. It's the reason a daily readout matters more than it used to. You cannot rely on memory to fill the gap that used to fill itself.
Why current tools don't fix it
git log is unreadable at this volume. The format was designed for slow, deliberate commits. AI-assisted developers are producing many times that volume.
Linear and Jira track plans. They have no way to see what the AI actually shipped, only what you intended to ship. The gap between those two has gotten really wide.
“Just ask the AI to summarize.” But the AI doesn't see your commits. You'd have to paste diffs in by hand every day. Nobody does that. (For why getting context into Claude Code or Cursor is its own slog, see the fastest way to give Claude Code, Cursor, or Codex project context.)
The thesis
Vibe coding needs vibe digesting.
If AI helped you write the code, AI should help you remember it. A daily summary in plain English. Not file paths. Not a reformatted git log. A real read of what happened, the way you'd want a coworker to brief you back: Vibe Check, what shipped, what changed, what kept shifting, where you left off.
That's askScout. Sign in to the web app at askscout.dev, or run it as a CLI in any local repo with your own LLM key. It reads your commits, diffs, and a small amount of project context (README plus a manifest like package.json) so the LLM you choose has enough to write a digest worth reading. Source files outside the changed regions, environment variables, secrets, and build artifacts are never read. Free. Sets up in about ten seconds. (For the practical follow-up, see the four real ways to track what you shipped and the AI coding tools that create the volume problem in the first place.)
If AI helped you write the code, AI should help you remember it.
Frequently asked questions
What is vibe coding?
Vibe coding is the way most developers write code with AI assistance. You describe what you want, the model produces patches, you review and ship. Code volume is high. Mental ownership of any individual line is low.
Why is it harder to remember code I built with AI?
When you do not type the bytes, they do not stick in memory the same way. You know the AI built a feature. You don't recall the specifics. The faster you ship, the wider the gap gets between what's in your repo and what's in your head.
Can I just read my git log to remember what I shipped?
Probably not at AI-coding pace. Git log was built for slow, deliberate commits. A normal week of vibe coding produces a flood of commits, often with auto-generated messages like 'fix' or 'wip.' Skimming that is not the same as understanding what changed.
What is a daily code digest?
A short, plain-English summary of what changed in your repo today. Sections cover what shipped, what changed, what kept getting reworked, and where you left off. The point is to be quick to skim, not to replace your git log.