Thursday, October 1, 2015

Notes on Startup Engineering Management for Young Bloods

(With apologies to my good friend Jeff Hodges this is a takeoff on Distributed Systems for Young Bloods).

I’ve been thinking about the lessons startup engineering managers learn on the job. A great deal of our instruction is by making mistakes, and as leaders, those mistakes often cost us real opportunities: people who don't join the company, people who quit, projects that don't ship, sometimes even our jobs. These scars are useful reminders, sure, but it’d be better to have more managers with the full count of their fingers.

Below is a list of some lessons I’ve learned as an startup engineering manager that are worth being told to a new manager. Some are subtle, and some are surprising, and this being human beings, some are inevitably controversial. This list is for the new head of engineering to guide their thinking about the job they are taking on. It’s not comprehensive, but it’s a good beginning.
The best characteristic of this list is that it focuses on social problems with little discussion of technical problems a manager may run into. The social stuff is usually the hardest part of any software developer’s job, and of course this goes triply for engineering managers.
I'm a distributed systems engineer by training, and I enjoy drawing lessons and making comparisons between the two worlds. I wrote this post with many indirect references to Jeff's original screed because I found it mapped quite well. It's long, and each entry is itself worthy of one or several posts, but I hope you will find it a valuable introduction.
OK, having copied Jeff's intro and lightly reworded it, let's dive in.
Managing people at startups is different because you have no safety net. You may think, having spent a few years at a big company in a management position, that you know how to manage already. You've given performance reviews, done interviews, dealt with project timelines, played politics. You know the basics. Right?
Here's what you don't see until you leave the safety of a big company. You don't see the millions of invisible systems all around you that have set you up for success. The army of recruiting personnel, the pipeline of aggregated talent, the power of a known brand. You don't have to figure out salary bands. You have standards, you have processes, you have rules, and you have people who make it relatively easy for you to live by those standards, processes, and rules. You have no idea what it is like not to have someone to check your work, to make sure that people get paid on time, that reviews happen, that holidays are tracked, that budgets get approved. You've never looked at an excel spreadsheet of numbers for year-end compensation only to find it full of errors that needed correcting.
Or maybe you've never been a manager at a big company. Your whole career has been spent in startups, and you have not only no management experience at all, but you've never experienced the safety net. You too are in for problems, but they will be much harder for you to detect, because you don't know what a smooth-running operation even looks like. You are comfortable making your own rules, but you may not appreciate the value of having a machine behind you. Instead of chafing at the chaos, you not only thrive in it, but create more of it. 
In both cases, creating the safety net yourself is part of the job, whether you realize it or not. Create sane processes, sane standards, and shared values, so that the team can scale without you having to make every decision yourself. If you find your team has doubled and you're still making roughly the same decisions you were before it doubled and you're just working twice as hard to get it all done, you are trying to paper over the safety net via effort. It doesn't work.
Coordination is very hard. "I hate agile!" Yeah, I get it. But when you are expected to know the progress of 10 very different projects off the top of your head, and teams across the company from each other cannot seem to get on the same page and you find yourself in meeting upon meeting upon meeting trying to align roadmaps and get some clarity as to what the hell is going on, you may feel that at least getting some shared vocabulary and process across the company is a valuable exercise. Many tactics and theories exist for how to solve this problem, but we must acknowledge that it is fundamentally difficult, and it is unlikely that you are going to solve it perfectly on your first try.
The amount of overhead that goes into managing coordination of people cannot be overstated. It's so great that the industry invented microservices because we'd rather invest engineering headcount and dollars into software orchestration than force disparate engineering teams to work together. And even that is an illusion when it comes to true cross-functional efforts. It turns out, there is a reason big companies end up with project managers who spend all day making sure people are talking to one another.
If the set of projects going on can fit into your head, your project list is probably trivial. I do not say this to malign your company, but there is a huge separation between the management style that you can afford when you know everything that is happening in detail, and the management style when you have to do some deep reading to even know what is going on in an area.
If the set of people is small enough that everyone knows everyone else, politics is trivial. You'll have it, sure, but it will almost always be very visible very quickly. Now is the time to get out in front of it. Politics at this scale is probably a sign of either organizational illness or a lack of cultural unity. If you can easily put a label on the type of people most often bearing the brunt of the politics (engineers, marketers, women, new grads, etc), it's probably a sign of organizational illness that you need to address unless you want it to fester and cause bigger problems as you go. Unless you can literally grow your business without that group represented, you don't want to create a culture that completely excludes an entire group. If, on the other hand, the people who bring politics share personality characteristics that are not strongly correlated with their gender/race/job/experience-level/etc, then you need to figure out what kind of culture your company actually is, and start screening for that in hiring. The sooner you realize what values your company truly holds, the easier avoiding these types of problems will be. If you do not figure out your company's values, as you grow, politics will become worse and worse.
“The team is moving too slow” is the hardest problem you’ll ever debug. When your CEO asks you why nothing is getting done, why we can't do everything on their laundry list, why the project they expected would launch next quarter is still two quarters out, accurately answering that question is incredibly difficult. Once you are a level or two removed from the actual people doing the work, your previous debugging process of "going to every meeting, watching the work being committed, understanding every detail of the project" does not scale. You have to figure this out from a distance. 
Implement trust and communication throughout your team. Your management team MUST trust you, and their developers MUST trust them. The basis of trust is doing what you say what you will do. At the most basic level, this is done by scheduling regular 1-1s and then showing up for them. If you don't have time to do this, think about whether you can handle having so many direct reports. You have to lead by example. Whatever you do to your direct reports will probably flow down the chain. If you disrespect their time, they will disrespect the time of their direct reports. In addition to 1-1s, find ways to be available to your whole team. I am a fan of office hours held weekly that anyone can sign up for. Spend time in the channels where the team hangs out. Show up for drinks and demos. Participate in hackweek. Enjoy this rare opportunity to build a team yourself by spending time with the team you built!
Metrics are not the only way to get your job done, but they can be useful. How often do releases happen? How often do people check in code? How many tickets are outstanding? How much time do people spend in meetings? How many people do you really need to hire this month? Here's the challenge: you're dealing with small data sets (lies, damn lies, and overfitting the data). Even if you have a year of github activity data, understanding WHY a person is coding infrequently requires an understanding of what is going on in that person's life. They may have just become a manager!
This also applies to goal-setting. If you miss your KPIs, what does that mean? Fundamentally, are you measuring the most important things? 
Learn to estimate your capacity, and your team's capacity. You should know how much you can realistically do in a week. If you constantly find yourself not finishing something you said you would, you are overestimating your capacity. When you aren't finishing important things, it is a sign that you need to either delegate or simply STOP DOING SOMETHING. That something you need to stop doing is often writing code. 
Lots of engineering leaders think that the way to maintain empathy for their team and to understand where problems lie is by continuing to write code. Here's the deal: if you have the time to do the full process of writing code (write code + tests, get review, release to QA, validate, release to prod, fix loose ends, document/hand-off/maintain), by all means, write code. It may be valuable to do this for one or two small things a year (protip: hackweek can be good for this). But as your team grows it is completely unrealistic that you are going to understand the pain of every engineer by walking a mile in their shoes. You may be able to do this for a service, but not the javascript, or the javascript, but not the app, or the app, but not the tooling. You must figure out how to get information about the bottlenecks and problems in the development process without actually having to do it all yourself. That is the job. It is not easy, and it is usually less fun than writing code. 
Here's a useful trick for estimating team capacity:
If we got some number of features done this year with our current engineering staff, we will need ~20% more engineers next year to get the same number of features done.
Technical debt and production support implies long-term cost for every new feature. You have to account for that. This is why big tech companies seem to grow massively every year.
Prepare for long feedback loops, and look for opportunities to shorten them. The feedback loop from "hired someone" to "figured out their total impact on the organization" is the duration of a person's time at a company. You will write strategies that may take years to implement. When you are coaching someone to improve in an area, that coaching will often take weeks or months to actually result in behavioral change. You are no longer in a red-green-refactor cycle. Anything you can do to build out quicker feedback loops into the company and your personal style will generally pay dividends. Beyond the common wisdom of not waiting for review cycles to give people both praise and areas for improvement, some things you can and should do:
  1. Get your teams in the habit of releasing code as frequently as is reasonably possible. That may not be "continuous", but it probably looks like more than once a week. If your team is unable to release code frequently (barring stupid shit like Apple store processes), it is a sign of potential bottlenecks.
  2. Postmortem time? Try to make sure it is held the day after the incident, when it is fresh in people's minds.
  3. Look for ways to prove out ideas early. This includes your architectural and strategic ideas. Work them organically into the product roadmap, to show value early.
