Claude Code Made Me Question My Career (And It'll Do The Same to You)

[GIF: A developer staring blankly at a terminal while a progress bar fills up, the camera slowly zooming in on their thousand-yard stare]

Right. Here's something I never thought I'd write: AI coding tools have finally got good enough to make me feel slightly obsolete, and I'm not sure whether to celebrate or update my CV.

I've spent the better part of a decade building backend systems. You know the type—distributed, eventually consistent, held together with hope and Kafka topics. I live in the terminal. Have done for years. Not because I'm trying to look cool in coffee shops (the Matrix green text gives it away), but because when you're SSH'd into a container at 2 AM trying to figure out why your message queue has decided to partition itself into oblivion, GUIs are about as useful as a chocolate teapot.

So when Anthropic released Claude Code in beta, I approached it with the same enthusiasm I reserve for "game-changing" npm packages that turn out to be left-pad with extra steps.

[GIF: Ron Swanson throwing a computer in a dumpster]

I was wrong. Annoyingly, comprehensively wrong.

Actually—let me qualify that. I wasn't entirely wrong. The scepticism was warranted. It's just that the bits I was wrong about turned out to be the important bits.

The Terminal's Having Its Moment (Again)

Remember when people took the mick out of terminal dwellers? "Oh, look at Dave with his green text, so l33t, bet he configures his window manager for fun."

[GIF: Leonardo DiCaprio raising a glass from The Great Gatsby]

Who's laughing now, Susan from product? Who's laughing now?

Claude Code isn't just another CLI tool. It's—and I don't say this lightly—Anthropic's attempt to make the terminal the primary interface for AI-assisted development. And it works. It works so well it's actually irritating. Like watching someone breeze through a crossword you've been stuck on for twenty minutes.

Here's what the polished demo videos don't show you: Claude Code fundamentally rewires how you approach problems. You stop thinking "I need to implement a retry mechanism with exponential backoff" and start thinking "I need to describe what happens when the network fails." The shift is subtle but profound. It's pair programming, except your pair never wanders off to make tea, doesn't silently judge your variable names (well—actually it does, but constructively), and happily works at 3 AM without muttering about work-life balance.

I should clarify that. It does judge your variable names. Passively. You'll type userInfo and it'll suggest authenticatedUserProfile and you'll sit there thinking "that IS better, damn it." It's passive-aggressive code review and I'm genuinely here for it.

The Workflow That Broke My Brain

Let's talk about what actually happens when you use Claude Code for real work. Not the "build a todo app in 30 seconds" influencer nonsense. Actual, proper, "this codebase was written by someone who's left the company" work.

Example 1: The Legacy Code Situation

Wednesday last week. Or maybe Tuesday. I'd inherited a Python codebase that looked like someone had learned programming exclusively from deprecated blog posts. 12,000 lines. Zero tests. Variable names like datastufffinalv2REAL_USETHISONE.py. You know the type.

[GIF: Michael Scott screaming "NO" repeatedly]

With Claude Code, I typed something like: claude "Analyse this codebase and identify the top 5 architectural issues that'll cause production incidents"

Within about 30 seconds—and I timed this—it had mapped the dependency graph, flagged circular imports I'd completely missed, and surfaced three SQL injection vulnerabilities that made me physically wince. One was in the payment processing module. The payment processing module. I just stared at my screen for a bit.

Would I have found these eventually? Sure. Probably. After about three days of painful debugging and too much coffee. Claude Code did it before my tea had finished steeping. Yorkshire Gold, if you're curious.

Example 2: The Refactor That Wouldn't End

Needed to migrate a monolith's authentication layer to OAuth 2.0 with PKCE. Normally this is a week-long project involving 50 browser tabs, three different RFCs, Stack Overflow (RIP), and me questioning every life choice that led to this moment.

Claude Code approach: claude "Refactor the auth module in auth/legacy.py to OAuth 2.0 with PKCE flow. Show me file-by-file changes and explain the migration path."

It didn't just spit out code. It walked me through the migration strategy, identified every breaking change, generated the new files, and wrote the database migration scripts. With rollback logic. ROLLBACK LOGIC. I've been "meaning to write rollback scripts" for approximately seven years.

The uncomfortable truth? It did in 20 minutes what would've taken me two days. And the code was... good. Not "good for AI" good. Just good. Proper error handling. Sensible comments. Edge cases I would've forgotten about at 5 PM on a Friday.

I'm still processing this, honestly.

Example 3: The Test Coverage Epiphany

This is where things got existential. I asked Claude Code to write tests for that legacy codebase.

claude "Generate comprehensive tests for the payment processing module with 90%+ coverage"

It generated 237 test cases. Found four bugs I hadn't spotted. Mocked external services correctly. Used parameterised tests where appropriate. Even added property-based tests for the input validation—something I've literally never done unprompted in my entire career.

And that's when it hit me: If Claude Code writes better tests than most senior engineers I've worked with, what exactly am I bringing to the table?

Sat there. Just staring. Terminal cursor blinking. Five minutes. Maybe more. Didn't touch the keyboard. Felt like that moment in a film where the protagonist realises they've been the villain all along, except I was just a developer realising his testing skills were thoroughly mediocre.

The Dark Bits Nobody Mentions

[GIF: Anakin Skywalker saying "This is where the fun begins"]

Before you accuse me of being an Anthropic plant, let's talk about where Claude Code falls flat on its digital face.

Context Window Amnesia

Claude Code has a massive context window—200k tokens, I think? But after about 90 minutes of intense development, it starts forgetting things. Like that colleague who "totally understands the brief" but can't remember a single thing you discussed before lunch.

You'll be deep in a refactoring session when Claude suddenly suggests an approach you explicitly rejected an hour ago. And it's so confident. That's the worst part. It suggests wrong things with the swagger of someone who's never been wrong in their life.

I've started keeping a DECISIONS.md file—literally just a markdown file where I jot down key architectural choices specifically so I can remind Claude what we agreed on. That's not a feature. That's me building scaffolding around a limitation.

The "Confidently Wrong" Problem

Last Tuesday, Claude insisted a particular Python package (boto3-stubs, if you're nosey) supported async context managers. Generated beautiful, production-ready code. Looked perfect. Immediately crashed.

TypeError: 'S3Client' object does not support the asynchronous context manager protocol

Fair enough, I thought. Pointed it out. Claude apologised profusely and generated different beautiful, production-ready code. Also crashed. Different reason this time. Something about credential chain ordering that it had completely invented.

Three iterations later, I just read the documentation myself. Version 1.34.122. Normal context manager. Nothing async about it.

The Hidden Cost

Here's what the pricing page won't tell you: heavy Claude Code usage burns through API credits faster than a startup burns through venture capital at a WeWork. One particularly gnarly debugging session—tracking down a race condition in our WebSocket handler—cost me nearly £10 in API calls.

Is a tenner worth two hours of my time? Obviously. But those costs add up, and if you're not tracking them you'll get a nasty surprise. I hit £140 in my first fortnight. Didn't even notice until my partner asked about the Anthropic charge on our joint account. Had to explain I wasn't buying anything, I was just... talking to Claude. A lot.

That was an awkward dinner.

The Workflow That Actually Works

After a month of daily use (started mid-January 2025), here's my actual workflow:

1. Exploration Phase: Use Claude Code to understand the codebase, map dependencies, spot issues
2. Architecture Phase: Discuss approaches with Claude, let it challenge my assumptions—sometimes it's genuinely insightful
3. Implementation Phase: Write the critical path myself, let Claude handle the boilerplate and the boring bits
4. Review Phase: Have Claude review my code, suggest improvements, catch edge cases I've missed
5. Testing Phase: Let Claude generate test cases, but I review every single one. Every. Single. One.

Notice what's conspicuously absent? Blindly trusting Claude to write everything.

I learned this the hard way. Around day 8—I think—I got lazy. Just accepted everything Claude generated for a WebSocket reconnection module. Deployed it. Ship it, right?

Wrong. So wrong. Rolled back at 11:47 PM on a Friday. Spent Saturday morning reading through 400 lines of AI-generated code, cup of tea in hand, trying to find where the logic had gone sideways. Never again.

The devs who'll thrive with Claude Code aren't the ones who type the least. They're the ones who know exactly what questions to ask and can instantly spot when the AI's hallucinating. The skill isn't writing code anymore. It's reviewing it. Judging it. Knowing when it's wrong.

The Uncomfortable Conclusion

[GIF: The "They're the same picture" meme from The Office]

Claude Code hasn't replaced my programming skills. It's amplified them.

The boring stuff? Automated. The boilerplate? Gone. The "I know I need to do X but can't remember the exact syntax" moments? Solved.

But the hard bits—the architectural decisions, the trade-offs, the "should we even build this" questions—that's still 100% human. For now.

Here's my prediction: within two years, "prompt engineering" won't be a separate discipline. It'll just be called "programming." The line between "writing code" and "describing what you want the code to do" is blurring faster than a crypto influencer's promises at a Miami conference.

Claude Code is the first tool that's made me genuinely believe we're crossing that threshold. I don't know how to feel about it. Excited? Terrified? Both? Neither?

Probably both.

What They Don't Tell You About CLI-First AI Development

The terminal's having a renaissance, and tools like Claude Code are why. But here's the catch: you need to actually know what you're doing.

I cannot stress this enough.

Claude Code won't save you from terrible architecture decisions. It'll just help you implement them faster. Much faster. Terrifyingly faster. It's a force multiplier, not a replacement for judgement.

If you're a junior dev, use Claude Code to learn. Ask it to explain its reasoning. Challenge its suggestions. Make it teach you. I've learned more about Python's asyncio internals in the past month than in the previous three years, purely because Claude explains its decisions when I ask.

If you're a senior dev, use Claude Code to eliminate the boring parts of your job so you can focus on interesting problems. Like why your team thought microservices were the answer to something that could've been solved with a cron job and a prayer.

If you're a "10x engineer" who thinks AI tools are for people who can't code, enjoy maintaining your hand-rolled jQuery spaghetti while the rest of us ship features at 3x your velocity. I'll check in on you in 2026. We'll see how that's going.

Should You Actually Use Claude Code?

Yes, if:

• You're comfortable in the terminal (or willing to learn—it's genuinely not that hard)
• You understand the code Claude generates (never trust blindly, I mean it)
• You value speed and can stomach the API costs (budget at least £80/month for heavy use)
• You enjoy pair programming but hate scheduling meetings (so, everyone)

No, if:

• You need a GUI to feel productive (no judgement, but this isn't for you yet)
• You're working on properly sensitive/proprietary code (think twice, then think again)
• You expect perfection (Claude makes mistakes, just like your human colleagues, except your human colleagues pretend they don't)

I've been using Claude Code daily for a month now. My productivity's genuinely increased. But more importantly, I'm enjoying programming again. The boring bits are automated. The interesting problems remain.

For now.

I keep coming back to that. "For now." Because if Claude Code is this good in early 2025, what does late 2026 look like? What am I optimising for? What should any of us be optimising for?

That's a crisis for another blog post, I think. Or possibly a therapist.

What's your experience with AI coding tools? Tried Claude Code, or still waiting for your IDE to add a "magic" button? Drop your hot takes in the comments—I'll be here, in my terminal, judging your GUI-based workflows. Probably configuring neovim. Because I have problems.

Related Reads:

• "Why Your IDE Is Making You a Worse Programmer" - My controversial take from last year that got me blocked by three VS Code evangelists
• "The Death of Stack Overflow: How AI Killed the Copy-Paste Economy"
• "Terminal-First Development: Why I Ditched VS Code" (Except for merge conflicts. I'm not a monster.)

P.S. If anyone from Anthropic is reading this, please add session persistence across terminal restarts. I beg you. I lost 45 minutes of context yesterday when iTerm2 crashed and I've never felt such despair. Also, dark mode by default would be nice. I'm not asking for much.

programming #claude-code #ai-tools #terminal #developer-tools #anthropic #software-engineering #productivity #future-of-coding #hot-takes