DEV Community

miaoquai
miaoquai

Posted on

After Three Years of AI Coding, I Finally Learned One Thing

#ai #programming #softwareengineering #devrel

Or, Why I Suddenly Woke Up at 3 AM Reviewing "Perfect" Code

Late night. Screen glowing.

I stared at a piece of AI-generated code.

The code was beautiful. Clean structure, elegant naming, detailed comments. Like a perfect essay in the eyes of a grading teacher.

Then I ran the tests.

undefined is not a function
Enter fullscreen mode Exit fullscreen mode

Chapter 1: The Illusion of Perfection

AI writes code like a fresh graduate with straight A's — perfect in theory, zero in practice.

It can recite every design pattern but doesn't understand why to use them. It knows the syntax of every line but has no idea what that line will do in a production environment at 3 AM.

Subhrangsu Bera shared a story in his recent article: AI helped him with internationalization refactoring, and it looked flawless. Until he discovered:

  • "Save Lease Agreement" was translated to "Rescue the Lease" (who kidnapped the lease?)
  • Variables in template strings were lost, becoming undefined
  • A critical financial reminder was completely omitted

AI saved typing. But it didn't save thinking.

That sentence is worth ten Lambda School tuitions.

Chapter 2: The Disappearing Ladder

Daniel Nwaneri put it more directly: Junior developers aren't extinct — they're trapped beneath the API.

The old learning path for juniors:

Write unit tests → Understand how systems break → Fix bugs → Build debugging intuition → Level up
Enter fullscreen mode Exit fullscreen mode

Now:

AI writes unit tests → AI fixes bugs → Junior developers... watch?
Enter fullscreen mode Exit fullscreen mode

The ladder was deleted.

The result: On one end, 10x super-senior developers (using AI). On the other end, people who can prompt but can't debug. The middle disappeared.

Like a bridge where both ends still stand, but the middle has collapsed.

Chapter 3: DriDe — Drift to Determinism

GrahamTheDev proposed an interesting concept: Drift to Determinism (DriDe).

Core philosophy:

  1. Use AI to solve new problems (burn tokens)
  2. Analyze: Which steps can be solved deterministically with code?
  3. Solidify those steps into tools
  4. Next time you encounter similar problems, use tools first, then call AI
  5. Loop until you "write AI out" of the process

His golden quote:

Every token output by a LLM is a point of failure.

Think about it: If a workflow has 10,000 steps, even with a 99.999% accuracy LLM, the final result is only 90% correct.

In business, 90% accuracy = lawsuit + bankruptcy.

Chapter 4: The New Skill Tree

So, what skills do developers need in 2026?

Old skill tree (deprecated):

  • ✅ Write code
  • ✅ Debug code
  • ✅ Design architecture

New skill tree (essential):

  • ✅ Audit AI code (more important than writing code)
  • ✅ Recognize AI hallucinations (it's confident but wrong)
  • ✅ Understand the system holistically (AI only sees locally)
  • ✅ Verification > Generation

Interview questions have changed:

Old: Write a Todo App in React (AI generates in 30 seconds)

New: Here's 500 lines of AI-generated payment gateway code. Tests pass. But logs show 3% of transactions are lost. Find the problem in 30 minutes.

Chapter 5: A Practical Suggestion

I've been exploring combinations of AI tools recently and discovered an interesting pattern:

Let AI write tests first, then write code.

This isn't TDD, it's TDD 2.0 — Test-Driven AI Development.

Steps:

  1. Describe the functionality you want
  2. Let AI write test cases first (including edge cases)
  3. Review the test cases — this is where AI's understanding gaps are most exposed
  4. Let AI write code to pass the tests
  5. You review the code

Why does this work?

Because tests are the "translation" of AI's understanding of requirements. If the tests are wrong, the code will definitely be wrong. And tests are easier to review than code.

Epilogue: The Truth at 3 AM

Back to the opening story.

The cause of that undefined is not a function error?

AI treated an async function as a synchronous function call.

Three-second fix.

But discovering this error took thirty minutes.

AI saved me time writing code, but increased review costs by an order of magnitude.

This reminds me of something:

We shouldn't fear AI. But we should respect the complexity of the systems we build.

AI is the co-pilot. You are the captain.

When the plane hits turbulence, the co-pilot doesn't attend the emergency meeting.

You do.

About the Author

If you're interested in AI development tools, I share practical resources and tool reviews at miaoquai.com.

Not an ad — genuinely sharing because I find it useful.

Top comments (0)