Choose your structure (or lack thereof) wisely. You may not personally be creating technical debt much anymore, but that doesn't mean you aren't creating organizational debt. When you roll out a half-assed engineering ladder, this new structure may actually make your life harder, because now you're going to have to negotiate with engineers eager to debate the finer points of broad and vague language. Early on, structure doesn't matter much, but at some point you have to address it. Interested in going the Holacracy or other self-organizing route? I highly recommend reading Reinventing Organizations. Because guess what? They also require some thought and process to work! Be prepared to be thoughtful about this and put some time into it.

The worst situation is having random titles, random pay, random equity. I have stopped counting the number of people who have told me that they discovered massive unfairness in the salaries and equity paid to members of their team. It happens easily. You pay early employees less, assuming you'll give them more valuable equity, but that does not always happen. As the company gets bigger and the market rates change, you hire new people in at higher salaries, but never adjust older people. Cleaning this up probably requires setting up a structure for levels, pay ranges for those levels, and actually increasing the salaries of many people to bring them up to level. 

You'll probably get this a little bit wrong the first time, but in an effort to make your life slightly easier, if you decide you want to do an engineering ladder feel free to use the Rent the Runway Ladder that we shared as a starting point

People can do more than they think they can. This goes for you, and for your entire team. I can't tell you about the failure patterns of people who overwork their teams because that's not my personal failure pattern (yet). But I do sometimes fail to push people hard enough. Engineers want to ship. This goes double for startup engineers. If they are not shipping much, they will start to complain of boredom, and go looking for ways to make trouble. This may result in you having overengineered systems in prod, engineers who quit to go to a new shiny company, or worst, engineers who first push overengineered systems halfway to prod then quit to go to a new shiny company.

