I've been developing software for about ten years now. Depending on who you ask, that apparently means I'm a "senior developer". But I've never really felt comfortable calling myself senior. Not because I think I'm terrible at what I do, but because after ten years I've become painfully aware of just how much I still don't know. And weirdly, I'm completely fine with that.

When I was earlier in my career, saying "I don't know" felt dangerous. It felt like admitting weakness. You'd be sitting in a meeting while someone casually mentioned some framework, architectural pattern, database feature, obscure Linux command or JavaScript library created approximately six minutes ago, and you'd sit there nodding like you knew exactly what they were talking about. Because obviously the worst possible thing you could do was admit you hadn't memorised the entire software industry.

I remember a friend telling me that when React was still the shiny new thing, their colleagues were discussing how to build a new form on a client website.

A single form.

And somehow the answer was, "We should use React."

Why? "Because it's cool". Because everyone was talking about it. Because it came from Facebook, so apparently that settled it.

The point is, don't get caught up in the hype just because something is new and shiny. Popular doesn't automatically mean appropriate.

Sometimes a form is just a fucking form.

Over many years, I started to realise that there was no harm in my challenging the norm. In my opinion, it shows character. It shows that you're thinking outside the box. You have an alternative view point that perhaps not everyone else can see. Don't be afraid to challenge anyone who tells you that you must know something or that you must use some particular tool. Maybe put the question back on them. Why? Why do I need to know this right now? What problem is it solving for me? What happens if I don't use it? "Because everyone is using it" isn't an answer. Neither is "because it's the future". If you're going to tell me I absolutely need to spend my limited time learning something, you should at least be able to explain why without pointing at a fucking hype graph or regurgitating something some tech CEO said during a keynote while trying to convince shareholders that their latest product will "redefine the future of software development".

Programming is too big for anyone to know everything. It always has been, but I believe that the problem has become significantly worse over the last decade. Probably because in that time, nearly every single person on the planet is wired into the Matrix in some shape or form. The ecosystem moves at a completely stupid pace. Languages evolve. Frameworks appear. Frameworks disappear. Frameworks get rewritten because somebody discovered signals, islands, server components, edge functions, or whatever phrase we're collectively pretending is revolutionary this month. The amount of knowledge available to us is enormous, and the amount of new shit being thrown onto the pile never stops.

There's an excellent article from 2016 titled How it feels to learn JavaScript in 2016 by Jose Aguinaga.[1] I recommend giving it a read. It basically describes just how fucking crazy the Javascript industry had become, how ludicrous it all was, and perhaps still is. I remember reading that article when it was originally published. It was around the same time I was properly entering the industry as a professional developer. Sadly, a lot of it is still relevant today. I should have treated it as a warning. Hindsight is a bitch.

Every few months, a new tool appears and suddenly the internet collectively decides that your career is in immediate danger unless you start using it. YouTube fills up with videos titled things like "YOU NEED TO LEARN THIS NOW", "THIS CHANGES EVERYTHING", and the ever-popular "I'M NEVER USING X AGAIN". The thumbnails usually contain a shocked facial expression, three arrows, a fire emoji, and the vague implication that you're already technologically obsolete.

And people fall for it, including yours truly. I can't count how many times I've been guilty of jumping on the bandwagon when a new technology is released, spending hours trying to learn it, only to come to the realization of, "how is this any better than what I'm currently using?" 4 months later, said technology is nowhere to be seen.

