Here's a thing nobody talks about in the "building a healthy engineering culture" TED talks: junior developers are not the problem. They're predict...
For further actions, you may consider blocking this person and/or reporting abuse
Hahahaha yes 😭 I was exactly that mid-level developer once.
I still remember working on an Angular app right around the time React was becoming super popular, and I genuinely started thinking: “What if we just rewrote everything?” 💀
At some point I even found one of those Angular-React integration libraries so we could use React inside Angular. Absolute peak “I watched a conference talk and now I have opinions” energy xDDDDD
Thankfully, actual senior engineers were around to protect the codebase from my revolutionary ideas 😅
That's artisanal mid-level energy right there 💀. You weren't satisfied with a rewrite — you wanted a hybrid rewrite. Peak "I read the headlines of two blog posts and connected them with confidence."
I'm not a fan of labelling a person. There is too much knowledge to give a person a level sector wide. We are all AI juniors because the mainstream use is only a few years old and it still changes in important ways.
I do connect with the knowing enough to be dangerous mentality. I think it is a trap we all fall in from time to time. This has nothing to do with your overall knowledge. I think it is just our brain that wants to use the information that has just been put in front of us.
This is why experimentation is so important. You can act on that desire and have real world experience.
This is the biggest problem when giving people AI. Now people can act on that impulse of doing a rewrite, and it will be quick. The problem is that LLM's are trained on yesterdays code, which means to fill the gaps it will do weird stuff you only discover later on.
If one thing fits the mid-level developer as being portrait in this post, it is AI.
Yeah, I think you're right—the label is a shorthand for a mode more than a person. We've all been "mid" on some random Tuesday about some random thing we just learned.
And the AI point is brutal. It makes the dangerous part faster without fixing the "what breaks later" part. Giving someone a faster way to be confidently wrong is... not the upgrade we think it is.
I think part of the mid-level anxiety today comes from the feeling that the ground keeps moving under them.
Juniors are still learning fundamentals, so experimentation feels exciting.
Mid-level developers are in the weirdest position:
they finally became productive enough to feel valuable, right when AI started automating parts of the work they spent years learning.
Oof, yeah. That's the part I didn't name explicitly but you're right. Mids get hit hardest by the AI thing too — juniors are learning with it, seniors have pattern recognition to filter it, but mids are supposed to be the "productive ones" while also competing with autocomplete. Weird spot to be in.
The junior pointing out that the docs are outdated is doing something genuinely valuable — not because of the insight itself, but because they haven't normalized the dysfunction yet. Every experienced engineer on the team walked past those stale docs a hundred times and stopped seeing them. The junior sees them because they needed them and they didn't work.
The mid-level 3am refactor pattern comes from a real place: they've identified something genuinely wrong and have enough skill to fix it but not enough context to know why it was done that way or what breaks when it changes. The missing ingredient isn't ambition — it's the "let's think about what breaks in six months" reflex that only comes from having been the one who changed something that broke in six months. You can't shortcut that by telling people to be more careful. You build it by giving them scope and letting them own the consequences.
Yeah, you said this better than I did. The junior thing isn't about insight — it's about need. The docs didn't work for them, so they noticed. The rest of us just learned to swim around the broken stuff.
And totally agree on mids. You can't teach the "what breaks in six months" reflex in a Slack message. You have to let them break something small-ish and sit with the aftermath. That's the part that actually sticks.
The best devs eventually realize that shipping stable, understandable code beats winning architecture debates. Juniors ask because they’re learning, mids push because they’re proving, seniors pause because they’ve already survived the consequences.
Yep. "Pause" is the right verb. The whole job starts looking different when you realize the goal isn't being right — it's not getting a call at 2am.
Juniors ask. Mids assert. Seniors pause. I might steal that.
I'm that mid dev 😅
We all were. The ones who say they weren't are either lying or about to do something unhinged next week 😅
Welcome to the other side.