New Junior Developers Can’t Actually Code
Something’s been bugging me about how new devs and I need to talk about it. We’re at this weird inflection point in software development. Every junior dev I talk to has Copilot or Claude or GPT running 24/7. They’re shipping code faster than ever. But when I dig deeper into their understanding of wh...
Namanyay, I’m sorry to say, sounds like a relative newbie when it comes to software development. The refrain “junior software developers can’t actually code” has been around as long as software development.
I remember when Stack Exchange first popped up, senior developers complained “junior developers don’t actually LEARN anything anymore; they just copy code off of Stack Exchange without understanding what it does!”
And before SE? We were doing the exact same thing in the comp.* newsgroups. And before that? When you started developing something, a senior dev dropped a bunch of books on your desk and said “when you’ve finished reading those, let’s talk.”
The truth is, ever since libraries have been a thing, the majority of developers have just used the libraries without really understanding what goes on inside them. And that’s not necessarily a bad thing — the entire point of abstraction is so that developers can focus on the stuff they need to get done while ignoring the already solved problems.
The issues arise when you place code monkeys in software architecture or senior development positions, and they’ve never had the curiosity to read through the header files for those libraries they use, but instead just let Claude code complete their way to functionality. Because then most style guides with teeth go out the window, as there’s no intention behind the choices made.
And this results in something that really irks (and always has) senior software developers: instead of writing really clean, performant and novel code, those senior devs have to spend all their time doing code reviews and editing and refactoring codebases that nobody else understands.
Same as it ever was.
From one senior dev to another, who remembers when O'Reily books were the gold standard, this, exactly this. Junior devs are junior because they don't know how to code. The important bit is that they learn and become intermediate devs. If in another decade we're sitting here complaining about intermediate and senior devs that don't know how to program, then we'll have a problem.
I say you're wrong. If in dacade we are stilling complaining about the same dev, then we have failed to teach. In a decade that junior dev should be a senior and probably better than me. If they are still junior either they don't have the ability to progress or I failed them. Most likely I failed them.....m
This is exactly right.
I was guilty of copy and pasting from Stack Exchange to meet deadlines.
The only thing I would add is complaining that colleges don't really teach coding for the real world and all boot camps are a waste of time and money unless that's the most effective way you can learn.
In reality, coding is something you can learn on your own… or not. Colleges are good for teaching computing science and architectural design, but the good ones will assume you already know how to code. The problem of course, is that when you graduate you are unlikely to find a job as a computer scientist or software architect, and will most likely need to spend 5+ years as a junior programmer first.
ever since libraries have been a thing, the majority of developers have just used the libraries without really understanding what goes on inside them. And that’s not necessarily a bad thing — the entire point of abstraction is so that developers can focus on the stuff they need to get done while ignoring the already solved problems.
Nobody but nobody has time to know what's in every library they might need to use. Who among us truly understands their network stack, all 8 layers?
senior devs have to spend all their time doing code reviews and editing and refactoring codebases that nobody else understands.
That's OK we will just train AI to review and refactor for us! I'm sure everything will be fine.
Vulnerable code will be with us forever. The system will always be Swiss cheese. If you think you understand common mistakes, enough that you can review other peoples' code for them, there's work for you in infosec for sure.
Yep I remember the same complaint 10+ years ago. They are jr for a reason.
Every junior dev I talk to has Copilot or Claude or GPT running 24/7.
Also
Hi, I’m Namanyay — a professional developer since the age of fourteen, now building AI tools to enhance human potential.
Bravo, sir, bravo 👏.
professional since 14
Hmmm child labor
When have they ever known to program? That is the point of being a junior.
feels like this is propaganda to pay juniors less and skirt seniors responsibility to train them
This feels a lot like the common “millennials can’t do X anymore” that we used to see all the time.
I switched careers recently from software engineering to teaching. Young people are fine.
Some things have changed. Those with no previous experience need a little help understanding file systems and moving files around, something they didn’t really have to do on iPads and Chromebooks.
Besides that students pick things up quickly. Find it as interesting and exciting as we did and often impress me by using more advanced features than we discuss in class.
Yes, they try to use AI. I usually explain to them that AI can likely do all their assignments in our classes not because AI is a good programmer but because these are introductory classes where the assignments are simple.
So far AI still can’t produce a perfect assignment for the students. And an easy way to tell they’re using AI is to see if their code is formatted too well. Most beginners will screw up indention somewhere in their programs. So what do I do if they use AI and then ask me for help (because AI didn’t do exactly what they wanted)? I tell them to let AI fix it. They end up having to rewrite so much before I help them that asking AI isn’t worth it to begin with.
Anyway, to summarize kids are still learning to code, still improving, and there’s going to be a lot of talented junior engineers graduating.
No. Junior Devs usually can't code. Anyone who lacks experience in a given field usually is not proficient in that field. That's not specific to software engineering.
The fix for this is pretty simple. It's just one that not every senior dev is going to want to hear. You have to do the one thing that a lot of us don't want to do: talk to people. You'll find that if you make an effort to build rapport with the juniors and be at least as quick to point out their successes as you are to point out their failures, more often than not they will learn to trust you and come to you for guidance.
Congratulations ... you've trained a generation of junior product managers.
And young cinematographers can’t use a light meter. Who cares? If the result is good the result is good.
The reality is “knowing how to code” isn’t a perfectly defined, singular thing. It’s ever evolving.
Something’s been bugging me about how new devs and I need to talk about it.
Missed a word in the freaking opening of the article
You know who wouldn’t have missed a word there? ChatGPT.
(Not saying it would’ve written a better article but AI is typically good at not making silly typos like humans.)
That's a broad brush to paint with. Pretty sure that there are people out there entering the workforce who know what an edge case is.
The more I code the more i realise I can't code for shit.
Not sure how this relates but similar vibe.