Claude Code, one year in
A reflection on the AI coding tool I've spent most of the last year using.
Claude Code shipped about a year ago, and I’ve spent most of that year using it as my primary AI coding tool. Here’s what held up and what didn’t.
What it actually is
For the future-reader: Claude Code is Anthropic’s terminal-based agentic coding CLI. You run claude in your project directory, and you get a conversational interface that can read files, edit files, run commands, and keep going until the task is done. It’s not an IDE. It’s a command-line agent that sits on top of your existing editor and runs tasks you’d otherwise do by hand.
The difference between this and an IDE-embedded assistant (Cursor, Copilot, etc.) turns out to matter more than I expected. Claude Code is the thing I reach for when the task is “do this thing across my repo and report back.” The IDE assistants are what I reach for when the task is “help me edit this specific file I’m looking at.”
What held up
It scales with task size. The thing Claude Code does better than anything else I’ve used is sustained, multi-step, cross-file work. “Add this field through the data model, the API, the validation, the tests, and the documentation” is a task it can do in one go, and it will catch things I would have missed. For the first time, handing a task to an AI and coming back to a correct diff 20 minutes later is a real workflow.
The hook system and slash commands are underrated. You can wire Claude Code into a specific project with custom commands and per-repo config. Any repetitive thing I do more than three times becomes a slash command. My own /commit, /review-pr, /bisect commands are now muscle memory.
It’s honest about uncertainty. The model will say “I’m not sure, let me check” and actually go check. The failure mode where AI tools confidently invent function signatures that don’t exist has mostly gone away. When it doesn’t know, it looks it up or asks.
Review-every-diff still applies. A year in, my most important habit is still “read every change before accepting it.” I’ve caught things that were almost right but would have caused subtle bugs. The agent is fast, which means you have to be disciplined about the reading part, because the temptation to rubber-stamp is real.
What didn’t hold up
It’s still not a replacement for understanding your code. I’ve had a couple experiences where I delegated a task I didn’t fully understand, got a working result, and later had a bug I couldn’t debug because I’d never actually learned how the code worked. The rule I landed on: if I wouldn’t be comfortable maintaining the result, I shouldn’t delegate the work. That rules out using Claude Code for things I’m trying to learn — which is a use case I originally thought would be great for it and turned out to be the worst fit.
Long-horizon tasks still drift. A 20-minute task is usually reliable. A two-hour task is often 80% right with subtle wrongness in the last 20%. I’ve learned to break longer work into checkpoints — ask for a plan first, approve it, then execute one phase at a time, review, then continue — instead of setting it loose for hours.
Cost adds up. I don’t think about API costs day-to-day but I checked my numbers a few months in and the bill was real. For a solo developer it’s worth it at almost any price. For a team, the economics change fast depending on how much agent usage is happening.
The “oh no, it deleted the wrong thing” moment is still possible. Rare, but it happens. Always work on a git branch. Always commit before running anything risky. I’ve twice had to git reset --hard to undo an agent run that went sideways. Both times the safety net worked. I’m still grateful I had it.
The bigger arc
When I wrote about my agentic coding workflow a few months ago, I described three layers — inline completion, chat for thinking, agent for delegation. That split is still how my day works. Claude Code sits in the third layer, and it’s earned its place there.
The thing I didn’t anticipate a year ago is how much my non-coding work has also moved into this tool. I use it to write blog posts, draft emails, summarize PDFs, run shell diagnostics, and process data. It’s become a general-purpose terminal assistant that happens to also do coding. I spend more time in it than in any other single tool.
That’s probably the honest summary. Not “Claude Code replaced me.” Not “Claude Code is magic.” Just: it’s the most useful tool I’ve added in years, and the version I’m using today is meaningfully better than the version from a year ago, which was meaningfully better than no such tool at all. The curve is still bending. I’ll check back in another year.