Every AI coding tool promises to make you 10x faster. Here’s what they don’t tell you: the best ones change your rhythm entirely.

The Uncomfortable Truth

I’ve been using Claude Code for personal projects and Cursor for work. I’m not coding slower overall—I’m spending time differently. Less typing, more thinking. Less debugging, more architecting.

This isn’t a bug. It’s the most important feature.

AI as a Mirror

When AI over-engineers a simple feature, it’s showing us something. I’ve seen it try adding database columns instead of fixing missing ORM relationships. Instead of addressing the real problem, it builds elaborate workarounds.

Sound familiar? That’s exactly what we do under deadline pressure.

When it generates 15 PHP tests that essentially test the same thing with slight variations, it’s mimicking common test-writing anxiety. More tests feel safer. But they’re not better.

The inefficiency isn’t random. It’s learned. From us.

The Rust Parallel

Rust makes you fight the borrow checker until you understand memory safety. AI makes you fight the prompt until you understand your problem.

// What I used to write:
function processUserData(data) {
  // 50 lines of implementation
}

// What AI forces me to articulate:
// "Process user data by validating email format,
// normalising phone numbers to E.164,
// handling missing fields gracefully,
// and returning a standardised user object"

That specification work? I should have been doing it anyway.

The Architecture Shift

Here’s what’s actually changing: We’re no longer thinking “how do I implement this?” We’re thinking “how do I architect this so AI can implement it?”

This is profound. It’s the difference between coding and engineering.

When you have to explain a system to AI, you discover:

• Module boundaries are unclear
• Naming is inconsistent
• Patterns aren’t actually patterns
• That “simple” feature touches 12 different concerns

Why Different is Better

The developers optimising for AI speed are missing the point. They’re using AI like a faster keyboard. But AI isn’t a typing accelerator. It’s a thinking accelerator.

The rhythm change comes from:

1. Better Problem Definition - You can’t prompt what you don’t understand
2. Clearer Architecture - AI struggles with your spaghetti too
3. Explicit Intentions - Vague requirements produce vague code
4. Quality Gates - You review AI code more carefully than your own

Each of these “inefficiencies” is something we should have been doing anyway.

The Real 10x

The 10x improvement isn’t in lines per minute. It’s in:

• Decisions that don’t need reverting
• Architecture that doesn’t need refactoring
• Code that doesn’t need debugging
• Features that actually solve the problem

Speed is a vanity metric. Velocity includes direction.

The Future Belongs to the Deliberate

In five years, the developers who survived will be the ones who learned this new rhythm. Who used AI as a forcing function for clarity. Who treated prompts like architecture documents.

The ones who chased speed? They’ll be debugging the mess they created at 10x velocity.

AI isn’t making us slower. It’s revealing that we were always too fast in the wrong places. The best code isn’t written quickly. It’s thought through slowly, then implemented at whatever speed makes sense.

That’s the paradox: AI changes your rhythm until you realise you’re actually faster. Not at typing. At building systems that last.

---

Adapting to AI’s rhythm. Thoughts? Find me on Twitter or LinkedIn.