For years I thought "senior" was a skill bar. Learn enough algorithms, master enough frameworks, cross the line, get the title.
I was completely wrong, and it cost me about three years.
I knew more than half the seniors around me and still got passed over for the role. It stung. Then a staff engineer told me something over coffee that rearranged how I saw the whole job, and I'm going to give it to you for free.
Senior is not a measure of how much you know. It's a measure of how much less other people have to worry because you're on the team.
Junior developers are paid to write code. Senior developers are paid to reduce uncertainty — technical, organizational, and human. The code is table stakes. The job is everything around it.
I believed the path was: get really, really good at coding, and seniority follows automatically.
So I optimized for that. I learned the internals. I could whiteboard a B-tree. I refactored everything in sight. And I genuinely was the strongest pure coder on a couple of my teams.
I also caused problems. I rewrote things that didn't need rewriting. I'd disappear into a "perfect" solution for a week while the team waited. I argued I was right in code review when being right wasn't the point. I optimized for my own correctness instead of the team's velocity.
That's a senior coder. It is not a senior engineer.
Here's the shift, stated plainly. A senior developer's primary output is not code. It's good decisions, made cheaply, that other people can build on.
Watch a real senior for a week and you'll see where the time goes:
None of that shows up as commits. All of it is the job.
When I finally looked at what the seniors I respected actually did, the pattern wasn't technical depth. It was a set of unglamorous skills:
They communicate so clearly it's almost boring. No ambiguity, no jargon flexing. They write the design doc that ends the argument.
They have taste, and taste means restraint. Junior me added abstractions. Senior me deletes them. The hardest engineering decision is usually what not to build.
They make other people better on purpose. They review code to teach, not to win. A real senior's footprint is a whole team that levels up around them — the kind of impact I dug into when I wrote about the Git habits that quietly save my team hours every week.
They're calm when production is on fire. Not because they're fearless, but because they've built the reflex of "reduce blast radius first, find blame never." Martin Fowler has written for years about how the discipline of the craft lives in habits like this, not in raw cleverness — and that calm under pressure is the same one I leaned on when I rebuilt my debugging into a repeatable method instead of a panic.
The most senior person in the room is usually the one asking the simplest question — the one everyone else was too embarrassed to ask.
There's a reason that question-asking reads as senior, not junior. Asking "wait, why are we building this?" in a room full of people nodding along takes confidence, not ignorance. The junior who's faking understanding stays quiet to protect their image. The senior who actually understands the stakes is willing to look momentarily dumb to save the team two weeks. That willingness to trade your ego for the team's clarity is, all by itself, a senior trait — and it's one you can practice starting today, in your very next meeting. The next time you're nodding along to something you don't fully understand, stop and ask. Worst case, you learn something. Best case, you discover that half the room was nodding along to a misunderstanding, and you just saved everyone from building the wrong thing. That's the kind of contribution that doesn't show up in a commit but shows up in your reputation, which is the currency seniority is actually paid in.
The moment I stopped optimizing for being the best coder, I got better at the actual job almost overnight.
We had a nasty incident. My instinct was to dive in and fix it myself — be the hero. Instead I did the senior thing without realizing it: I grabbed a doc, started writing down what we knew, assigned two people to two leads, and kept the channel calm and updated. I barely touched the code.
We resolved it in half the usual time. Afterward my manager said the thing that got me promoted three months later: "You ran that well." Not "you fixed that well." You ran it well.
That's when I understood. The promotion wasn't waiting on my coding. It was waiting on me stopping making it about my coding.
If I could go back, here's the list I'd hand junior me:
| Junior mindset | Senior mindset |
|---|---|
| "How do I build this?" | "Should we build this?" |
| Best coder wins the review | Best outcome wins the review |
| Add abstraction | Remove abstraction |
| Fix it myself | Unblock three people |
| Knows the answer | Asks the right question |
Here's a frame that finally made the whole thing make sense to me: seniority is a trust account, and you make deposits and withdrawals every day.
Every clear design doc, every incident you handle calmly, every time you say "I'm not sure, let me check" instead of bluffing — that's a deposit. Every missed deadline you didn't flag early, every rewrite nobody asked for, every time you were right but made it about being right — that's a withdrawal. The title comes when the account is consistently full enough that people route important, ambiguous problems to you by default, without being told to.
I missed this for years because trust is invisible and code is visible. You can point at a commit. You can't point at "the team felt safe shipping because she was on it." But that feeling is what gets you the role, and it's built in a thousand small interactions nobody logs.
The practical upshot changed how I spend my days. I stopped optimizing for impressive and started optimizing for dependable. Dependable is boring. Dependable is answering the message, scoping the ambiguous thing, writing the doc, being calm. It's also, it turns out, exactly what a senior engineer is. The flashy 10x-coder myth sells conference talks. The real promotion goes to the person everyone quietly relies on, and reliability is a choice you make on ordinary Tuesdays, not a talent you're born with.
If the shift from "best coder" to "most dependable engineer" resonates, it's the thread running through most of what I write — and worth sticking around for if you're building toward the role rather than just the title.
Q: Do I still need to be technically strong? Yes — it's the floor, not the ceiling. You can't lead what you don't understand. But technical strength alone caps you at "great coder," not senior.
Q: How long does it take? Less about years, more about reps making real decisions and owning the outcomes. Some people get there in four years; some never do because they never stop trying to be the smartest person in the room.
Q: What's the fastest way to grow? Take ownership of something ambiguous and see it all the way through. Ambiguity is where senior skills are forged.
Q: Can AI tools shortcut this? They shortcut the typing, not the judgment. If anything, they make judgment more valuable, because anyone can now generate plausible code.
The brutal truth is that I spent years training the wrong muscle.
Becoming senior wasn't about learning more. It was about caring about different things — about trading "look how much I know" for "look how little the team has to worry."
Stop trying to be the best coder in the room. Start being the person who makes the room work. That's the whole secret, and almost nobody says it out loud.
So here's my question for you: are you building skill, or are you building trust? Because only one of them gets you promoted.
Leaving my job wasn't a leap of faith. It was a spreadsheet. Here's the runway math that turned a terrifying gamble into a boring, calculate…
No following, no network, no luck. Just an unglamorous system I ran for eighteen months. Here's exactly what I did.
I went from 200 to 11,000 subscribers without hiring anyone. AI didn't write my newsletter — it did everything around it.
Comments
Sign in to join the conversation
No comments yet. Be the first to share your thoughts!