10x Developer

Apparently this is a saying that has been going around for a while, but I’ve only come around it recently.

“For as long as I’ve been in software, there’s been talk of the 10x developer. These are the people you want to solve your problems; they’ll do it in 1/10th of the time, with 1/10th of the number of lines of code. They sound awesome.” Source

What is a 10x Developer?

I need to be a 10x developer. Right now, I am a Terrible Programmer.

But what really is a 10x developer? If you can make an app in 1 day that takes someone else 10 days, are you automatically a 10x developer?

I don’t think so, because I think a 10x developer should also be good programmer, i.e. also someone who writes good code, i.e. clear and maintainable. Good programmers can write code that can scale.

I think relating to the stuff I am related in, I just need to grind Competitive Programming so I get really good at programming. This is the skill I need to ace these interviews. I need to think faster.

10x developers are fast. To be fast, they must quickly combine high-level thinking and low-level thinking. What made me realize this is talking to Chester and what Ross Evans said on the last lecture of CS247.

Chester is probably one of the few 10x Developers I know, even though he is quite humble to say that he isn’t. He feels that he is still lacking experience.

How did he get to where he is today?

  • Every single time he runs into an error, he tries really fucking hard to understand why that error is happening. So that the error never happens again.

This is a common pattern with all really great problem solvers, it’s that they really look down fundamentally at a problem by First Principles, and ask WHY.

Always ask WHY, get to the root of the issue. Go down to the lowest level of Abstraction.

The best problem solvers always think from First Principles.

You might feel like you are wasting time, but actually, you are not. These are issues that you are probably going to run into again in the future, so you might as well master it now. Like learning about unique_ptr, constexpr, noexcept, and nodiscard.

So whereas I would simply make a new note every time that a new concept is introduced, Chester actually spends the time to look more deeply into that concept. Maybe like 20 minutes to make sure he understands.

  • And he does this because he is intrinsically curious about its purpose.

Ask Yourself

Ask yourself why people do things the way they do. Why did they make this design decision?

I feel like I’ve focused too much on pattern matching. But the reality is, I should probably focus way more on building strong intuition.

This way, you have a much easier time Reasoning. Because Reasoning is a skill that you don’t lose. But with Pattern Matching, you lose that with time.

The reason he is able to remember a lot of the things that I forget, is because he genuinely had a question on how the thing worked. Whereas I kind of just get introduced to the concept. If you are genuinely curious about how a certain implementation works, because not knowing gives you headache, then you spend the time to look into it.

Chester spends a lot of time ”slacking off”, but what I’ve realized is that half the time that he is slacking off, he is really going down random rabbitholes.

I find that amazing.

This is different to my style of learning, where I try to be really focused on a certain topic.

Seeing someone like Chester really made me realize the power of Compound Effect: Everyday, you just learn a little. One thing at a time. It’s crazy how much more you can learn and accomplish over multiple days and weeks.

I guess that is also how Ross Evans became cracked at C++. He was just intrinsically curious.

What about usefulness of your code?

Another thought: If you write 10,000 lines of code a day, but no one benefits from it at the end of the day, are you really a 10x developer still? This idea is explored in this semi-satirical video by TechLead. “skill alone is not sufficient”. Someone else needs to use it.

This is why I try to make videos so the stuff I make ends up being useful.

Other characteristics:

10x Developers

  • George Hotz (you can tell from his livestreams how fast he codes, though he talks about how it is an act)
  • Chester Chung (working with him on the Biquadris project)
  • Ross Evans (not 100% sure, but just seeing how long he’s been programming for, and how well he teaches CS247 )

Inflection Points in My Programming Journey

Hopefully, with enough inflection points in my programming journey, one day, I will become the 10x developer that I’ve wanted to be.

(Sep 2021) Learn Vim because of George Hotz

  • Made me so much more efficient with manipulating code (Sep 2022-Mar 2023) Doing my Self-Driving RC car and really getting into robotics (May 2023) Taking CS247 and falling in love in C++ (CS138 didn’t achieve that) (Aug 2023) Seriously learning how to use the debugger in VSCode? naa that’s not it. It’s realizing that I need to go down layers of abstraction and getting serious about getting good at programming. Read Clean Architecture.

(Aug 2023) Chat with Chester and Brian Chen (his work at Open Robotics and he is so knowledgeable about ROS) made me realize that I totally need to go down more the layers of abstraction and try to understood how things work under the hood.

(Sep 2023) Learn CUDA, whole new programming paradigm with parallel thinking


Beyond just copy pasting on stack overflow, you REALLY REALLY need to understand what is the issue that is causing everything.

NEVER pick the easy way out. It is going to BACKFIRE in the long run. Figure out why a bug happens, and you’ll never make the same mistake again.


I feel like the reason I’ve neglected the get a deeper understanding of the material for CS241e is that I didn’t see the need. Same for CS348. But if you answer your own questions, and tie it back to the knowledge that you have, you will do a lot better.

Some ideas to exercise high-level low-level thinking

  • References are a thing in C++ (high level). But they don’t really exist on the actual hardware. How does one go about implementing references?