Leading By Example
How often do you find yourself telling your team what to do, instead of showing them? It’s a common struggle for engineering managers – we’re often hired for our strategic vision, but fall into the trap of directing without demonstrating. After 20+ years in this field, I've found the most potent form of leading by example isn't grand gestures, but a consistent practice I call “Do, Then Delegate.”
This isn’t about being a coding hero or single-handedly fixing production issues (though occasionally that’s necessary!). It’s about deliberately demonstrating the behaviors you want to see in your team, especially when it means getting your hands dirty. It’s surprisingly powerful, and often overlooked.
The Problem with "Just Telling"
We, as engineering leaders, are often hired for our technical and leadership skills. We’re expected to envision solutions, articulate strategy, and drive execution. But it’s easy to fall into the trap of only articulating. We issue tasks, review pull requests, and monitor progress…from a distance.
This creates a subtle but damaging disconnect. Your team hears your expectations, but they don't see them embodied. This can breed resentment, lower motivation, and ultimately, slower progress. Consider a scenario I encountered at a startup: I tasked a junior engineer with refactoring a particularly messy module. I provided guidance, but spent most of my time in meetings. The engineer struggled, the code quality suffered, and frustration mounted. I realized I hadn't shown him what "clean code" looked like in our codebase. I spent an afternoon pair-programming with him, refactoring a smaller, similar module with him, demonstrating best practices and thought processes. The turnaround was remarkable.
“Do, Then Delegate”: A Practical Framework
“Do, Then Delegate” isn't a rigid process, but a mindset shift. Here’s how it breaks down:
- Identify Critical Behaviors: What behaviors do you want to amplify within your team? This could be anything from writing thorough commit messages and comprehensive tests, to proactively seeking feedback, or embracing a “fail fast” mentality.
- Model the Behavior First: Before assigning a task requiring that behavior, demonstrate it yourself. If you want better test coverage, write a particularly robust test suite for a small feature. If you want more proactive communication, over-communicate on a small issue.
- Explain Your Reasoning: Don't just do it; explain why. Walk the team through your thought process. “I’m writing these tests this way because it helps us catch edge cases early and reduces future bugs.” Transparency builds trust and understanding.
- Delegate with Support: Now, delegate a similar task. Offer guidance, but let them own it. Encourage questions and provide constructive feedback.
- Reinforce and Repeat: Consistently model and reinforce the desired behaviors. It's not a one-time fix; it's an ongoing practice.
| Desired Behavior | "Do, Then Delegate" Action | Potential Challenges |
|---|---|---|
| Thorough Code Reviews | Personally conduct a detailed, constructive review of a pull request, explaining your reasoning. | Team member may perceive review as overly critical if not delivered with empathy. |
| Proactive Problem Solving | Identify a small potential issue before it becomes a problem and publicly document your approach to resolving it. | Team member may feel undermined if the issue was already known to them. |
| Effective Communication | Over-communicate on a minor update, even if it feels excessive, to model transparency. | Team member may become desensitized to frequent updates. |
Why it Works: Beyond Just “Setting an Example”
“Do, Then Delegate” is more effective than simple "setting an example" because it addresses a core human need: credibility. It’s easy to tell someone to do something. It's much harder to be perceived as authentic and competent enough to lead them.
As Peter Thiel points out in Zero to One, successful people “find value in unexpected places” and think from first principles. When you demonstrate a behavior with action, you’re showing your team not just what to do, but why it matters. You’re embodying the values you espouse, and illustrating a commitment to the underlying principles that drive successful engineering. This isn't just about doing the work; it's about thinking about the work in a way that sets a strong example.
This approach also subtly challenges the “methodology” trap – the endless pursuit of process without substance. Getting your hands dirty breaks down the abstraction and focuses on tangible outcomes. By actively contributing, you demonstrate that you're not just dictating how things should be done, but are willing to roll up your sleeves and contribute to the actual work.
The Hard Truth: It Takes Effort
This isn’t the easiest path. It requires you to carve out time for hands-on work, even when time is tight. I recall a situation where a high-performing engineer was stuck on a complex bug. I once worked with a highly skilled engineer who was stuck on a complex bug – the easy answer was to assign it to another engineer. Instead, I spent a few hours pair-programming with him, digging into the issue. It delayed my other tasks, but it unlocked his ability to solve the problem independently.
It’s easy to fall into the trap of thinking you don’t have time for this, but the payoff – a more engaged, empowered, and skilled team – is worth the investment.
Addressing Potential Resistance
Be mindful that some team members might initially resist this approach. They may perceive it as micromanaging or a lack of trust. To mitigate this, be transparent about your intentions. Explain that your goal isn't to take over, but to model best practices and provide support. Encourage open communication and actively solicit feedback.
In conclusion: Leading by example isn't about being a superhero. It’s about consistently demonstrating the behaviors you want to see in your team, starting with deliberate action. “Do, Then Delegate” is a powerful framework that builds credibility, fosters growth, and ultimately, drives better results.
This week, identify one critical behavior you want to amplify on your team. Then, demonstrate it yourself before delegating a related task. It’s a quiet, consistent practice that can transform your team and solidify your leadership.