1x Engineer
1x.engineer
1x.engineer
I've been a 10x, 1x and 0.1x developer. Let me tell you: most business or managers have a hard time distinguishing between all of them.
- 10x: You're smart, knowledgeable and passionate. You love going to the office and create code. Love the team and are moving forward every day. You're doing meaningful work. Managers love your work. You get excellent reviews. You earn as much as your colleagues.
- 1x: You do your job to get money. There's a lot of business shit, stupid decisions all around you. Dispite that, you try your best to do your job. You sometimes complain to managers, they claim they can't do much. You get good reviews. You earn as much as your colleagues.
- 0.1x: You spend your days wasting time on the internet (Hi there, welcome to HN! :D). Some days you do nothing, some days you spend 15 minutes fixing a bug. You find excuses of things you are stuck at. Managers give you good reviews. You start questioning when you get good reviews, what the fuck your other colleagues are doing? Are they also goofing off all the time? Probably. You earn as much as your colleagues.
you soak up tons of time of other developers' mentoring time while never "learning how to fish". you can't figure out how to solve problems so you're always stuck. you choose the wrong path of investigation and waste weeks on the wrong line. you won't post your code for review until it's "ready" so no one's ever sure really how to help you or your progress. people complain about you to managers but nothing is done. you get good reviews. you earn as much as your colleagues.
0.1 devs are actually fine, they don’t really exist unless they stare at YouTube for 36 hours each week. Usually when incompetent devs start to do something the result turns negative quite quickly.
I worked with person who told his/her manager that "they [mozilla] decreased stack size in firefox[0] and that's why app doesn't work because there was a lot of recursive calls under the hood cuz they used knockout.js or something like that"
the actual reason was some null or some other trivial thing
[0] I checked that later and they even increased it in last versions.
Edit: Sorry my explanation wasn't complete. In my opinion, getting a 10x developer has more to do with the work environment than with the developer. Some companies or structures just don't allow you to be a 10x developer.
More like 200% more.
There's a lot of Europeans here in the Valley, but almost no Americans in Europe. There's a reason for that. There are also "dark matter devs" in Europe that are working remotely for SV companies, at SV salaries. They simply won't ever show up for interviews at local companies.
> In my opinion, getting a 10x developer has more to do with the work environment than with the developer.
I recall a story someone told me a while ago. Software business that did local CoL/prevailing wages. Hired an intern one summer that was just running around in circles around the other, more senior devs. Next summer they tried to get him back but he was already at a large search engine company down in the Bay. Of course, he wouldn't return. That's when they realized a whole class of engineers were completely invisible to them; they lucked out hiring him that summer but there was no chance they could attract someone like him full time.
I think there's a default engineer level and then 0.1 or the -10x :) The -10x will create complexity that cannot be undone.
This said an engineer is just an engineer. The problem is many coders are not engineers.
Theres no reward for being 10x at 99% of companies. If youre that good, start your own company.
To a person, none of them wanted to start their own company. In my experience, they want to come to work, write great code, go home at 5pm and collect a paycheck.
With that said, there are plenty of entrepreneurs and technical co-founders who think they're 10X developers. That's how you end up with large legacy Ruby codebases (I kid, I kid)
At my last job, I was part of a crack team of senior consultants spent months building a CRUD service that basically did nothing but passing data from incoming requests to another API, and then doing the same with the responses. Because the service was distributed, this was asynchronous, and state was persisted in a byzantine state machine. By God were all the buzzword dev-ops checkmarks green. The entire team spent most days navigating a maze of elaborate OpenAPI specs, trying to make sense of nebulous kubernetes failure states, and debugging spontaneously self-breaking Jenkins pipelines that took a full hour to run each time regardless of fail or success. Hours were spent documenting the work, multiple daily standups, updating Jiras with elaborate definitions of done, time reporting in multiple tracking systems. It could take a full week of this stuff to bring a trivial code change into production. That was at most 0.1x development. I spent a lot of time browsing the internet because I literally couldn't affect the speed of the work, I was always waiting for some process somewhere to decide to finish so I could repeat the cycle.
Note: Many of these things are necessary sometimes in larger projects. This was not a large project, but it was run as though it was, leading to a development workload that was almost entirely process overhead.
In my spare time, I developed an internet search engine, and quite literally was 100x more productive than I was in my dayjob because I had none of that bullshit in the way.
That's one way of running a tech company but what you'll end up with is going to look more like one of those comically bad bodyshops that's used for outsourcing. These have a turnover so high it's almost impossible to find someone with more than two years of experience. And, well, the results speak for themselves.
Truth is, the 10x will eventually leave when someone from his circle points out he has a much better comp package than him and lure him for an interview (and will, of course, cash that 10K referral bonus). But the 1x and 0.1x will sure stick around for many years.
TLDR: Don't get stuck at "0.1x". Do leetcode and switch while you get competitive salary.
In a new company you are usually 1x for the first year. You might be a 10x for a while after the first year then some thing changes like a project move or disagreement with technical decisions/manager/raise then you become 1x and then 0.1x. This is a dangerous time. Better switch. If you don't in the next appraisal cycle you will get compensation below you skill level and then its hard to get your compensation back.
You can even find examples. Fabrice Bellard immediately comes to mind.
"There's no such thing as a 10x engineer" people probably haven't seen a normal distribution before.
And yet there aren't 17 meters tall people (avg adult male height back home is 1.7m)
Mind you, I consider the whole discussion stupid since it's an intellectual/creative job
Every. Single. Instance. Of trying to measure such things has failed at producing consistent results or results with predictive capability.
Talking about X times engineer makes no sense when you don't even know what a 1x engineer is.
It's not that the 10x engineer is a myth - it's a fallacy. You'll find that people in the same profession (any profession) will have variance in their abilities and their return to a project, but it's a big leap to assume that someone that appears to perform much better than their peers is actually doing so in any objective sense.
The 10x engineer is more likely than not the person most familiar with the project and the codebase, knows the real reason why Mark didn't just put everything on Kubernetes or why Tanya didn't want to switch from React to Vue before leaving the team.
Or.. it's an engineer that has the ear and the faith of higher-ups in the organisation to deliver results because they're good at convincingly taking credit for them.
Generally I find that 10x engineer on here means "knows more than most about [tech stack X]" and can work quickly. That's cool if all other things are equal, but I've had to clean up more than a couple of catastrophic messes left in the wake of people that worked quickly.
Just to pre-empt someone telling me I must never have met a real 10x engineer or some other such dismissive response - I'm an average fish in an average pond. I've had people tell me how good I am in the past, both reports and managers, and have in both cases corrected them politely that I've just had more time with the problem/project/codebase than others have.
Anytime I hear someone talk about 10X engineers, let alone describing themselves as that, all it makes me think is that there's a failure of humility.
None of this belittles Fabrice Bellard. Or John Carmack. Or Chris Lattner. Or [known and respected programmer]. Their achievements speak for themselves.
You could give names of people in the field all day. There's a lot of us around. How many of the self-described or colleague-described "10X engineers" floating around are Linus Torvalds?
Their solutions are elegant, performant and survive design changes. Their code is easier to maintain. Paying 2x the average to these people is a steal,as they are a LOT better than that. Not sure how much, but I'd rather have one of them on my team than 3 average engineers (probably more).
I'm not saying average engineers aren't useful workers. They are, they get things done if they aren't incompetent. But they are nowhere near a 10x engineer.
10x engineers aren't perfect. But they are amazing nonetheless.
If you have never worked with one, maybe it's because you had bad luck, haven't been around long enough or haven't worked in great teams. Whatever the reason,once you meet a 10x, you will know it.
That should save us some time.
> Whatever the reason,once you meet a 10x, you will know it.
Guess not.
* You've never met a 10x engineer, and you can reason clearly and cogently as to why they don't exist, so you conclude that they don't exist;
* Someone ... indeed, several someones ... tell you they they have met, worked with, and/or managed people who really are 10x engineers;
* You say that these people must be wrong.
This feels a lot like the biologists who wrote - convincingly - that kangaroos can't exist. They'd never seen one, and gave completely water-tight arguments that the method of locomotion was inherently impossible.
This computer-aided leap in output actually does separate software engineering from every other discipline except things like pure math.
The use of specialist tools to increase output happens in hundreds of other careers and I’m sure it just falls under learned knowledge of the craft.
But I'm not sure there are any other disciplines where a single person does it regularly.
I think the difference is we're not dealing with anything physical. A structural engineer never has the leeway to invent new ways to build bridges while under deadline. Maybe some ingenuity and process improvement along the way, but nothing like 10x on any single project.
Nope.
To whatever extent they actually exist, the 10x engineer is the one who starts without a codebase, and creates one that is elegant, flexible, extensible and performant, avoiding mistakes and working faster than most of their peers would. They build a platform for their successors to work with that enables more than it impedes.
If you've never seen this, then fine, but that's most likely because you've not been around during the prehistory phase of a given codebase.
I think the debate is over the properties of that distribution, and whether it needs to be plotted on a logarithmic scale
Personal anecdote: I've worked with 10x, 1x, 0x, -1x and -10x engineers, and everything in between.
> A manager went to the Master Programmer and showed him the requirements document for a new application. The manager asked the Master: "How long will it take to design this system if I assign five programmers to it?"
> "It will take one year," said the Master promptly.
> "But we need this system immediately or even sooner! How long will it take if I assign ten programmers to it?"
> The Master Programmer frowned. "In that case, it will take two years."
> "And what if I assign a hundred programmers to it?"
> The Master Programmer shrugged. "Then the design will never be completed," he said.
---
10x programmers are just as susceptible to Brooks’ Law as the regular programmer is.
I believe part of the 10x factor is the ability to hold a larger part of the problem space in one's mind. Having developers that overlap in that without a single vision (thus the importance of the surgical team approach), brings out the worst case of Brooks' law with more interaction needed to keep things in their scope.
If anything, this is just a general definition of an engineer.
I don't find it particularly effective at any of these. And let me join the chorus of folks saying; don't use Commodore 64 font. It's very inaccessible. Putting a button on the page to "fix" the problem you deliberately caused is a good indication you should't have done the thing the button fixes.
By contrast, we've all encountered good engineers who have brought down the efficiency of entire teams with their repulsiveness. This is particularly problematic if their technical ability doesn't exceed their costs to group efficiency.
P.S. I didn't find much issue with the font, and liked the ability to switch to a simpler style.
I think the only people who would call such an individual a "10x" are themselves....
Trim that thing down to maybe 4 or 5 things and we could perhaps call that a 1x baseline.
I'd say this is getting pretty close to a 4.5x /s
This was created 3 years ago as a response/meme to the stupid 10x engineer stuff some VC tweeted 3 years ago. It’s a crowd-sourced list and is literally just shitposting/being self-deprecating, while also pushing back on the ridiculous deification and mis-labeling of 10x engineers. That’s it. It isn’t that deep.
It’s a shitpost meme riffing on some stuff that got Twitter into a tizzy. Nothing more.
Disclosure: I made some contributions to the repo early on and am friends with the original creator of the site (and we worked together as 1x engineers at the time this was posted).
Most super good engineers which I always though of when I com across this term are good precisely because they do the whole list 2x better than normal people, not because they really are 10x faster. Especially the community part.. no one can be alone.
The whole idea of engineers as fungible resources with output that can be represented with a single digit is silly to begin with, and I fully support attacks on the concept, but this isn't attacking any of the fundamental problems. It's attaching "be agreeable, think long term, and don't overwork yourself or your team" to the bandwagon of "a 10x engineer is a silly idea." However, while those two aren't mutually exclusive, they're not the same thing. Calling yourself an anythingx engineer is giving tacit approval to the idea you can even measure output with a number, even if you do it ironically.
The truly best engineers have the experience to develop intuition around what core not to write, and have 10x impact but are not 10x better coders.
[1]: https://twitter.com/devblackops/status/1149883098567331840
[2]: https://twitter.com/devblackops/status/1150115483380621313
If you’re interacting with someone who is self-described as “10x”, you’re almost certainly talking to an asshole, and a lot of their time will be all about gorilla chest-thumping and establishing their 10x-ness.
Bug intended? :)
It's not that 10x engineers do 10x the work, it's that they do -different- work that produces 10x the value. We could also call them O(log n) engineers as opposed to O(n^2) engineers.
Let's define a 10x engineer as someone who ships and has a disproportionate amount of impact compared to its coworkers. I'd say most 10x engineers I've met had a real hard time detaching from work and spent most of their waking hours working. This is definitely not a life most people should follow, but I can understand it.
I've also seen 10x engineers who become so toxic that people around them end up leaving. Another example, which is depicted in The Phoenix Project, is the 10x engineer that hoards information and thus cannot be replaced or scaled. There's a lot of archetypes for 10x engineers, and not all of them are good for a team.
I get that the font is part of the joke, but it's unreadable to the point of being an accessibility issue. I have 20/20 eyesight with glasses, and had a mild headache by the time I got to the end. I like the idea, but feel that dialing it back sightly would be a worthwhile tradeoff :)
We are all average engineers in the end, there's always someone more productive, with more experience, with more dedication, with more energy ... somewhere in your organisation. As long as the organisation can keep a learning and collaborative environment and the assholes at the door, I welcome as many 10x engineers as they will fit the room. But then if all your peers are 10x engineers ... they become 1xs ?
I am interested in making development easier for my colleagues, just as I am interested in accessibility for the web.
You could build software that is more reliable, fast, and easier to maintain but they won’t let you. They want you to work on feature X. Once that is done they want feature Y. And it keeps going with never ending deadlines so that all the company is capable of is mediocrity.
I think I’d like working with these 1x engineers.
The worst 10x and 1x engineers I’ve worked with walk into a room and think, “everyone else is terrible at this, good thing I’m here.” They speak in absolutes and assume the worst from other people. They always seem frustrated and ready to vent. They’re often more opinionated than pragmatic. It can be a slog working with these folks.
JavaScript single page apps are my comfort zone, and I will not sleep until every single dev is here with me. I am not leaving. It's very comfy.
One thing I don't understand the point of juxtaposing it against a high-performer. No human is going to be good at all of these things at once regardless of their efficiency or ability. Even if you could churn out bug-free code at an unbelievable rate it would not matter if your soft skills suck.
Personally, I'd call this the "shepherd coder" (vs. the "cowboy coder").
* Searches Google, Duckduckgo, Bing, or wherever they like when they're not sure what's up.
* Copy/pastes code snippets from Stack Overflow, Glitch, Codepen, or wherever they find answers.
* Gives credit where credit is due.
* Creates community and shares knowledge.
* Spends time on things outside of engineering, like hobbies, friends, and family.
* Has a schedule that allows them to maintain a healthy work-life balance, and respects others' time-boundaries, too.
* Isn't measured by arbitrary contribution scores on any website, and doesn't judge others for theirs either.
* Writes code that &emdash; gasp &emdash; has bugs.
* Writes code that others can read.
* Reads the Docs.
* Updates the Docs.
* Doesn't need to be passionate about the code they write or the problems they solve, but may be.
* Doesn't act surprised when someone doesn’t know something.
* Is willing and able to collaborate with others.
* Willing to spend time and energy to help teammates get unstuck, when appropriate.
* Publicly celebrates others for their wins.
* Ask questions before providing critical feedback.
* Gives tough feedback privately.
* Treats others how they would like to be treated.
* Provides code reviews and feedback to their peers that are constructive, helpful, and presented tactfully, helping their peers to grow personally and professionally.
* Expresses appreciation for code reviews and feedback from their peers that are constructive and helpful.
* Sometimes feels hurt by critical feedback, but doesn't react destructively.
* Sometimes takes short breaks to clear their head.
* Makes mistakes from time to time, and finds growth in those mistakes.
* Willing to admit when they're wrong, and aren't afraid to say "I don't know."
* May or may not like writing documentation, but does it anyway for future maintainers.
* May or may not like writing tests, but tries to learn to do so if the team or project needs it.
* Thanks others for their time, effort, and energy.
* Can have colorful desktop backgrounds.
* Supports code in production, even if they did not write it.
* Can feel like an imposter at times, and understands others may, too.
* Believes that everyone in the room is equally as smart and capable as they are.
* Will help level-up others, and asks for help when they need it.
* Never stops learning, but can feel totally overwhelmed by the amount of learning there is to do.
* Tries to keep discussions productive and lets others have their say before the team makes a decision.
* Is willing to leave their comfort zone.
* Contributes to the community in their own way when possible, and appreciates the ways that others contribute when they can.
* Can be a slow coder.
* Has productive and unproductive days.
* Doesn't take themselves too seriously.
* Says, "I've never heard of that," in lieu of nodding and pretending.
* Is trustworthy.
* Works to live, rather than living to work.
* Sometimes loses their work.
* Doesn't have to have the entire codebase memorized.
* Respects and upholds community Codes of Conduct.
* May work from home, the office, a coffee shop, or where ever else best works for them.
* Doesn't hate on tools, processes, or languages that they'd rather not use, or that others are using.
* Is not defined by the computer they're using.
* May decorate their laptop and workspace in any way they like, and is respectful of others' decor (or lack thereof), too.
* Isn't defined by myopic Tweetstorms by clueless VCs.
* May have a lot of unfinished personal projects, or no personal projects at all.
* Doesn't riddicule entire professions within engineering, especially not when in a position of leadershi p.
I used to pay a lot of attention to who said what, but realised I was pre-judging comments based on what I'd seen people say earlier, and dismissing people's comments prematurely. So now I usually don't read the usernames because I find that tends to prevent me from judging a comment on its merits.
I didn't realise it was you that made that comment earlier ... sorry.
for me "1x" or average is just someone who does the minimum but tries to do it well and professionally.
not proactive or overly opinionated. basically the 9-5 man (or woman).
I'm not that technically brilliant, but I enjoy finding ways to make the efforts worthwhile and I feel that gives me already a small edge.
Hope that helps others struggling with reading the retro style font.
> Doesn't riddicule entire professions within engineering, especially not when in a position of leadership.
> Can have colorful desktop backgrounds.
What?
Most of these come down to "don't be an asshole".
I suppose it's worthwhile to remind people that a large part of engineering is dealing with people, and not being an asshole tends to be a force multiplier (or stated differently being an asshole gets people to actively sabotage your efforts).
It reads so much like the "casual" vs. "hardcore / tryhard" memes you'd find in gaming communities.
If I had a penny for every backend developer I've met who made fun of frontend develop, then I'd be well on my way to Musk-level money :(
Seriously though. Yes, many of these come down to "don't be an ass", but in different flavors, so I personally like the list :D
Writer's block is another part. Just thinking about the numerous ways to approach a problem and getting analysis paralysis, while the 10x just jumps into some experiment without a second thought.
10x is the ability to avoid getting blocked. Everything else on the list could very well be part of any programmer's set of attributes.
This is peak irony if it's not intended.
source: I committed it.
Couldn't hold my laugh on this one.