How AI made me relearn coding

After more than a year of AI-powered coding, I can honestly say this:

I had to relearn some of my own skills.

Earlier, experience came from doing things by hand.

You searched on Google.

You read documentation.

You struggled with an error.

You tried one approach, failed, tried another, then slowly converted that concept into your own solution.

That process was slow.

But it built muscle memory.

It built judgment.

It built a certain awareness around the framework, the language, and the problem.

With AI, the speed is completely different.

You describe the task, click once, and a working-looking solution appears.

That is powerful.

But there is a hidden cost.

When AI writes the code, the code may look simple while reading it.

But the mental work that goes into writing it is missing.

For example, many developers can read an async retry function with exponential backoff and understand what it does.

But writing it from scratch is different.

You have to think about:

• how promises resolve
• where errors should be caught
• how retry count should be handled
• how delay should increase
• what happens on the last attempt
• how cancellation should work
• how to avoid hidden bugs

That thought process is where real learning happens.

I used to tell myself, “I read every line of AI-generated code, so I am still learning.”

And yes, reading helps.

But I slowly realized something.

Reading code is not the same as thinking through the code.

Understanding a solution is not the same as building the solution.

If AI had not come, I am sure I would have learned many things more deeply, because I would have been forced to build them by hand.

It would have been slower.

But maybe more worth it.

The good part is, healing is possible.

For the past month, I have started using AI differently.

Not as a shortcut to finish tasks.

But as a tool to rebuild my fundamentals.

I create dedicated ChatGPT projects and ask it to teach me in a build-test-break-predict pattern.

For example: “Help me learn Kafka. Assume I have backend experience. Build an evolving project. Make me implement, test, break things, predict behavior, and then ask follow-up questions. Keep it fast-paced.”

That kind of learning changes everything.

Instead of just giving me code, it makes me reason through concepts like:

• partitions
• consumer groups
• committed offsets
• retries
• dead letter queues
• outbox pattern
• inbox idempotency
• failure handling

And because I build, break, observe, and answer questions, the knowledge starts coming back.

AI can make us lazy.

But it can also make us sharper if we use it properly.

The mistake is not using AI.

The mistake is letting AI do the thinking for us.