Good Judgment is the New Important Skill for Engineers
Why decision-making matters more than coding in the age of AI.
Intro
For a long time, being a great engineer meant having strong technical expertise.
The more you understood systems, algorithms, and the underlying technologies, the more valuable you were.
And that made sense, because building was a lot more difficult. Access was limited, and creating anything required deep knowledge and experience.
But that world is changing.
Today, code is easier to produce than ever. The gap in producing code has decreased, and what used to take days to implement can today be done much faster.
So naturally, the question becomes: If everyone can build, what actually differentiates great engineers?
The answer is no longer just pure implementation. Judgement is becoming an important skill for engineers.
This is an article for paid subscribers, and here is the full index:
- As Access Increases, Judgment Matters More
- From Pure Implementation to Decision-Making
- An Important Note on the Size of the Organization
- What Actually Good Judgment Means In the Engineering Context?
- The Cost of Poor Judgement
🔒 How To Develop Better Judgement
🔒 Experience
🔒 Actually reflecting on your mistakes and mistakes from others
🔒 Seek feedback
🔒 Understand the “Why”
🔒 Understand that every decision has trade-offs
🔒 Last Words
Let’s start with an analogy first!
As Access Increases, Judgment Matters More
Before the Printing Press Revolution in the 15th century, books were rare and expensive. Only a small group of scholars had access to knowledge, and learning itself was the main challenge.
Then, after Johannes Gutenberg invented the mechanical movable-type printing press, books became cheaper and widely available.
With books becoming more accessible, a new problem appeared. There were now too many books, more books than a person could read. So, the question changed from “Can you access the knowledge?” to “Which books are actually worth your attention?”.
A similar situation is happening today with the flood of AI-generated content online. And it’s no longer about how to find specific information, but which information is actually worth your attention. That’s where good judgment helps a lot.
And a similar case today is with developing software. With generating code being a lot more accessible, judgment becomes a lot more crucial.
From Pure Implementation to Decision-Making
As we see the shift happening across the industry, where more and more code is being generated instead of just typed out, the speed of pure implementation has increased tremendously.
With this shift, building the right things has become more important than ever. And that’s where good judgment comes into play.
Good judgment helps you answer questions like:
Should we build this feature at all?
Is this solution over-engineered?
What are the long-term consequences of this shortcut?
When should we prioritize speed over perfection?
And especially, if you can make these decisions correctly with speed, that’s where you can provide a lot of value in a very short amount of time.
Now, it’s really important to also mention that the importance of judgment heavily depends on the overall organization’s size. Let’s get to this next.
An Important Note on the Size of the Organization
Good judgment will especially shine where you are able to have a good amount of ownership, responsibility, and empowerment. That’s usually in smaller to mid-size companies.
A good example are teams at OpenAI, where they have a very bottom-up culture, and engineers often own projects straight from the idea phase and all the way to where the project is being released to the users.
If you are a part of a similar culture, judgment is more important than ever for you. If you are a part of a larger organization, it is much less, but the importance is growing.
In larger companies, there are more defined roles and a smaller scope that a specific engineer can have, which limits the overall impact you can have as an engineer. So, it’s definitely understandable that the overall judgement is much less effective.
But, I can see where the trend is heading: Smaller teams, more ownership, less typing, and more empowered decision-making. That’s where organizations want to go, but for larger companies with more rigid processes, that will definitely take some more time.
Now that we understand the importance of judgment, and the importance of it based on the size of the organization, let’s focus more on judgment in general.
What Actually Good Judgment Means In the Engineering Context?
Good Judgement is hard to define, as it contains many aspects, but personally, I like to view it as a combination of pragmatism and taste.
Pragmatism means that you find the best solution possible within the constraints of the real world, not the ideal world. Those constraints can be a specific budget, knowledge, expertise from the team, hardware constraints, people-related factors, or something else.
And taste from the engineering perspective is about making decisions that lead to systems that are simple and easy to evolve. Often, it’s hard to define what a certain “tasteful” solution is, but in many situations, you just know it when you see it. Think about what simple code looks like and how you would define it. You can’t, but your experience tells you it’s simple.
Often, both pragmatism and taste are heavily connected with experience and your overall understanding of your craft. The better you understand a specific domain or technology and the more experience you have solving similar problems, the better your judgment will be.
It’s the reason why experience, good understanding of fundamentals, and overall domain knowledge are more important than ever. It’s impossible to have good judgment without them.
The Cost of Poor Judgement
Good versus poor judgment can really make a huge difference.
Here is an example of poor judgment: Building a microservice architecture, with 2 engineers, while having 0 paying customers.
And an example of a good judgement: Building a monolith with the most important features of the product, so we can get paying customers as soon as possible.
Of course, there can be specific cases where building a microservice architecture would make sense, but you get the point.
Without the business, there is no engineering. So, the cost of making poor judgment in this case would be that the company would eventually need to be disbanded, as there would be no paying customers for a long time.
That would be the worst-case scenario, but in many other cases, poor judgment can also show up as an increase in technical debt, a slow system in general, reliability, or security issues as well.