What I got wrong about agents after 200 hours

I have about 200 hours of agent work behind me now. Most of it on my own projects, a fair bit helping a friend who’s a contractor and a couple of one-off jobs for people who paid me in brisket. Here’s what I got wrong early and had to unlearn.

The five-minute loop is a trap

I kept trying to break work into chunks that would finish in five minutes. The thinking was: short loop, less to undo if the agent goes sideways, easier to verify. The reality is that short loops produce code that doesn’t fit together. The agent doesn’t see the seam between the chunk it just finished and the next one. I now write a plan in plain text first, then let the agent work on the whole plan, then review. The plan is where the five-minute thinking happens, not the implementation.

Tools that look impressive often aren’t

I bought a subscription to the agent with the most features. It had file system access, browser control, shell execution, the works. I used maybe 10% of it. The agent that just edits files and runs a terminal beats it on the work I actually do. More capability is more places for the agent to do something dumb.

Memory features are not a substitute for a CLAUDE.md

I kept waiting for the agent to “learn” my preferences. The memory feature is fine for remembering that I’m on Python 3.12, but the kind of preferences that matter (don’t use the foo library, prefer the bar convention, this codebase uses tabs) belong in a file the agent reads every session. Memory features feel personal. CLAUDE.md is project-local and survives session boundaries. Project-local wins.

The 80% is the hard part

The first 80% of a feature takes 20% of the time. The last 20% takes 80% of the time. With agents, the first 80% goes faster. The last 20% goes the same speed. The total time is the same as before agents for most non-trivial work. The win is that I can have more non-trivial work in flight at once.

Reading the diff is the actual skill

The biggest skill I built this year is reading the agent’s diff carefully. Not skimming. Reading. Asking “why this library” and “why this pattern” and “why didn’t you just call the existing function.” Most of the bugs I catch are in the diff, not in the runtime. The agent is fast. The review is what makes it correct.

The 200 hours didn’t make me 10x. They made me roughly 2-3x on the kind of work I do, with the same number of late-night “oh no” moments. That’s a good trade. It’s not the trade the headlines promised.