Every project is trying to teach you something. The question is: are you listening? Or just writing codes?
I was working on a project recently when I discovered something that genuinely surprised me. It was related to how I had structured the public pages of the application for reusability. I had a group of similar pages that shared the same general structure, so I decided to make the underlying page structure reusable rather than build each page independently. It was cleaner, easier to maintain, and avoided unnecessary duplication.
At first, it felt like exactly the kind of decision you want to make as a software engineer. Then I discovered the trade-off few days after, while revewing the codes I had written.
The approach made the pages reusable, that's speed for me, but it also meant I was not handling page-specific metadata as effectively as I needed to for SEO performance. The implementation was solving one problem while quietly creating another.
And that was the interesting part. I had used this kind of approach before. I had probably made similar decisions without thinking much about them. But this project forced me to look at the decision differently.
It reminded me that every project is supposed to teach you something. Not just about the technology. About your assumptions. Your architecture. Your tools. Your decisions. Your habits. Even the things you thought you already understood.
There are things you think will work that will fail. There are things you are convinced will not work that turn out to work perfectly. There are architectural decisions that look great in isolation but reveal their weaknesses when they meet the actual requirements of a project.
The code is constantly giving you feedback. Every function, every feature, every dependency, every architectural decision and every line of code encapsulates some kind of insight. Sometimes the insight is obvious. Sometimes you only recognise it after something breaks.
The difference is whether you are paying enough attention to notice it.
I think this is one of the reasons experience matters so much in software engineering. People who have worked on many projects have simply had more opportunities to encounter these lessons. They have seen more approaches fail. They have discovered more trade-offs. They have made more mistakes and had more opportunities to correct their thinking.
Experience is not just the number of years you have spent writing code. It is the number of things you have learned from writing that code. That is why I think rushing from one project to another just to say "I have completed another project" misses something important.
When you finish a project, you should not only have delivered something.
You should know something you did not know before. And this matters even more now that we have access to incredibly powerful tools.
There is a constant temptation to chase the newest framework, the latest library, the cutting-edge tool or whatever happens to be trending in the developer ecosystem. AI makes this even more interesting because it can now do a significant amount of the heavy lifting for us.
And there is nothing wrong with using these tools. The problem is when we stop paying attention because the tool is doing the work. AI can write the code. It can suggest an implementation. It can debug an error. It can even explain why something works.
But AI does not automatically make you intelligent. It only reveals your intelligence. It amplifies what you give it as input, but it cannot replace the curiosity, judgement and understanding required to know whether what it gives you actually makes sense.
If you let AI do all the heavy lifting without understanding what is happening underneath, you may finish more projects without necessarily becoming a better engineer.
So I think we need to learn to listen to our projects. Pay attention to the decisions we make. Question the assumptions behind them. Notice the unexpected behaviour. Understand the trade-offs. Ask why something worked, why something failed and what the experience should change about the way we build next time.
Because the goal should not simply be to become someone who can use more frameworks, more tools or more AI.
The goal should be to become someone who understands more. The newest tools will change. Frameworks will come and go. Today's best practice will eventually become yesterday's best practice. But the fundamentals remain.
And every project gives you another opportunity to strengthen them. So, while you are working on your current project, don't just ask yourself: "How do I finish this?"
Ask yourself: "What is this project teaching me?"
What are you learning from the project you are currently working on?
Share it.