You see enough people talking about the same thing and eventually you start wondering whether you're the idiot for not knowing it. Maybe everyone else really has moved on. Maybe your skills are becoming outdated (they're not). Maybe you're falling behind (you're not). Maybe you should spend your evening learning yet another framework instead of doing literally anything else with your life (don't).

It's not difficult to see how that constant pressure feeds into the wider anxiety and burnout problems in this industry. Research into software-engineer wellbeing has repeatedly found issues around psychological distress, workplace stress, exhaustion, anxiety and burnout. That doesn't mean YouTube thumbnails are single-handedly destroying developers' mental health, obviously, but an industry built around relentless change, comparison and the feeling that you should always know more probably isn't helping.

Developers already worry constantly about becoming outdated. There's always another language you haven't learned, another framework you haven't tried, another cloud certification you don't have, another architecture diagram you don't fully understand. Then some influencer appears to tell you that everyone is moving to a new tool you've never heard of, therefore you should drop everything and learn it immediately. Conveniently, they also happen to have a twelve-part tutorial series on the subject that's "On sale now". It's funny how it's always "on sale now". Pure coincidence, obviously.

Do they actually care whether you use that tool? Fuck, no.

They care whether you click the video. They care whether you watch the sponsor. They care whether you subscribe. They care whether the algorithm decides their content deserves to be fired into the eyeballs of another hundred thousand anxious developers. That's not necessarily evil. People are allowed to make money. But we should stop pretending every piece of content is neutral technical advice handed down from some sacred engineering mountain.

A lot of it is marketing.

And marketing works best when you think you're missing something.

While we're on the subject of the "Cool Kids Developer Club" tutorials, don't fall into the trap of thinking, "Fuck me, this person really knows what they're doing. Look how fast they're typing. Look how quickly they came up with that solution. Am I supposed to be that fast too?"

No. You're watching a video.

Videos can be paused, edited and chopped up. The forty-five minutes spent staring at an error message wondering why the fuck nothing works somehow doesn't make the final cut.

Most likely, that developer spent hours, perhaps days, working through the problem, researching it and recording the thing before you ever saw the neat twenty-minute version.

There is absolutely no fucking way you're going to convince me that a video titled "Let's build an API together using Svelte McShite" was conceived, implemented, debugged, explained and recorded perfectly in twenty minutes.

You're watching the finished performance, not the process. Just like a Hollywood blockbuster, you're not seeing the 24 takes it took to get the scene right. Again, I don't know, and do I need to know? See how easy that was?

Basically, don't compare your messy process to somebody else's edited highlights.

The reality is that a new framework doesn't immediately invalidate the thing you're already using. Some of them might genuinely be brilliant, but that doesn't mean you need them. A company successfully shipping software using technology from five years ago has not somehow failed because somebody on X found a more fashionable way to render a button.

Your job is not to know every technology. Your job is to solve problems.

Sometimes that means learning something new. Sometimes it means using the boring tool you've used for years because you understand it and it works. Sometimes it means admitting that another developer knows more about a particular subject than you do. None of those things make you less experienced.

In fact, I'd argue the ability to say "I don't know" is one of the things that actually comes with experience.

Early-career developers often feel like they need to prove themselves. Experienced developers eventually realise that pretending to know something is far more dangerous than admitting you don't. Bullshit has a nasty habit of making architecture decisions, and architecture decisions have a nasty habit of surviving for seven years because nobody wants to touch them.

I've met clever developers who constantly admit what they don't know. I've also met developers who seem physically incapable of saying those three words and will instead produce twenty minutes of confident nonsense to avoid admitting they're unfamiliar with something. That just wastes everyone's fucking time, by the way. I'll take the first person every time.

And seriously, learning something new together can be incredibly powerful. There's a reason humans have spent centuries sticking thirty confused children into the same room with a Teacher and hoping something useful happens. Learning isn't just about individual brilliance. You bounce ideas off each other. You challenge assumptions. One person notices something the other missed.

Cliché incoming: two heads are better than one.

And then COVID happened, and working from home went from being the perk everyone wanted to the default almost overnight.

At first, it sounded fucking brilliant. No commute. No pointless office small talk. No sitting under fluorescent lights while someone reheats fish in the kitchen. You could roll out of bed, open the laptop and get on with it.

And for some people, it genuinely was better.

But over time, I don't think it was quite the utopia we were promised.

Something gets lost when everyone is permanently behind a screen. Those little moments where you overhear someone struggling and offer an idea. Turning to the person next to you and saying, "Have you ever seen this shit before?" Junior developers absorb things simply by being around more experienced developers.

Remote tools are useful, but they don't magically recreate that. You can send a Slack message. You can jump on Teams (God forbid). You can share your screen. But there's still friction that wasn't there when someone was sitting six feet away.

And that matters when you're learning. At whatever age.

The lesson isn't that offices are essential or working from home is bad. That's far too simplistic. It's that software development is still a collaborative job, despite our industry's occasional fantasy that the ideal developer is some hooded genius sitting alone in a dark room producing perfect code or having their Agent do it with a handful of carefully crafted skills.

Sometimes learning requires being around other humans. Who knew?

Software development isn't an exam where you're expected to memorise every answer before entering the room. Half the job is knowing how to investigate something you don't understand. Read the documentation. Build a small prototype. Ask someone. Search the codebase. Break something locally. Swear at it. Discover the problem was a missing environment variable. Swear again.

That's programming.

Which is why some developer interviews have always felt a bit absurd to me.

You're given a technical question you've never seen before and expected to produce the correct answer immediately, as if that somehow proves whether you're a competent developer.

But real software development doesn't work like that. Requirements are vague. Systems are messy. Context matters. Documentation exists. Google exists. Your colleagues exist.

Quite often, the most accurate answer to a technical question is:

"It depends." - Povilas Korop[2]. Champion.

And that's not avoiding the question. It's acknowledging that software rarely gives you a useful answer without first understanding the constraints.

A good developer doesn't necessarily know the answer immediately. A good developer knows which questions to ask next.

So if you've been developing for years and still regularly encounter things you don't understand, congratulations. You've discovered the actual size of the field.

You're not falling behind because you haven't tried the latest database, runtime, framework, AI coding tool, deployment platform or JavaScript package named after some woodland animal. You're not stupid because someone on YouTube built a demo with something you've never heard of.

Ask better questions.

What problem does this solve?

Do I currently have that problem?

Would learning this actually improve the work I'm doing?

Is this technology likely to matter to me six months from now?

Or am I just feeling pressured because fifteen people published the same fucking thumbnail this week?

There's nothing wrong with learning new things. Curiosity is one of the best parts of being a developer. But curiosity and panic are not the same thing.

Learn because something interests you. Learn because it solves a problem. Learn because your job requires it (to a degree). Learn because you want to broaden your skills.

Don't learn because an algorithm convinced you everyone else already has.

After ten years, there's still an enormous amount of programming I don't know. There always will be. I'm really only knowledgeable in a handful of technologies.

And, I'm ok with that.

They're the technologies I enjoy using for the things I enjoy building. Fuck the rest, it's just fluff. Knowing 20 more technologies that your colleagues have doesn't automatically guarantee you more money or extra entitlements. If anything, it'll definitely guarantee you more headaches and sleepless nights. "Yeah, but then I'll be able to add it to my LinkedIn bio", right?

"I don't know" isn't the end of the conversation.

It's usually where the useful part starts.