Embrace Your Developer Superpower Instead of Chasing the 10x Engineer Dream

Jan 11, 2024 by Craig Jellick
Embrace Your Developer Superpower Instead of Chasing the 10x Engineer Dream

In the world of software development, the elusive 10x engineer has long been a subject of discussion. This archetype often conjures an image of an individual capable of single-handedly conquering any software development challenge. Debates swirl around what defines such a paragon and whether their impact ultimately enhances or hinders their team. The truth is that 99.9% of the time, no one developer possesses every skill necessary for every task.

Instead of trying to fit into this elusive mold, I propose a different approach: identify and refine your developer superpower. What truly propels a team to greatness is a collection of developers each wielding their unique power to combine into an unstoppable force.

Throughout my career, I've witnessed many developer superpowers that have significantly elevated individual careers, team health, and customer satisfaction; it’s a win-win-win scenario. As a manager, discovering a developer's superpower and helping them leverage it for everyone’s benefit is immensely rewarding. It's essential to recognize that no single power dominates all. Instead, each is a specialized skill contributing to the collective success of a team. So, let's explore some of these superpowers and their impact.

Tenacity

Developers with this trait approach problems with the mindset of, "If it needs to be done, I'll figure it out." Their unwavering commitment to solving challenges, even when faced with frustration, sets them apart and is a boon for any team. I’ve seen engineers turn their willingness to figure out a difficult, potentially tedious niche into industry-recognized subject matter expertise. Not only did this immediately benefit our product and customers, but it opened up multiple career opportunities for them.

Reading Other People's Code

Simple put, the ability to navigate, comprehend, and stay up-to-date with codebases other than your own accelerates knowledge growth. This superpower provides insights into coding best practices, pitfalls to avoid, and innovative approaches to common tasks. With so much open-source code in the world, there’s just so much knowledge to pull from. The times I’ve heard “Well, here’s how <Project X> solves that,” and the time it’s saved has been huge. One great example in the cloud-native ecosystem is Kubernetes. Much of Acorn is built on top of or adjacent to the open-source libraries of Kubernetes. This couldn’t have been accomplished without an intimate knowledge of that sprawling codebase.

Highly Effective Code Reviews

I have a love/hate relationship with the code review process – it’s critical to maintaining high-quality code and effective teams, but it has the potential to bog down. I’m constantly looking for ways to optimize this. The consistent game-changer? Devs who are highly skilled in code reviews. To be great at this, you developers need to do a lot of things well.

First, they must be able to zoom in and out. Zooming out entails grasping the big picture and understanding the potential implications of a change on the entire system. Zooming in is the ability to scrutinize implementation details and identify potential bugs.

Second, they need to focus on what truly matters. They don’t let nitpicks like stylistic preferences or micro-optimizations slow the process down. Navigating this can be tough, as sometimes it makes sense to share, like when you’re mentoring a junior. But other times, like during a time crunch, these things should be completely let go.

Third, they need to hone communication and interpersonal skills. I've witnessed relationships sour due to perceived slights in the delivery or acceptance of code review comments. Striking the right balance between constructive criticism and maintaining positive relationships is key to leveraging this superpower effectively.

Live Debugging (with an Audience 😱)

This is one I wish I was better at and really admire when I see it in other folks. It’s hard to develop, but is incredibly valuable. The best devs I’ve seen at this have had knowledge of our stack from top to bottom. In my industry that means understanding, to some degree, Linux, networking, containerization, Kubernetes, and then a slew of software running on top of all that. You often just need to “know enough to be dangerous.” There’s usually some cross-disciplines at play too, like a backend dev with ops experience or a frontend dev with broad knowledge of AWS. It shouldn’t be surprising that tenacity and “reading other people’s code” are complementary, if not prerequisites for this.

There’s a second aspect to this superpower: working under pressure. As much as we work to minimize it, firefighting happens. Middle-of-the-night pages happen. Frustrated customers that need their problem fixed NOW happen. Staying cool under these high-pressure situations and being able to apply debugging skills is a power in its own right. I’ve found that the majority of devs (myself included) who are used to developing code in relative isolation can find these situations incredibly intimidating, especially if a customer or user is directly involved. What I tell myself and others is that you’re just dealing with another human being trying to solve their problem. Take a breath and trust in the skills of you and your team.

User Empathy and a Product Mindset

Developers often fall into the trap of a narrow focus on technical problems. It’s tricky because we need that narrow focus to actually solve the problem at hand, but that can be limiting in a lot of ways. At the end of the day, if you’re building something that will be used by other humans, put yourself in the user’s shoes and do it often.

This skill starts paying dividends when you start forming and sharing opinions from the perspective of your users. In my little niche of the dev and ops tools industry, this isn’t too big of a stretch because we’re building tools that we can at least conceive of using ourselves. However, this becomes even more valuable if you’re building something that’s out of your comfort zone. Before I got into the dev and ops tools space, I worked on an ecommerce SaaS. Most of us working on it really didn’t understand the user, but one teammate took it upon himself to build a shop for a product that scratched an itch in his personal life. He became a user and his insights were incredibly valuable. He ultimately left his software development career to run this side business full-time and it’s been quite successful. Opportunities come in weird places!

Traversing the Hacky-POC-to-Production-Grade Spectrum

Over time I’ve come to the conclusion that all developers naturally exist somewhere on this spectrum. On one end are devs who excel at quickly producing proof-of-concepts (POCs), navigating nebulous requirements and lots of unknowns. They’re good at sacrificing quality for speed of delivery. On the other end are devs that excel at meticulous attention to detail, delivering production-grade code with thorough consideration for edge cases.

Every position on this spectrum is valuable. The superpower in this area comes in a couple forms. The first is optimizing for the extremes. If someone is incredibly good at POCs, teams should optimize and leverage that and the same is true for the other side of the spectrum. The second and rarer way this manifests is being able to shift left or right on the spectrum. Know where you naturally land and recognize when you can and should shift to the left or right. It doesn't hurt to explicitly ask yourself or others “Do we want this quick and dirty or clean and thorough?” You may have to develop some new skills to effectively shift left or right, but that’s what makes this a rare ability.

Conclusion: Embrace Your Power

Instead of aspiring to be a 10x engineer, focus on recognizing and honing your unique developer superpower. By doing so, you contribute to a diverse team where each member's strengths complement others' weaknesses. So, identify your superpower, lean into it, and watch how it transforms your career and the success of your team.

Craig Jellick is a software architect and engineering manager at Acorn Labs. He has extensive experience building and supporting teams that build and support open source infrastructure and developer tools. You can follow him on Twitter or connect on LinkedIn.