I know my boundaries and rarely respond well to people trying to push me to do things. I push myself hard enough. This is true for some engineers, but not all. When you are not pushing them to get something done, you may be trying to give them space, and they may consciously appreciate that while unconsciously start to think that their work doesn't matter that much. If it mattered, my boss would be pushing me!
So, if you have an engineer complaining of boredom, ask them to finish what they're doing faster. I once heard this on the topic of infrastructure engineering: "If you're bored, try doing it all 20% cheaper". Engineers will often identify interesting hard problems when they try to do things faster. Such as: it's hard for me to run tests because they're too slow, getting to prod takes a long time, the build is always broken, this downstream system is not responsive. You were saying you're bored?
People will quit. As sure as the sun rises, as sure as networks occasionally partition, people will quit. They will quit because you are a bad boss. The will quit despite you being their best boss ever. They will quit to move across the country. They will quit because they don't see the future with your company. They will quit because they got another offer they can't turn down. They will quit because it is time for them to move on.
You cannot control all the reasons that people quit, but it will feel like a punch in the gut every time it happens. Your job is to keep going. To put on a smile and go out and recruit. To rally the team. To celebrate that person even as you are seething inside, how dare they leave me right now! Try to identify common causes for people quitting your organization, and address them as best you can. Especially if those causes relate to the environment that you help create (harassing, aggressive, burnout, underpaying, favoritism, politics). If you can in good conscience look at your environment and believe that it is in pretty good shape, then be kind to yourself. 
One of my greatest accomplishments was this: I told my team over the years that if they were seriously looking to move on, to tell me and let me help them find a new job. This finally happened for the first time this year and it felt like a massive win. If you care about your team, helping them move on when they want to move on is a great honor.

