Where have you worked where senior engineers do hardly any coding? What else would they do all day?! Are you sure you aren't thinking of project managers?
Everywhere I've worked (mostly large companies) the seniors write much more code than the juniors.
Juniors write a lot of code. Often significant amounts for a company's products and services. They're the ones who are implementing all the decisions that seniors spend their time making in all their meetings.
Most senior engineers I've seen have most of their days filled with meetings with very little actual coding time.
The seniors are valuable, making decisions, coming up with solutions, building frameworks etc, but it's the juniors who then take that and run with it and build everything on top of it.
So while some will still code, it's far less than what the junior engineers are creating.
Yes they require some more training, and clear direction, but they are the ones actually creating and executing the vision of the company informed by the seniors.
What companies really want, like others have said, are senior engineers who are willing to accept a junior salary.
While of course companies would love senior engineers willing to accept a junior salary I'd say
> Most senior engineers I've seen have most of their days filled with meetings with very little actual coding time.
Is actually a symptom of the shortage of senior engineers. Big companies that can afford to hire as much talent as they want actually will let seniors write code all day (my company does) because they have the economies of scale that lets them afford doing so; no one else can.
I'm senior and been at many companies. We still write a ton of code. Of course, you do that and still do PRs, attend boring meetings, mentor juniors, etc.
The thing is, senior programmers really aren't always that useful. We want leadership, we want big meaty projects and problems, we know so much and can do so much... Except that sometimes what needs doing is boring. It's grunt work. It's some infrastructure migration or a real simple API addition. A lot of coding is actually not that hard depending on where you are. That work we consider grunt work is a great way for a junior engineer to learn and they don't complain as much as we would. I've worked with a lot of other senior folks and (like myself) and we have entire abandoned features because no one wants to own them. It's a gift when someone junior shows up and jumps in.
Juniors do most code, seniors less. Those who work on easy tasks produce most code, those who work on hard ones less.
And then there are usually senior positions where producing code is just part of your responsibility - compliance, analysis, negotiation, architecture, operations, troubleshooting shooting.
This is laughably false. The highly-paid, experienced seniors produce so much more value than juniors that it's not even in the same ballpark. It's also usually the kind of value that juniors don't even notice, because it's not measured in lines of code.
A good junior will write a hundred lines of code in a day. A good senior will delete a hundred because they realize the user dictated a solution instead of detailing their problem, asked them, and figured out that they can solve that problem by changing a config variable somewhere.
In fairness, the ratio of "just write code" to everything you listed above changes quite drastically as your seniority increases.
To be sure, there will always be some senior/staff/principal engineers who sit in a room by themselves and code all day without talking to anyone, but, typically, the more senior you get in an organization the more your job consists of things other than writing code. When you're a junior or a mid, however, writing code makes up the vast majority of your day.
Because they are two different jobs usually. Juniors are more focused on code while senior trends towards planning, reviewing, and leading. In my experience a senior is just as likely to spec out some work and pass it on as do it themselves.
I haven't seen many junior engineers write code I was particularly impressed by, or that could stand the test of time. It's more tech debt, but it's also learning. Others here have said a mix of junior + senior is ideal, and I agree. But for some things, you need speed and low tech debt: those projects are when you should lean more heavily on your senior staff.
Junior engineers willing to burn themselves out doesn't bode well for the quality of work you're getting.
In addition, I think it's the fault of management if it's all young engineers.
I've often said the difference between a senior and a junior isn't writing software successfully, it's writing software that's maintainable 5 years down the road. The only way to learn that skill is to deal with a project over years and learn the pain points that aren't immediately obvious w/i the first 18 months.
This is why, in retrospect, I miss my days as a junior engineer.
When I was a junior, there was plenty of room to learn and screw things up without much risk. I had plenty of opportunities to write brand new software for any which purpose, and the possibility of advancement was really exciting.
The longer my career went on, the more my job became about fixing crap, fighting brittle tests, and trying to squeeze enough information out of the org so I could actually get my job done properly. Now that I'm a senior engineer making above the average income for the role, the only advancement left for me is to become a lead or staff engineer, neither of which I am at all suited for. In either case, it would be more of the same.
I'd have more to say, but I've got to hop on a pair programming call with someone. :)
I’m having troubles imagining how more experienced eng could be slower than junior provided their code is reviewed and tested to the same standard. Unless the task is so soul crushingly rote that your senior is looking for another job rather than working on it ;)
At my organization, everyone's code gets reviewed before deploy, everyone (especially leads and managers) is learning and getting mentored, and everyone gets guidance (new projects and major changes have a design doc that goes out to the whole engineering org for comments).
Tech leads are expected to do more architecture but having direct reports and writing code are usually mutually exclusive.
Most of us senior devs don't write that much code anymore anyway so there is work involved in tech without coding.. although to get here we all wrote code. I'm not sure how juniors will get trained up in the future
Yea, a lot (not most) of seniors at Big Tech spend 50+% of their time writing docs that never result in anything or otherwise really did _not_ need a doc, or "generating ideas" and "fielding questions" from someone 3 teams away from them.
The mid-levels engineers are doing a lot more of the grunt work of writing code. At a small company, new ideas are great, but you really need someone that can just sit down and pump out code. Move fast, bias for action.
Source: I've worked at various sized companies from 5 person seed, to 300 person high growth, to Big Tech.
Maybe we do. I don't know what you think a Senior Engineer does. I think a senior should be able to take responsibility and ownership over his work and the work of his team. I don't think they're able to predict business needs without any feedback about those business needs. I certainly think a senior should be able to divide big chunks of work into smaller parts, because even a junior should be able to do that; that's pretty much the core of programming.
I also think a senior should be able to understand how a development process works without resorting to silly strawmen.
Everywhere I've worked (mostly large companies) the seniors write much more code than the juniors.
reply