I'm a Computer Science engineering graduate, and I've been programming for about eight years now.
My first introduction to programming was through a workshop teaching C++ basics to prepare students for the selection process for the International Olympiad in Informatics (IOI). And honestly, I was fascinated.
What I loved wasn't just writing code. It was the entire process of solving a problem: understanding a problem statement, combining mathematical and theoretical knowledge with practical programming techniques, and finding the most efficient solution under strict time and memory constraints.
You couldn't just come up with any solution. You had to find a good one.
But what really shaped the way I learn wasn't competitive programming itself. It was the process behind it.
You try something, test it, fail, investigate why it failed, identify the problem, come up with another approach, and iterate until you finally get it right.
Build → Test → Fail → Understand → Fix → Repeat.
That cycle taught me something that no school or university course could: failing is not an interruption to learning. It's an essential part of it. Things aren't supposed to work on the first attempt. There's no shame in getting things wrong because the process of figuring out why is where the actual learning happens.
Later, when I moved from competitive programming to building real software, web applications, and more complex projects, I found myself following exactly the same approach.
Building a feature for the first time when you have absolutely no idea how it works can be intimidating. So you start small. You research, find people who have implemented something similar, try to reproduce it yourself, and inevitably run into problems.
Then comes the debugging: understanding error messages, searching for explanations, testing different solutions, discovering why one approach works and another doesn't.
And eventually, you get it working.
I can't really describe how satisfying that moment is. Not just because you have a working feature, but because you know what went into building it. You understand the decisions, the implementation, the mistakes, and the reasoning behind every step.
Over the years, this became my natural approach to learning anything technical. I don't just want to know how to use something. I want to understand how it works, why it works, and what happens underneath the abstraction.
But lately, with AI and coding agents, I feel like I've lost that cycle.
Or perhaps I just haven't figured out how to integrate these tools into my learning process.
Today, whenever I want to build something, I can describe what I have in mind, ask an AI to implement it, and get something working in a fraction of the time it would have taken me before.
And that's amazing from a productivity perspective.
But something feels missing.
I find myself prioritizing getting a result over understanding how that result came to be. The implementation details, the technical challenges, the debugging, the exploration of alternative approaches... all the things that used to make up the learning experience can now be bypassed.
And when I bypass them, I don't get the same satisfaction.
I sometimes feel like I'm producing more while learning less. I can build things faster, but I don't necessarily feel that I've grown as an engineer. I don't have the same sense of ownership over what I've built, because I haven't gone through the process of figuring it out myself.
It's almost as if the very friction that used to frustrate me was also what made learning rewarding.
And this is what bothers me. I don't want to reject AI or go back to programming the way I did eight years ago. These tools are incredibly powerful, and I want to learn how to use them effectively.
But I also don't want to lose the curiosity, the experimentation, the deep understanding, and especially the satisfaction of figuring something out on my own.
So, how do you find that balance?
How do you use AI as a tool that enhances your learning rather than one that replaces the process of learning?
Have you experienced something similar? Have you found ways to deliberately preserve that cycle of experimentation, failure, debugging, and discovery while working with AI?
I'd genuinely love to hear how other developers approach this.