Jeff didn't manage to find a concluding paragraph. It's hard to put a conclusion on what is ultimately a brain dump. But here is mine:

Your job is to survive. Put one foot in front of the next. Keep going. Be open-minded. Be curious. Read about what other people are doing. Make friends who are running tech at other companies. Be kind to yourself, even if you fail. You have the power to make the world better for all of those people on your team. Use it responsibly.

Wednesday, July 29, 2015

Have a Theory

There is a phrase I find myself employing pretty frequently at work, when discussing new features or products. While I am not a product manager, I am responsible for making sure that we implement features well, and thinking strategically about what we are spending our precious time implementing. So, when I am asked about my thoughts on a new product or feature, I usually have one and only one question:

"What is your theory?"

In this day and age we sometimes get lazy about thoughtfulness, and rely on data and experimentation to hill-climb our way through the world around us. Or at least we say that we rely on data and experimentation to drive our features. But the reality is that we're working in such complex multivariate environments that we cannot possibly test all permutations of even the simplest change. We do make choices about what features we build, and these choices are not entirely data-driven.

So, given that our choices cannot be entirely perfectly data-driven, how then do we decide what to build? The only way that we can make sane choices in a complex world is by actually being thoughtful about the choices we are making, creating a theory, and creating experiments that actually test that theory.

For example, in my current world of e-commerce, we often are faced with the mandate to implement a new feature that will make the customer feel better about the product in some nebulous way (it's cooler! it's more high fashion! millennials will love it! whatever). This feature, while it might not cause customers to immediately buy more up front, should cause them to be more loyal over time. Sometimes, this is the right instinct. But beware: if you're going to try to get second or third order effects from a feature, you'd better have a really solid theory of the chain of events that leads to those second or third order impacts. And you need to figure out what you can measure to validate the chain of events. Don't just look at the number of people buying the product and hope it goes up. What does making the look and feel "cooler" DO for your customer? Do they visit more often? Spend more time? Tell more friends? Have a theory!

Failing to have a theory, and a solid experimentation plan for proving that theory, leaves you open to all kinds of irrational outcomes. The worst of these is the "you just didn't implement it well enough" outcome. The original idea was good, but you implemented it poorly, and that's why it failed. And that could very well be true! But it's impossible to prove or disprove without anticipating the question ahead of time, thinking through the logical conclusions of the theory, and setting up a good test to understand its outcome.

So the next time you are building a feature, ask yourself: Do we have a theory? What is it? Are we measuring the immediate expected effects of the theory, or are we just measuring the same stuff we always measure and hoping that it changes?

Tuesday, July 21, 2015

Ask the CTO: Going Rogue

I often get asked one-off questions about engineering leadership and management, and thought it would be fun to share my answers here. Asker's question has been anonymized and generalized.

The challenge:
I have an employee that was supposed to be adding a needed feature to one of our core systems. A few days ago I notice in GitHub that he has created a new repo and been working solely in that repo for the past two weeks. Instead of adding a feature to the new system, he is completely rewriting it! Furthermore, the repo is in a new language that no one in the team uses and that we have never put into production. I feel bad, I should have noticed this before it got this far, but I never expected someone we consider to be a senior engineer to go off and do this without at least checking in. How should I address this?

My thoughts:

Oof. This has happened to most of us at least once, in some fashion. Engineers want to be able to use what they think is the right tool for the job, even when the right tool is brand-new to the company. And generally speaking, this should be OK! The last thing you want to do is stifle people's initiative to create solid solutions and learn new things.

