From Stars to Team
Before I became an engineering manganager and when I was just reading software engineering books, I believed the surest path to success was hiring as many top-tier engineers as possible. My logic was simple: great software design comes from great engineers. A colleague once told me, "Hire stars—they'll build game-changing features!" And often, they did. These engineers introduced powerful designs, elegant abstractions, and impressive capabilities that elevated our products.
But over time, I saw the limits of that approach. Debates dragged on. Unpopular tasks went unowned. Engineers left because they felt underutilized. After reflecting on what I saw in my own teams—and what I learned from others—I realized:
Focusing solely on individual brilliance—even when it delivers great features—often sacrifices teamwork, consistency, and long-term growth.
The real magic happens when the team works as a cohesive unit. The goal isn't to collect stars—it's to build a constellation.
When building teams—whether in sports or software—the instinct is to stack the roster with as much talent as possible. More senior engineers, more superstars, more wins, right? Not always. Research and real-world experience suggest a more nuanced truth: too much talent can actually hinder performance. Even when individual engineers introduce brilliant features, the lack of balance and collaboration can slow the team down. Here's why—and how to build a team that thrives.
The Research: Talent Has Diminishing Returns
A 2014 study by Swaab, Schaerer, Anicich, and Ronay analyzed highly interdependent team sports like soccer and basketball. They found that adding talent improves performance—up to a point. Beyond that, performance suffers. Too many stars can lead to coordination breakdowns, ego clashes, and poor collective results.
This challenges the assumption that talent and output scale linearly. In interdependent teams—like most software engineering groups—excessive star power can actually disrupt the very collaboration needed to succeed.
Key takeaway: Talent drives performance, but only if it doesn't undermine teamwork.
Why This Matters for Software Teams
Software engineering is a team sport. Engineers must align on architecture, review each other's work, and ship features together. A team made up solely of senior engineers or high-performers can run into serious problems:
- Decision Gridlock: Strong opinions may clash over tech choices or system design, delaying progress.
- Neglected Execution: Critical but unglamorous tasks—like CI/CD setup, writing documentation, or fixing edge-case bugs—may get ignored.
- Leadership Friction: Too many leaders without clear roles often compete instead of collaborate.
- Blocked Growth: Without mid-level or junior engineers, there's no natural path for mentorship or long-term team development.
Even when talented engineers ship great features, a lack of cohesion or clarity in roles can erode team efficiency and morale.
Real-World Examples: Talent Alone Isn't Enough
Google's Early Struggles
In the early 2010s, Google's engineering teams were packed with elite talent. Yet, some teams struggled to ship:
- Endless architecture debates delayed progress.
- Glue work like documentation and infrastructure lagged behind.
- Junior engineers felt sidelined, which hurt morale and retention.
Google eventually recognized that technical brilliance wasn't enough. They began emphasizing soft skills—collaboration, humility, team orientation—in hiring and promotions. They also formalized the role of the Tech Lead to create alignment and speed up decisions.
Node.js and Open Source Governance
Node.js, in its early days, suffered from too many strong voices pushing in different directions. Conflicts and lack of governance stalled progress. The project rebounded only after implementing clearer roles and decision-making processes. This empowered contributors at all levels and helped the project scale.
These examples show that raw talent is not a silver bullet. Without structure and shared purpose, even the best engineers can struggle to work effectively together.
The Role of Tech Leads in Balancing Talent
A well-balanced team still needs guidance. That's where Tech Leads come in. The Tech Lead isn't the smartest person in the room—they're the one who keeps the room aligned.
Before I became a team lead, I didn't fully understand this role. In my past companies, the Tech Lead was treated as the boss—someone who went to meetings, made decisions alone, and became disconnected from the team. Often, these leads lacked strong software instincts and sometimes introduced friction with senior engineers. This was far from the kind of leadership that fosters a healthy engineering culture.
Now I realize:
A Tech Lead is not a boss. A good Tech Lead is a coordinator and a listener.
The role is about creating alignment—not control. It's about ensuring that everyone contributes, conflicts are resolved constructively, and decisions move forward without dragging the team down.
An effective Tech Lead:
- Guides Without Dominating: They set direction while making space for team input.
- Resolves Conflict: They facilitate decisions so the team doesn't stall.
- Leverages All Levels: They ensure seniors mentor, mid-levels execute, and juniors grow.
- Focuses on Outcomes: They prioritize what's best for the product—not their own technical legacy.
Spotify's Squad Leads operate in this mold, helping cross-functional teams stay aligned while maintaining speed and cohesion.
Without a Tech Lead—or with one driven by ego—teams of superstars often descend into dysfunction.
How to Build a Balanced Team: Practical Tips
If talent alone isn't the answer, what is? Here are some actionable ways to build a high-performing team:
- Hire T-Shaped Engineers: Seek people with deep expertise in one area, but enough breadth to collaborate across functions.
- Assess Gaps Before Hiring: Need innovation? Hire a senior designer or architect. Need delivery? Mid-levels are crucial. Need culture? Add a mentor.
- Prioritize Soft Skills: Interview for humility, communication, and collaboration—not just algorithms and system design.
- Foster Mentorship: Pair seniors with juniors. This builds culture and spreads knowledge.
- Empower a Tech Lead: Choose someone who values team success over individual heroics. Support their growth with training in facilitation and leadership.
A Fun Metaphor: The LeBron James Problem
You might call this the LeBron James Problem:
- You'll wait forever trying to hire three LeBron Jameses—they're rare and expensive.
- Even if you succeed, they may clash instead of cooperate.
Software teams aren't basketball fantasy drafts. Obsessing over rockstar hires wastes time and breeds dysfunction. A team of role players with clear leadership often outperforms a group of misaligned all-stars.
Final Thoughts: Build a Constellation, Not a Cluster of Stars
Talent absolutely matters. Superstar engineers can introduce groundbreaking features. But once you reach a certain threshold, adding more talent without balancing the team dynamic can backfire.
To build a truly great team:
- Seek balance: Mix senior, mid-level, and junior engineers.
- Prioritize teamwork: Hire for compatibility as well as capability.
- Support leadership: Use Tech Leads to align the team and resolve friction.
- Value the whole: Celebrate team outcomes over individual accomplishments.
Don't build a cluster of lone stars. Build a constellation—where everyone shines together.
Top comments (0)