I learned to code on iPhones before ARC existed.
If you're young: there was a time you allocated an object and you, personally, were on the hook to free it. Retain, release, keep the count right. Forget a release? Leak. The app keeps growing until iOS just kills it. Over-release? You're now holding a pointer to memory that's already gone — a dangling pointer — and the crash lands three screens later, nowhere near the actual mistake. Hours of your life, gone to a stack trace that points at where it crashed, not where you messed up.
We don't do that anymore. ARC handles it. A whole genre of bug just... evaporated.
So it's funny that I'm doing it again.
Here's the thing nobody warns you about with vibe coding. The model is plenty smart. The scarce resource isn't intelligence — it's the context window. That's your RAM now. And you are, once again, manually managing it. You just don't have an Xcode gauge yelling at you.
Work an agent hard for twenty minutes and watch the context fill. And it doesn't even wait until full to get worse. Cross some invisible line and accuracy quietly falls off a cliff — the thing was cruising at 95% and now it's guessing. Every search, every wrong turn, every file it read "just to check" leaves junk in the window. Noise it can't clear out. That's your fragmentation. Same disease, new hardware.
Blow your RAM budget and you crash — loud, immediate, honest. Blow your context budget and there's no crash. The agent just forgets. Loses the thread. Starts contradicting a decision it made ten minutes ago with total confidence. It's the dangling pointer again: everything looks fine until it very much isn't, and the symptom shows up miles from the cause.
And the worst move — I've made it plenty — is waiting until you're at the wall to compact. Summarize at 95% and you're freeing memory after the leak already sank the ship. The good stuff already got squeezed out to make room for the junk. Too late.
So you budget on purpose. Small scoped tasks, each one sized to fit in a clean window. Write the decisions down — into a file the agent can reload — so the plan lives on disk, not in fragile RAM. Hand the messy side-quests to a sub-agent that burns its own context and brings back one clean paragraph instead of the whole repo it had to read. You're not prompting. You're doing memory management with extra steps.
Which is the part I find genuinely funny.
Because this skill has an expiry date stamped on it. Windows went from a few thousand tokens to two hundred thousand to a million, and they are not going to stop. I remember games shipping on floppies. Now one wants a hundred-plus gigs and nobody blinks. We stopped counting bytes. We'll stop counting tokens.
So this is real today and gone tomorrow. A sharp, annoying, very-2025 problem.
Same as it ever was. Somebody's writing the ARC for this one right now.