That being said, there is a high overhead to adding new things to your stack, and at some point, it usually makes sense to have some policy around how to add new things. I whipped together such a policy for my team about a year ago, when we had reached around 40 on the team and there were some folks discussing creating a new service in a language that we had very limited experience with. Our policy looks something like this:

Before any new language/framework is chosen for a production system, the following needs to be in place and approved by Camille and an architecture review board (group of senior engineers who are knowledgable in the area of change and would be impacted by it)
  1. the engineers advocating for the language/framework will present a case as to the benefits it will provide over existing choices
  2. there is a plan for what sorts of systems this language/framework should be used to implement, and what existing systems could be rewritten in it
  3. a style guide and templates for readability, testing, continuous integration, monitoring, logging, deployment and production standards will have been created
  4. at least four engineers on the team must sign up on learning how to write readable, production quality code and support the new systems in production
This must be done before the start of any project for engineering to commit to supporting the resultant code.
 This is a bit of a heavyweight list, but it articulates some of the challenges with bringing new languages and frameworks into teams. If you are in a team that wants to be conservative with new languages, frameworks and tools, clearly articulating the process for adding new things is an important element to avoid unexpected surprises on both sides of the equation.

So, you can put such a policy in place and point to it in the future to try and prevent such things from happening, but it has happened now, and there is an argument to be made that part of being a senior engineer is knowing when to communicate scope changes such as the need to move to new languages or frameworks. Even if you don't agree with my conservative approach to adding new things, you probably appreciate it when you get a heads-up on important changes early in the process.

The conversation you have now should involve first understanding their perspective: Why the new language? Why didn't they grab you earlier to tell you about it? What you learn from their perspective might surprise you. Perhaps you skip all of their 1-1s and they think you are unapproachable. Perhaps they are frustrated with the way you make decisions. Perhaps they knew you would be mad and were simply afraid to show you new work early when you would shoot it down.

Once you have gotten their perspective (and perhaps some takeaways for you), now it is time to clarify your perspective and expectations of them. As a senior engineer, you need them to push information to you. You expect them to communicate the scope of changes and approximate timelines, and let you know when these things change. They need to think about their peers, and have empathy for the needs of the team as well as their own interests; all too often teams will reject projects they weren't aware of and didn't have any say in. Socializing change not only to your manager but to your team is part of the role of the senior engineer.

So, to sum it up:

If you care about having a somewhat conservative process for new languages/frameworks, clarify what that process is and share it with your team

When someone ignores the process or otherwise surprises you, first ask why and try to understand their perspective

Finally, clarify your expectations to them, helping them understand the impact that their actions have on others and the importance of communcation

Sunday, June 28, 2015

Vision and Trust: External and Internal Leadership

Fred Wilson recently wrote a post where he defined leadership as this:
It is charisma, it is strength, it is communication, it is vision, it is listening, it is being there, it is calm, it is connecting, it is trust, faith, and belief
Trust, faith, and belief. These are all words for the same thing, right? Well, not exactly.

I have observed that many leaders, especially the ones called visionary, are often evaluated in the court of public opinion on the following subset of those qualities:

Charisma, strength, communication, vision, connecting, faith, and belief

Listen to them talk to a crowd and they will blow you away with the clarity and strength of their vision, with their ability to connect with their customer. This in turn translates to a level of faith in that vision and belief in the overall direction that they are guiding their company towards. Awesome. Literally, awe-inspiring to witness. These are the public qualities of leadership that show up in the media, that the whole company can see in an all-hands, that you can see firsthand when they speak at a conference. These are the qualities that the board members see, that the venture capitalists invest in, and it is pretty hard to get into the position of successful startup founder without them.

So where do the rest come in? Listening, being there, calm, trust. These qualities are more difficult to evaluate based on an interview or a presentation, these are the “internal” signs of leadership.

