Back to blog

The AI Coding Revolution: Claude Code, Codex, and What It Means for Us

10 min read

Six months ago, I was skeptical. "AI will replace programmers" headlines felt like the same hype cycle we've seen a dozen times. The metaverse was going to change everything too, remember?

Then I actually started using these tools. Not as a toy, but as a daily driver. Claude Code for complex refactors. GitHub Copilot for boilerplate. Cursor for exploration.

I was wrong to be skeptical. But not in the way the headlines suggest.

What Actually Changed

Let me be specific about what's different in my daily work:

Before AI assistants:

  • Writing a new API endpoint: 30-45 minutes
  • Debugging a weird async issue: could be hours
  • Learning a new library: half a day reading docs
  • Writing tests for existing code: soul-crushing

After AI assistants:

  • New API endpoint: 10-15 minutes (mostly reviewing)
  • Debugging: still can be hours, but I get better hypotheses faster
  • New library: 30 minutes of asking "how do I do X?"
  • Writing tests: actually enjoyable (I just describe the behavior)

The productivity gain is real. But it's not 10x across the board. It's more like 2-3x on mechanical tasks, and 1.2x on genuinely hard problems.

The Tasks AI Crushes

Some things AI is genuinely incredible at:

1. Boilerplate and Patterns

Writing a CRUD API? Setting up a new React component with TypeScript types? Converting data between formats? AI handles these in seconds.

This used to be the stuff I'd copy-paste from previous projects. Now I describe what I need and get clean, contextual code.

2. Explaining Unfamiliar Code

I inherited a legacy Perl script last month. Instead of spending hours deciphering it, I pasted it into Claude and asked "what does this do?" Got a clear explanation in 30 seconds.

This is huge for onboarding and maintenance.

3. Writing Tests

This one surprised me. I describe the behavior I want to test, and AI generates comprehensive test cases - including edge cases I wouldn't have thought of.

Test coverage used to be a chore. Now it's almost fun.

4. Documentation

"Write documentation for this function" → instant, clear docs. I used to skip documentation because it felt like overhead. Now it's trivial.

The Tasks AI Struggles With

Here's where the hype breaks down:

1. System Design

AI can implement a cache. It can't tell you whether you need one, or what the right eviction strategy is for your specific traffic patterns.

Design decisions require context that spans months of understanding your users, your infrastructure, your team's capabilities. AI doesn't have this context.

2. Debugging Production Issues

When a service is down at 2am, you need intuition about what changed, what's different about this traffic pattern, what that one weird metric means.

AI can help analyze logs, but it can't replace the mental model you build from operating a system over time.

3. Knowing What to Build

The hardest part of software isn't writing code. It's figuring out what code to write. What features matter? What problems are we actually solving?

AI can build anything you describe. But describing the right thing to build? That's still entirely human.

4. Code Review (The Important Parts)

AI can catch bugs and suggest style improvements. But the deep code review - "this abstraction is wrong," "this will be unmaintainable in 6 months," "this doesn't match how users actually behave" - requires human judgment.

What This Means for Engineers

Here's my honest take:

Junior engineers need to adapt. The tasks that used to teach you the basics - writing CRUD endpoints, implementing standard patterns - are now done by AI. You'll need to learn differently, focusing more on understanding why code works rather than just writing it.

Senior engineers become more valuable. The parts of our job that AI can't do - system design, understanding users, technical leadership - are exactly the skills that took years to develop. We're not obsolete. We're leveraged.

The skill gap is widening. Engineers who embrace AI tools are dramatically more productive than those who don't. In a year or two, not using AI assistance will be like not using an IDE.

My Current Stack

For what it's worth, here's what I actually use daily:

  • Claude Code (via OpenClaw): Complex reasoning, refactors, architecture discussions. Best for when I need to think through something.
  • GitHub Copilot: In-editor completions. Great for flow state, never breaks my concentration.
  • Cursor: For exploring unfamiliar codebases. The codebase context is magic.

I switch between them depending on the task. No single tool is best at everything.

The Future (My Predictions)

Next 1-2 years:

  • AI agents that can handle multi-file changes autonomously
  • Much better at understanding project context
  • Integrated into every IDE, not optional add-ons

3-5 years:

  • AI that can maintain entire subsystems with supervision
  • Natural language as a legitimate interface to code
  • Junior engineer role transforms into "AI supervisor" role

What won't change:

  • Need for humans who understand the problem domain
  • Need for judgment about what to build
  • Need for someone accountable when things break

My Advice

If you're an engineer who hasn't gone deep on AI tools yet:

  1. Start with one tool and actually use it daily. Not for demos. For real work.
  2. Learn to prompt well. The difference between a good and bad prompt is 10x in output quality.
  3. Stay skeptical but open. Not everything works. But enough does that ignoring it is career suicide.
  4. Double down on judgment skills. System design, user understanding, technical leadership. These are your moat.

The engineers who thrive will be the ones who use AI as leverage for their judgment, not a replacement for it.


I'm actively exploring these tools while job hunting. If you're building something interesting in this space, let's talk.

aiengineeringfuturetools