Progress Is Hard to See When You're Living It

By Joseph Ndungi

A few weeks ago I opened a folder I had not touched in three years. University projects. Final year stuff. I was looking for an old transcript and instead I found my past self, fully exposed, in code form.

There was a function with eleven parameters. Not because the logic needed eleven inputs, but because at some point past me decided that adding a parameter was easier than thinking about the problem properly. There was a variable called data2 sitting right next to one called data. There was a comment that said // fix this later directly above a block of code that, judging by the file’s last modified date, I never touched again. It is still there. It was never fixed later. Later never came.

I sat there laughing at myself for a some minutes. Then I felt something else creep in, which was a quiet kind of disbelief that I used to think this was good work. Not bad work. Good work. I remember submitting that project and feeling proud.

That is the thing nobody tells you about getting better at something. You do not feel yourself improving. You only see it in hindsight, usually by accident, usually while looking for something else entirely.

The Slow Thing You Cannot Watch Happening

Here is a problem with skill. It does not announce itself. Nobody messages you on a random day to say “congratulations, you now understand dependency injection.” There is no popup.

What actually happens is much quieter. You write the same kind of code for months. You debug the same category of problem enough times that your hands start solving it before your brain finishes complaining about it. You read an error message and instead of panicking, you just sigh, because you have seen this exact error message in three different jobs and you already know it is a null reference, it is always a null reference, it was born a null reference and it will die a null reference.

None of that feels like growth while it is happening. It feels like Tuesday.

I spent the better part of last year deep in a clean architecture .NET codebase, building out integrations, untangling dependency injection issues that would appear at the worst possible times, debugging things that only broke in very specific orderings of service registration. At the time it just felt like work. Annoying, occasionally rage inducing work. It was only when I had to explain DI lifetimes to someone newer than me, off the top of my head, in full sentences, without Googling anything, that I realised I actually knew this stuff now. Actually knew it.

I did not notice the exact day that happened. There was no day. It just accumulated.

Old Code Is a Mirror

Here is the uncomfortable bit. Looking at your old work is basically agreeing to let a younger, more confident, significantly more clueless version of yourself roast you from the past.

That eleven parameter function was not a mistake I made because I was lazy. I made it because I genuinely did not know there was a better way. I did not know what I did not know, which is the most dangerous kind of not knowing because it comes with full confidence attached. Past me looked at that function and thought “elegant.” Present me looks at it and feels something closer to secondhand embarrassment, the same feeling you get watching old footage of yourself trying to sound smart in a meeting.

But here is the part that actually matters. The embarrassment is proof. You cannot be embarrassed by something you have not outgrown. If I looked at that old code today and thought “yeah, still pretty good actually,” that would be the actual disaster. That would mean three years passed and nothing changed.

I will admit that growth is not always about getting smarter. Sometimes it is just about getting better at noticing when something is wrong, even when every part of you wants it to be right.

Recently I went through a whole job process, technical challenge, offer letter, the entire theatre production of it, only to realise partway through that I had been talking to a scam the entire time. I want to be very clear that I am not proud of how that played out. There was a moment, a very specific moment, where a part of my brain raised its hand and said “this seems off” and I overruled it because I wanted the outcome to be real.

I am not going to pretend that is growth in the traditional sense. It is not a skill I leveled up. But I will say this, the version of me from three years ago would have handled the aftermath far worse, probably by panicking quietly and telling nobody. This time around I knew exactly which steps to take, who to email, what to ask for, and how to actually try to fix it instead of just absorbing the loss and moving on. That part, the calm “okay, here is the plan” part, that is new. That did not used to be in me. Make of that what you will.

You Do Not Get to Watch Yourself Improve

Other people notice your growth before you do, because they are not stuck inside the slow motion version of your own life.

A colleague newer to the team will ask you something that used to take you a full day to figure out, and you will answer it in under a minute without even realising you just did the thing that used to break you. You will not register it as a milestone. You will just move on to the next task. But if you went back and told eighteen month ago you that you would casually solve that problem before your coffee got cold, that version of you would not believe it.

This is why talking to other engineers matters, not for networking buzzword reasons, but because they hold up a mirror you cannot hold up for yourself. They remember what you used to ask about. You do not, because you are too busy being the person who now answers it.

What I Am Taking From the Campus Project

I am not going to delete that old project. I thought about it. Genuinely considered quietly archiving it into a folder labeled “things that did not happen.” But I think it is more useful sitting there, slightly humiliating, slightly hilarious, as a fixed point I can measure myself against.

Progress is not a straight line you can watch yourself walking. It is something you only see by accident, usually while digging through an old folder for something unrelated, usually while laughing at a function that has no business existing with eleven parameters.

If you want to actually feel your own growth instead of just trusting it is happening somewhere in the background, go open your oldest project right now. Not the one you are proud of. The embarrassing one. The one you have been quietly hoping nobody ever opens again.

Open it anyway.

Happy Coding!