Trust is a contract between two people. You are constantly creating and building trust in a long-term relationship with everyone around you. When you listen, and are there for people, and are calm when interacting with them, you build trust. But without that listening, without “being there” in a way that lets people feel the ground beneath their feet, without calm, trust is fragile or non-existent. Trust is regularly tested and negotiated based on our ability to show up. I would say that these more private qualities, these relationship qualities, are the qualities of management that every great leader must possess. Managers know the value of steadiness, of showing up for that 1-1 every week, of reacting slowly and listening to the people around them.

So even great external-facing leaders need some management skills. What about the managers?

Managers fail when they lack communication, connecting, and strength. A manager who can’t communicate with their team cannot execute effectively. A great manager connects with their employees as human beings (without turning into full-time therapist), and has the strength to shoulder the challenges of making hard calls in the trenches with their teams, the firings, the resignations, the projects being cut and the delivery or missing of deadlines. The day-to-day pains are very real for the manager and without strength it is almost impossible to do the job well.

But what about vision? We think that vision is the realm of the strategist, but vision also has a place in the manager's skill set. Instead of business strategy or architectural future, the manager’s vision sees what their organization looks like in 2 years, what their team can grow to be capable of accomplishing, what the successful day to day looks and feels like for the employees on their team.

As a final data point, my former CTO coach and one of his partners wrote about the Management/Leadership split in their new version of The Art Of Scalability, excerpted here. Between these three sentiments, perhaps you can triangulate your own path to being a great leader who manages enough, a great manager who leads enough, or whatever the situation calls for.

Tuesday, June 2, 2015

The Trials and Temptations of the New Leader: "Cool Factor"

Being a new leader at a startup is hard for many reasons. You think you're good at a lot of things, only to discover that you're not. You were fooled by success gained inside of a company with hidden structures that helped you succeed, the invisible backpack of big(ger) company privilege.

One very common area of weakness is recruiting. When I started to lead engineering at Rent the Runway I fancied myself pretty good at recruiting. After all I had done it well in prior gigs, I was friendly and engaging in interviews, so I'd be fine! Of course I quickly realized that startup recruiting is enormously different than at a company with a whole recruiting department sourcing candidates, making sure the process goes relatively smoothly, and of course, paying them fat industry++ salaries. Outside of this structure you experience a world where you reach out to so many people and get nothing but silence, blank stares, or polite dismissals. Your CEO tells you that you've gotta sell, and asks for your sales pitch. And often, faced with a string of failures and pressure to grow, you land on the need to do something "cool" with technology to up your "cool factor."

You know what I mean. Chase the buzzwords: microservices, Go, big data, event-driven, reactive, functional, etc etc etc. The only way engineers will want to come work for me on my relatively straight-forward application development is if I give them the carrot of Cool New Technology!

I have learned a few things over the years, and one of those things is that usually engineers that are only interested in Cool New Technology are not going to stick with your Boring Business Problem for long enough to be worthwhile, or worse, they'll stick with it long enough to leave a trail of one-off solutions that no one else on the team understands before they walk away and leave you holding the bag.

If you're tempted to reach for Cool Tech, then I'm going to guess that you're not at a company where the primary challenge is purely technical or scaling. Instead, the interesting problem that your company is solving is almost certainly a combination of a) figuring out how your business, possibly the first of its kind, is going to survive, and b) growing, changing, and evolving to create a functioning organization. Once your company is successful, many of the problems that seemed trivial become surprisingly challenging to solve at scale, but in the early days oversolving with cool tech only leads to distraction from tackling the real challenges.

So resist the urge to adopt any technology for the cool factor of recruiting. Instead, look for people who want to own big parts of the system, who are interested in the business, who are really passionate about the customers you're serving, who are looking for leadership opportunities. Don't undersell the opportunity you have just because it isn't Cool New Technology. Be honest with yourself about the real problems that make you excited about the business that you're in, and that's where you'll find your best sales pitch.

Thursday, May 21, 2015

Entrepreneurial Gap

