I've been consistently amazed at how far companies can get on shoddy code.
In my experience, even majorly successful startups that turn into companies worth 10's of billions tend to have lots of technical debt.
Honestly, I believe that at some scale its very difficult to get the caliber of experience and talent that can keep a codebase clean.
People often say accruing technical debt is a form of shortcutting to a more business focused goal, but in my experience the technical debt is almost always created by accident through lack of experience rather than a conscious tradeoff. Especially when you consider a SaaS company where your product lives forever and is meant to scale, taking on technical debt for short term gain is almost never the right decision.
Not to reopen the 10x engineer debate, but I've observed that the top 20% of engineers tend to do 80% of the total work of an org. Of course, 10x is relative... But there are definitely individuals that are 10x more productive than the median engineer. And for whatever reason, that seems more to do with an individual's personality and drive than their level of experience... Though of course experience helps.
Especially as a project scales, somebody who makes good technical decisions will only increase the productivity margin between themselves and others. What I see in a lot of these SaaS codebases is that it takes a week to do something that should take 1 day, due to amount of technical debt and spaghetti code.
Software is still a new industry. I fully believe the companies that win in the long run will be the ones that have the best codebases (assuming software is what differentiates your business). The impact that it has on velocity is just monumental.
Code quality and philosophy of well written code is not stressed at all in school... One example of how far off we are from maturity as a discipline. There is a whole school of thought that's currently neglected that will become mainstream in the future IMO. Similar to other engineering disciplines...
> Especially as a project scales, somebody who makes good technical decisions will only increase the productivity margin between themselves and others.
I once saw a customer obsessed junior engineer push out features that our users really wanted, but that none of the senior engineers had time for.
Half a year or so later one of the senior engineers was complaining that he had to rewrite everything that junior engineer did due to how poorly the code was written.
End of the day? The junior engineer's code is what got shipped and made the user's happy. Was it tech debt that had to be rewritten? Sure. Was my team happy with him for being willing to work with us to make the product better? Yup.
Perfect is the enemy of the good and all that.
(I've also seen code where changes took a long time because someone invented a DI framework and layers of XML configuration files when a single if statement with 2 branches would've done the trick. Was the solution well engineered? Yes! Very reliable, good quality code. Took me a few days to get ahold of it and add that 2nd conditional...)
Sure, but if a senior engineer had written it in the first place, it wouldn't have had to be rewritten, thus saving lots of time (assuming senior engineer is strong technically :))
If you had instead hired an additional senior guy who was paid 1.5x compared to the junior guy, it would have been a better outcome for the business all around. Of course just using this contrived example, and the exact salary numbers change the outcome...
I value code well written, maintainable, and testable but sometimes I'm a bit put off on certain conclusions. Once I read a report by a guy who had come in into a business to re-work an, by his words, unmaintainable mess. This had been written over five years by a single guy and no-one seemed to be able to make sense of it.
The one re-writing touted what they had accomplish, a full re-write with a team of 15 or so people, in a couple months. I can believe that some guys are dickheads and do crap and are anti-social or don't want anyone touching their stuff and think they're the last cookie in the packet.
On the other hand, there's a real difference between writing from scratch something, with features tacked on week-in week-out, contradicting requests, no time to work through issues or problems, being the only one allocated to the problem and having no real plan or feature map laid out, during 5 years and then coming in, when all the system is laid out, all the bugs and domain knowledge have been made visible, there's a working system that can be used as base to understand the objectives, the rough edges, problems and pain points are also known, and rewriting it from scratch better.
Lastly, it's also not known if they had been the ones writing from start with the same constraints if it would have been so pristine as they claim, and it hasn't stood the time for 5 years yet. Maybe it'll end problematic as well but now it took a team of 15 or so that probably cost more than that single guy for 5 years - and still made something that helped keep the business throughout.
Part of the problem is that "well written code" is unbelievably subjective. Take 10 people from hacker news and you will get 10 likely very different answers, some of them most likely the exact opposites.
Maybe it has to do with being "a new industry", but by now we have accumulated decades. I think it's more because you can get away with it. In other industries, you can't. If a bridge collapses, people die. If a car's brakes fail, people die. If you administer the wrong amount of anesthesia, people die. If you write spaghetti code .. shrug and move on.
Even within the code base of the place I work in, a few hundred sw engs in total, we don't have a shared understanding of what exactly "good", "clean", ... design is. Everybody has an idea, and there are overlaps, but the criteria that people seem to optimize for, and thus the conclusions they draw about design, differ vastly. Within my company, and even more so across our industry.
> Part of the problem is that "well written code" is unbelievably subjective.
I'd recommend you check out Code Complete if you haven't read it. It is an excellent intro into best practices although its about 1000 pages and a bit dated. As it turns out, we as an industry do have an understanding of what makes code better, and it turns out, its mostly not very controversial - push complexity as low as it can go, simpler interfaces tend to be better, argument pass through causes errors, functions longer than 80 lines are associated with higher error counts, optimize code for human comprehension later (~70% of the effort that goes into code is maintaining it) etc etc.
What I personally check out does not matter much. My point was a lack of consensus within the industry. It does not help if I read the same book as you and we two agree 100% what exactly we mean, when the next guy considers most of that nonsense. And that's what I observe with colleagues.
> it turns out, its mostly not very controversial
I don't believe this until proven otherwise with actual data. Any programming concept on this planet eventually gets an article on the HN front page that argues for why that particular concept is really bad and then we are having a huge discussion about it.
> I don't believe this until proven otherwise with actual data.
I don't remember the last time that a piece by Uncle Bob or Martin Fowler—and they're just two examples, I've seen quite a few more who are generally met with agreement every time they're posted—was heavily criticized or disagreed with here.
And when I do see disagreements, they tend to come from people who don't seem to have nearly as much experience as those guys do or who might have misinterpreted their point (much like how the idea of agile has turned into something that only reflects the manifesto tangentially, and accidentally at that) and who are, perhaps not coincidentally, likely to fall in the "programming is easy" camp.
And even then, "controversial in hacker news" is hardly representative of what's controversial in the field at large (which I also understand goes against my own first point).
If anything, Code Complete was for me further evidence of its subjectivity. I'd have to pull the book out again to find examples, but I remember finding a good 20-30% of the "better" examples actually more difficult to read, or there being a third way of doing it not mentioned in the book.
Heh, good code is the kind you can throw away once you’ve used it to sell stakeholders on an idea. It’s contextual. Or, to put it another way: is a very structurally sound bridge located on a road that no one uses considered a “good” bridge?
I'd raise a difference between good and useful then. That is still a good bridge, but it's not a useful one. I think that also transfers to programming. That also raises that what makes a bridge good is not usefulness it's perhaps structural quality. Maybe the only thing that makes programming good is usefulness in which case my point is moot.
There's subjectivity, but you can also certainly make objective arguments for why one form is readable relative to others.
For example, here are some principles I can strongly justify:
Bubble important info. Structure your code visually such that signal to noise ratio is highest. E.g. appropriately named variables should be more immediately visible than implementation details. E.g. if variable is named well, you can typically ignore the RHS of an assignment... It's an implementation detail. Don't indent such that RHS of assignment is emphasized. We can debate that point, but I'm using objective reasoning for defining why this style is beneficial.
Human readable naming. Name of variables should define exactly what they represent and nothing else. Your code should be written to read as closely to natural language as possible. E.g. if in a functional language, and all functions describe what they do exactly, RHS of assignments are indented to deemphasize them, you can understand high level of any function quickly by scanning LHS assignments and top level expressions. The more unclear your names, the more "mental recalls or lookups" the reader has to do.
Don't use anonymous functions. For anything longer than one line, always used a named function that appropriately represents what it does. Reader should not ever get implementation details pushed into their face. Pushing implementation details to the forefront is the biggest readability error I see in code. It's almost never important for business oriented code unless there's a bug in it. Majority of the time the reader is simply trying to get context and understand meaning of the code. Optimize for this.
Hide your declared functions out of sight. Reader will get high level understanding of their use where called, due to their name. If they want to reference the implementation, they can go to function declaration, but typically they won't need to. Don't declare functions sibling to your core logic. They should not break high level flow of function (does not help readability). Frustrating when people declare functions above where the core logic of the function is... See it a lot in python due to lack of inner function hoisting. Books have footnotes for a reason
Hide implementation details as much as possible behind api boundaries.
Model component apis such that implementation details are not exposed to caller or creator. Don't mix naming of business concepts and render logic. E.g. if you have a generic graph component, nothing within that component should reference your business domain. I see this mistake a lot. More generally, never name something which implies an understanding of a different context than the one you're in. By doing so you're coupling the two domains and increasing the amount of context the reader needs to understand your code.
Prefer immutable variables. The more constants and immutable state you use, the fewer things you have to track in your head as you follow code. You know once you see an assignment, that variable will never change. You don't need to scan every line between assignment and later use to determine whether that var is later modified.
Don't nest expressions too deeply, such that it's difficult to parse. If you can instead assign to appropriately named variable, reader can typically ignore the expression altogether.
Prefer named function or variable that describe the result of a computation rather than inlining an expression. If featureFlag == 1 represents isFeatureEnabled, assign that to an appropriately named variable. Anytime you make the reader "infer the name" of a variable by parsing the expression themselves, you make your code harder to read.
camelCase is superior to snake_case because a variable represents a single concept, not separate concepts represented by a string of words. Adding underscore unnecessarily makes words visually distinct when you're dealing with a single concept. They also add verbosity and length that doesn't benefit anything. Is there an objective argument for snake case being more readable other than it's the convention in some languages (not objective reasoning) (Flame war go!)
Anyway, I could go on with a number of more points. Am I suggesting there's a correct style? Not at all. But you can absolutely use strong and objective reasoning for why one style is superior to another. I don't see people typically apply this kind of rigor to their style, they tend to just prefer one approach "because".
Different people will weight things differently, so can come to different conclusion given same evidence, but there's absolutely a whole set of philosophy and logic you can use to justify style, and it's not explored at all in academia really.
Final note. There is definitely an element of cultural bias as well. People who tend to read code of one style will more readily be able to parse that style. There is no universal truth. But if we all start from the same state, we should justify which styles are best with strong reasoning.
Because I agree with most of it, but you called for a flame war, I'm going to jump in.
snake_case, is obviously the more readable. In fact your point shows this cognitive dissonance we all have to a certain extent. You argued (and I agree) with a lot of details that are important for readability at "first sight", "intuitive layout" etc, and then you go to say camelCase is more readable...
We're not even taking into account people with small amounts of dyslexia in this, but
certainlyThisIsNotMoreReadable than certainly_this_is_not_more_readable
Maybe if you're a foodie person? :)
kebab doesn't allow to do whole selections on most text interfaces though so that's a real downer for me, no matter how much a good kebab is worth
Thanks for this long list. But again, that's missing the point. Everybody has their list of what they do and why. And everybody is pretty convinced that this is how it ought to be and they have good reasons. I'm not saying yours are wrong. But for most of your points, I know people who'd argue the exact opposite. And they give good reasons too.
Point is that we don't have a shared, common, well-defined core in our industry. A list that everybody adheres to. Our lists are not in sync.
The variety of programming languages that people can choose from now does not help either. Standard practice in one language is a cardinal sin in another. Different patterns, different principles, different paradigms. People mix and match freely.
My point is that most people's "list" is not rooted in objectivity at all.
I provide objective and concrete reasoning for why these style elements are beneficial. In the wild I rarely see people justify their style with strong convictions.
Again, different people can reach different conclusions given the same evidence, so there will never be a universally correct way to do things.
But there's also is a lot that's done by convention that's hard to justify objectively.
The biggest faux pas I see is pushing implementation details to the forefront. There are arguments to be made that this can be beneficial in some contexts, such as algorithms where you want a "single pane of glass" into what's happening. But you can also objectively specify those contexts and when a style is more applicable to one context vs another.
So long story short, no, there is no best style. Yes, you can objectively quantify why a style is good or not, and in which contexts. Beyond specific style elements, there is a philosophy underlying the readability of code style and will eventually become a big part of education in software IMO.
Other industries/areas have firmly established standards. Our industry needs those too, badly. Not just for style, but overall for design and architecture.
Maybe it's because software development is so easily accessible that we don't have them yet. To become a surgeon, you need to go to med school for an eternity. To become a construction engineer you need training and government certification. Both areas move slowly, compared to programming. In our industry, a language that's older than 10 years is called "mature" and the hipsters leave it for a younger one. And the next 16-year old can jump right in. That's not bad, it keeps our industry exciting, but it does not allow us to establish rules everybody agrees to, applies and defends.
>I've been consistently amazed at how far companies can get on shoddy code.
I think this was one of the most disheartening realizations of my career. I spent and still spend a lot of thought on how to improve code for readability and maintainability just to realize companies can make a lot of money with crap for a long time.
I think it's more of a correlation not causation thing :)
All else equal, the company with the better codebase will be more competitive/make more money.
But at the same time it's just true that for most companies code quality and technical excellence are not core qualities of their culture. A lot of companies say that it is, but they don't live it... Or the original founder/technical team don't really have the chops to enforce that quality and make it a core element of the business.
Of course that doesn't meant they're not smart. I've known a huge number of highly intelligent people that don't care about code quality, or the future human reader. Needs to become embedded in culture of the org for it to trickle down and become lived in practice.
This is where I shine in start up environments. I can throw together “working” implementations quickly while also having the forward thought to allow the system to be incrementally replaced or improved overtime. My starting implementations can look rough and sloppy, but I use consistent patterns and designs that guide building out more complex systems as we go.
I have also done the opposite of taking an existing monolithic spaghetti code system and start isolating functionality without changing behavior. This then allows to improve and replace sub systems as needed.
If the 10x and gatekeeping people want to give us methods for getting to 10x productivity/skill, I'm all for it. But articles and threads like these always fail to give up a method of reliably training that quality and accurately testing for it.
Until I can hold up a plaque where humanity agrees that I'm a proven 1x, 5x, or 10x engineer and I deserve money and a job according to each of those levels, it's all just posturing and debate.
Unfortunately I'm not sure it's trainable. It seems much more correlated to an individual's personality and drive.
The traits I see in engineers who I consider to be 10x:
Growth mentality. Always try to do things the "right way" rather than just completing a task. Educate yourself via internet/books to understand all points of view on an issue, and tradeoffs of each approach.
Setting a high bar for your work. Never solely focus on getting the job done, always question and focus on what the best way to get the job done is.
Extremely self critical. Don't get attached to your work. Always criticize yourself and question whether decisions you made were correct.
Objectivity. Always quantify objectively to yourself why you made a given design decision, why
did you name your variable X vs Y? Could you justify the merits of your approach to others without relying on subjective points?
Focus on business value. Optimize for what drives business value. Don't pursue projects that are technically interesting that don't provide long run value, for example.
Work with intensity. These people legit code 8-10 hours a day straight. They aren't coding for 30m then browsing the internet.
Never give up. Regardless of how technically challenging or impossible a task seems, they will work tirelessly to find a solution.
Self managing. Can operate 100% independently without constant manager intervention. High level direction still important to align on business goals of course.
Ownership. These people take pride in their work and feel a sense of ownership over their code. They don't need to be asked to step in when something they've worked on has an issue.
It's not about specific knowledge at all, or training.
People could learn to follow these principals, but it's much easier when it's in your nature. I have not seen anyone really change their trajectory from median to superstar before, but I'm sure it's possible with a mentality shift.
> Never give up. Regardless of how technically challenging or impossible a task seems, they will work tirelessly to find a solution.
That is actually a failure mode - the engineer that tirelessly works towards an impossible goal.
The 10x engineer has the critical heuristics/intuition/skill to avoid dead-ends, and also the engineering taste to concentrate on technically hard but possible tasks and the skills to deliver.
> These people legit code 8-10 hours a day straight.
That's physically impossible, unless you're performing some assembly line task like creating a frontend prototype from a marvelapp mock (tons of html, css, js).
Can you do creative work for 10 hours in a stretch, every day.
I would consider myself a highly productive person and I have many of the qualities they pointed out. I can’t program that long, I program in hyper-focused bursts. I have had many coworkers comment/complain that it looks like I’m not working because I’m surfing the web, watching YouTube, daydreaming, etc. But I’m constantly designing, debating, and thinking out how I should implement something that by the time I actually go to code it I know what needs to be done and bust it out in a couple hours. My managers commented on this early in my career because other developers think I’m lazy, unprofessional, or unproductive when I’m usually the most productive person on the team. Working from home removes this problem for me.
> One afternoon, I was bent over a program listing while Wendl was staring into space, his feet propped up on his desk. Our boss came in and asked, “Wendl! What are you doing?” Wendl said, “I’m thinking.” And the boss said, “Can’t you do that at home?”
Averaging around 350k lines of code a year for a few years. This was mostly frontend/product focused work, so there is more boilerplate than in other disciplines, of course.
It's also important to note, the higher quality the codebase is, the less energy it takes to add to it. If you spend 50% of your time reverse engineering spaghetti code, it will be way more tiring than adding to a codebase where design is sound, code is very human readable/friendly etc.
It certainly takes a lot of energy, but why do you say it's impossible?
Been coding about 20yrs, In my case its not as much as the IQ but the ability to switch perspectives. I have seen that when I code or debug for long hours often I lose that critical ability and I often repeat the same mistakes. Eventually I take hours to accomplish what I would in 30mins, thats when its time to wrap up.
but I should point out that long stretches of time are different from quite (context switch free) streches of time.
In my case I was working in a codebase that I largely built myself, so I understood all design decisions and code at all times. It's much easier to operate in this environment.
I have worked on less clean codebases where I spend hours tracing state through spaghetti-like code, and there's no way you can productively code for lengths of time in those environments.
It's always better to refactor that kind of stuff ASAP, assuming the longevity of the product matters, and the refactor is a tangible improvement over the original.
So it was more or less a large solo project? How do you know your code base was much better than those less clean/spaghetti codebases? Your own code is obviously easier to read/understand than that of others. In general it's easier to write code than to read/understand code of others. Developers who are founding members of a codebase are able to navigate it better vs those who come later and therefore able to work much faster. It may give them a false impression that they are genius 10x coder. Then when developer who comes later is not able to be productive, founding developer would blame it on incompetence of newer developer. But it could also be that codebase is of poor quality, but as founding developer you don't see it. It's hard to be objective about your own code.
Now let's go to the reverse situation when you are spending hours "tracing state through spaghetti-like code". It could in fact be that it's actually a great code written by a 10x developer, but you are not smart enough to understand how it works. It's natural to blame someone else and not you.
Not a solo project. I was an early dev at a startup and owned that feature area. Later on others took over the code.
How to judge whether a codebase is
high quality?
Consistency of design and abstraction. Does the code use the same abstractions and design throughout? Consistency is one of the most important things in quality. How many unique concepts and abstractions do you have to learn to understand the code? E.g. in frontend context, do you use the same pattern for managing business oriented state? How is that state updated? Are those patterns consistent throughout your codebase? The biggest problem I see with the spaghetti codebases is they lack consistency in design.
Separation of concerns. What's the blast radius of any given change? If I change render logic, can it impact business logic, and vice versa? A big problem I see is that codebases do not appropriately separate these type of things out. Meaning the code is fragile and it's easy to introduce bugs inadvertently.
Anyway, I can list many points, but I'm on mobile now.
High level indicators would be: How quickly can new devs jump into the codebase? Is it easy to diagram and explain to others how the code is structured? How many bugs come out of your codebase? How quickly can you add new features to that codebase? What is the "blast radius", or is it possible to break something seemingly unrelated to a change you're making?
How do I know my codebase was good quality? I was extremely self critical when writing it and ended up rewriting it a few times before it was in a state I was satisfied with. Number of bugs are extremely low and feature velocity is high, relative to other areas of the code.
I don't think there needs to be a 10x label. It's not healthy to actually call people out as 10x or not publicly, I definitely agree with that.
But the truth is there are people who are insanely productive relative to median, and 10x is just a rough term to refer to them.
I do think it's worth paying those people 2x or more over paying 1x for two median devs. The trick is being able to identify them accurately... that relies on a well honed interview. There's risk in compensating people so highly if your judgment turns out to be wrong.
Certainly definitions won't be universal, but this type of person tends to do very well regardless of the environment/language etc.
Well the label could be anything and the same problems are still around. The same goes for being labeled a software craftsman or not. There's enough flexibility in how we assess peoples' skill that I can accidentally get the label if I just keep trying and the stars align. (This being a genuine, verifiable belief of someone else who's in the field and not me simply lying about what they said). With interviews, those can vary by company and the person giving it. It'd be more consistent if that was focused on a widely known credential and institution that's dedicated to assessing it. When I can take company and people's biases out of it, I can more objectively decide how good I am, what I need to improve on, and what level I should be working jobs at.
I do think certification and credentials can play a much bigger role than they do today.
No, I'm not talking about the BS certifications where you can spend a few hours reading a book and pass a multiple choice test... but something more "elite" and well rounded to give a quality stamp of approval.
It would be a great thing if candidates could go through one process, get that stamp of approval, and receive offers from X companies.. rather than interviewing 100 times. I understand the needs of companies are individual, but most candidates who are "strong" will do well interchangeably at these companies... if it's more of a generic development role.
The difficult thing is that the industry seems very stuck on algorithm and design problems as the sole focus of judging a candidate, which are pretty easy to game (design less so than algorithms). To identify these kind of people you really need to judge real world code and productivity... large projects with more elements of design.
Beyond technical skill, how hardworking is the person? How much will they care? Personality traits like these tend to matter a lot more than specific knowledge.
Anyway... this is kind of a meandering response, but I do believe that in the future we'll have a much better system for interviewing with less redundancy and higher accuracy. The goal is to maximize correlation between performance on the interview and performance "on-the-job".
IMO being "10x" or whatever is not really about productivity or skill, or rather, those are necessary but not sufficient. What it really comes down to is doing the work that makes other developers more productive. In other words, the 10x developer doesn't output ten times as many lines of code or complete ten times as many stories. They simply make everyone else's life a little easier by identifying and working on the important stuff.
>Software is still a new industry. I fully believe the companies that win in the long run will be the ones that have the best codebases (assuming software is what differentiates your business).
There are so many counter examples (Facebook, Microsoft to name two) to your point it simply can not be true.
So your view is that the long run is a few decades? :)
When I say long run, I'm talking hundreds of years. Software as an industry is not even one generation old yet. There are countless advancements that will come.
That being said, I don't consider social networks to fall into the class of an area where your product is the main differentiator. Network effects come first, product second.
Database products are a better example. JIRA another. It's the most widely used now but extremely slow and buggy. I sincerely doubt JIRA will be the winner 100 years from now if they don't improve technically.
In fact, a lot of software companies these days are just competing with traditional companies, but with better software. That's the whole selling point. E.g. fintech replacing banks, uber replacing taxis, insurance companies that make it easy to make claims etc. The bigger the tech disparity, the bigger the advantage.
> So your view is that the long run is a few decades? :)
I suspect that there's almost nothing going on at the Ford Motor Company that has even the remotest connection to anything technical that happened during the early years of the company's founding.
I guess it depends on how much leeway you can be given for using “almost nothing” and “remotest connection to anything technical”, but Wikipedia says Ford Motor Company was incorporated in 1903 and the first assembly line dates to 1913.
Engine blocks are still cast, sheet metal is still bent, pressed, and rolled so I think there is a lot of the original years still around. Yes, I’ll give you that there have been huge advances in sophistication, but it seems to me the early years are still present.
So many good points in this post. But I’ll nit pick this one anyway :-)
>technical debt is almost always created by accident through lack of experience rather than a conscious tradeoff.
I agree with this, at least early on in the business. But my experience is that many organizations eventually realize their technical debt. Sometimes the realization comes so far down the line that it feels like a monumental task to fix and then it does become a conscious decision. “We know the code base is shoddy and needs to be fixed, but the schedule/cost risk outweighs the quality risk.”
>Software is a new industry
In the early 1990s I heard it referred to as the “cave drawing days” of the industry. I wonder if it’s similar to how mechanical systems were in the early days of the industrial revolution. Lots of innovation, very few codified best practices related to pressure systems etc. It seems like the steam era of “move fast and break things”. Eventually, industry caught up and put together standards like ASME codes (or were regulated to do so). I’d like to see this more commonplace in software beyond its current adoption in a few industries
In my experience, even majorly successful startups that turn into companies worth 10's of billions tend to have lots of technical debt.
Honestly, I believe that at some scale its very difficult to get the caliber of experience and talent that can keep a codebase clean.
People often say accruing technical debt is a form of shortcutting to a more business focused goal, but in my experience the technical debt is almost always created by accident through lack of experience rather than a conscious tradeoff. Especially when you consider a SaaS company where your product lives forever and is meant to scale, taking on technical debt for short term gain is almost never the right decision.
Not to reopen the 10x engineer debate, but I've observed that the top 20% of engineers tend to do 80% of the total work of an org. Of course, 10x is relative... But there are definitely individuals that are 10x more productive than the median engineer. And for whatever reason, that seems more to do with an individual's personality and drive than their level of experience... Though of course experience helps.
Especially as a project scales, somebody who makes good technical decisions will only increase the productivity margin between themselves and others. What I see in a lot of these SaaS codebases is that it takes a week to do something that should take 1 day, due to amount of technical debt and spaghetti code.
Software is still a new industry. I fully believe the companies that win in the long run will be the ones that have the best codebases (assuming software is what differentiates your business). The impact that it has on velocity is just monumental.
Code quality and philosophy of well written code is not stressed at all in school... One example of how far off we are from maturity as a discipline. There is a whole school of thought that's currently neglected that will become mainstream in the future IMO. Similar to other engineering disciplines...