I recently came across a blog post that mentioned an intriguing concept, the "entrepreneurial gap." The idea is straightforward: give people more accountability than they have the direct resources to accomplish.

In many organizations employees are generally held accountable only for things fully within their control. So while the CEO has both all the resources of the company and the ability to make decisions that cause major tradeoffs (sacrificing profit for growth, for example), a manager of a team is only given projects big enough for that team to accomplish and goals big enough for that team to meet.

The entrepreneurial gap comes in when you give people bigger accountability than they have the direct ability to execute against. This is in many ways the classic startup move. You hire people and give them enough freedom to accomplish whatever they can manage to accomplish. Because early startup employees tend to be very entrepreneurial they often find a way to do just that, to gather support from other people in the organization and align efforts to produce outsized results. I think this is an important element of a growth business, something that inspires great people to work for a company, and produces a really fun culture to work in.

But, there's a trap.

The entrepreneurial gap works incredibly well when you give teams aligned goals. If you read the first case studies in the paper, you will see that in all of the examples the CEOs focused the company on a few goals, and in fact in all three examples there was a very strong emphasis on the customer. In companies where everyone is working ultimately towards the same goals, the entrepreneurial gap is awesome because it encourages people to work together and identify opportunities and efficiencies, especially cross-functionally, that may otherwise be lost.

Unfortunately, it is just as common to see companies put in place both an entrepreneurial gap and too many or misaligned goals. When you are in direct competition with your peers for scarce resources and you are not going to be graded on the same outcomes, the entrepreneurial gap produces a toxic environment of politics and power plays. Perhaps the best idea sometimes wins in these situations, but more often the best political players rule the day.

So what do we take away from this?

Organizational alignment is important because it lets you successfully ask more from people than the resources they have at hand. Without organizational alignment, you get political maneuvering. Without stretching people beyond their direct control, you get a lack of collaboration and creative cross-functional engagement. Set the right priorities and give people the freedom to stretch to them, and you will see the full potential of your organization come to life.

(The paper again: The Entrepreneurial Gap: How Managers Adjust Span of Accountability and Span of Control to Implement Business Strategy)

Saturday, March 21, 2015

Get Curious

The best advice I’ve gotten in recent years is simple. Get Curious. For those of you who don’t know me personally, I can be rather aggressive, especially with things I don’t trust. Whether by virtue of personality or experience, my instincts always lead me to attack and take apart the unknown. This is in some ways a good trait in an engineer, after all, the unknown is what causes you to get paged at 2am. Unfortunately, when it comes to interpersonal interactions, aggressively looking for flaws in things you don’t understand looks less like smart defensive behavior and more like obnoxious trolling.

So how can one honor the need for clarity without attacking and picking apart things in a way that causes others to get defensive? The tactic I’m using is “Get curious.” Instead of assuming that the other party hasn’t thought of your objections, try to understand deeply the context in which they are making their statements. Why do they seem to want to do something that may sound illogical to me? What is their perspective on the circumstances? What have they tried to do already?

A few years ago I wrote about “Yes, and...” I won’t lie; I still struggle to this day with “yes, and”. For me, “get curious” is a bigger picture version of "yes, and," one that I find easier to keep in mind. If you’re always curious and looking for the context, you’re open to the possibilities that are out there. The possibility that you’re missing something important. And that openness makes people want to work with you.

“Get curious” could be the mantra for the learning organization. Curiosity in the face of failure, instead of blame, leads to a safe environment for people to fail, and lets us discuss our failures. Curiosity leaves us open to new ideas. Curiosity enables us to recognize our differences and embrace them to create a stronger whole.

So for those of you who are quick to blame and judge and want to get out of this habit, get curious. For those of you who feel like your team is afraid to take chances and fail, get curious. Even for those of you who are afraid that you’re being too nice and are not challenging your team or colleagues enough, instead of getting mean or aggressive, get more curious. You’ll be surprised at how much more effectively you can create change when you approach situations with open curiosity.