Vox

Leitura de 19 min

5 Stages Of Relationships With Mistakes

Summary

In this episode of Developer Tea, host Jonathan Cottrell introduces a five-stage framework for understanding and improving one’s relationship with mistakes. He emphasizes that mistakes are inevitable and that our approach to them significantly impacts learning, team culture, and innovation.

The first stage, willful ignorance, involves consciously ignoring mistakes without investigation or prioritization. This unhealthy approach relies on chance rather than intentional management. The second stage treats mistakes as anomalies, leading to poor planning and stressful, reactive responses when errors occur, which can compound problems and create fear within teams.

Stage three represents a cultural shift to anticipating mistakes, making space for them, and normalizing their occurrence without blaming individuals. Stage four involves responding adaptively to mistakes through postmortems, testing, and targeted improvements. The final stage, stage five, proactively engineers mistakes into processes through techniques like chaos engineering and premortems to stress-test systems and prepare for potential failures.

Cottrell encourages listeners to identify their current position on this continuum and consider how they might progress toward healthier relationships with mistakes, emphasizing that the goal isn’t to eliminate errors but to leverage them for growth and improvement.

Recommendations

Tools

  • Imgix — An image optimization service with a simple API that helps developers deliver fast sites through automated image optimization, used by companies like Unsplash, Kickstarter, and Prismic.

Topic Timeline

  • 00:00:00 — Introduction to relationships with mistakes — Jonathan Cottrell introduces the episode’s focus on examining personal and team relationships with mistakes. He explains that while acceptance of mistakes is commonly discussed, this episode will go further by providing a five-stage scale to help listeners locate themselves and understand the full spectrum of possible approaches to handling errors.
  • 00:03:32 — Stage one: Willful ignorance of mistakes — Cottrell describes the least healthy relationship with mistakes: willful ignorance. This involves consciously ignoring mistakes without investigation or prioritization, often shipping known bugs to production. He notes this approach relies on chance rather than intentional management and represents sticking one’s head in the sand rather than dealing with issues deliberately.
  • 00:07:09 — Stage two: Treating mistakes as anomalies — The second stage involves treating mistakes as exceptions rather than normal occurrences. This leads to failure to plan for errors, pushing teams to their limits, and creating stressful, reactive responses when mistakes happen. Cottrell explains this approach compounds problems, fosters fear, and prevents the psychological safety needed for innovation and growth.
  • 00:12:33 — Stage three: Anticipating mistakes — Stage three represents a cultural shift to anticipating mistakes and making space for them. This involves planning for errors, building in overhead time, and recognizing that mistakes happen to even the best engineers. Cottrell emphasizes this stage normalizes mistakes without blaming individuals but notes it doesn’t yet leverage mistakes for improvement.
  • 00:14:58 — Stage four: Responsive adaptation to mistakes — The fourth stage involves responsive adaptation to mistakes through postmortems, testing based on failures, and targeted improvements. Cottrell describes this as a healthy relationship where organizations handle mistakes effectively and improve their processes. He notes many good engineering organizations operate at this responsive stage.
  • 00:16:02 — Stage five: Engineering mistakes into process — The final stage proactively engineers mistakes into processes through techniques like chaos engineering, premortems, and offensive strategies to stress-test systems. Cottrell explains this involves predicting future mistakes, simulating failures in controlled environments, and preparing for potential problems before they occur in high-stakes situations.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2020-09-02T09:00:19Z
  • Duration: 00:20:25

References

Podcast Info

Transcript

[00:00:00] What is your relationship with mistakes?

[00:00:08] What is your team’s relationship or your company’s relationship with mistakes?

[00:00:15] In today’s episode, if you haven’t thought about this before, you’ll get a chance to

[00:00:20] think about it and to locate yourself on a scale that I’m going to provide of what your

[00:00:26] relationship looks like with mistakes.

[00:00:29] My name is Jonathan Cottrell and you’re listening to Developer Tea and my goal on this show

[00:00:32] is to help driven developers like you find clarity, perspective and purpose in your career.

[00:00:40] So here’s the thing about mistakes.

[00:00:44] It is in vogue and it is certainly popular to accept that mistakes are going to happen.

[00:00:53] So I don’t want you to check out too quickly because you’ve kind of jumped on that bandwagon.

[00:00:58] This is something that has been discussed a lot in podcasts like this.

[00:01:04] It certainly has been discussed in plenty of books.

[00:01:07] We talk a lot about the importance of psychological safety.

[00:01:12] In today’s episode, we’re going to take it another step further and not just talk about

[00:01:18] acceptance of mistakes.

[00:01:20] There’s more to this discussion and there’s more to how we should behave or how we can

[00:01:25] behave to deal with mistakes better, to have a better relationship with them.

[00:01:32] So hopefully you’ll stick around as we go through this scale and there’s five categories,

[00:01:39] five points on this scale that you can find yourself on.

[00:01:44] Almost certainly you’ll find yourself somewhere on this scale.

[00:01:48] Now of course we’re going to talk about it in terms of very discrete points on the scale,

[00:01:54] but this is a continuum.

[00:01:56] You’re not going to act only one way.

[00:01:58] You’re not going to fall entirely into one point on the scale.

[00:02:02] But I encourage you to consider how you might react or how you might behave to move to a

[00:02:11] new point on this scale if you don’t like where you’re at.

[00:02:16] So this podcast, this episode is not intended to make you feel bad about where you are on

[00:02:23] the scale, but instead to try to provide a clear picture of the full scale altogether.

[00:02:31] So the idea is to zoom out of your own circumstance and try to imagine what other circumstances

[00:02:38] may allow.

[00:02:41] Now one thing that we’ll note in advance before we get into the scale is that there is no

[00:02:45] point on the scale where you have escaped the relationship with mistakes.

[00:02:51] In other words, you will always have mistakes.

[00:02:56] There’s no point on the scale where you will be able to break away and stop making mistakes.

[00:03:02] So that should not be a goal.

[00:03:05] As much as we want it to be a goal, it shouldn’t be a goal.

[00:03:10] And part of the reason for that is because if we don’t have mistakes, then we are probably

[00:03:15] not learning.

[00:03:17] past our previous barriers, not just individually, but as teams, and we’re not helping others

[00:03:24] grow.

[00:03:25] Okay, let’s get into the five stages of your relationship with mistakes.

[00:03:32] We’re going to start at the kind of least healthy relationship with mistakes.

[00:03:38] That is the stage one, this willful ignorance, willful ignorance.

[00:03:43] You’ve seen this done before, you probably have done it at some point, and perhaps you

[00:03:48] regretted it.

[00:03:49] But the idea here is that you just ignore the mistake.

[00:03:54] Whether that’s a bug in code, or some other mistake, some other fault, you are willfully

[00:04:01] choosing to ignore it.

[00:04:04] This isn’t because you’re not aware of it, right?

[00:04:08] It’s possible that you’re not aware of a lot of mistakes, which this kind of scale,

[00:04:13] you can’t really have a relationship with something that you’re unaware of.

[00:04:19] So we kind of ignore that for the sake of this episode.

[00:04:21] But if you’re willfully choosing to avoid any kind of contact with the mistake, in other

[00:04:30] words, you’re not investigating it, you’re not trying to change it in any way, you’re

[00:04:37] not trying to understand it in any way, you’re just ignoring it, you’re going about it, you’re

[00:04:41] going about your job, you’re writing your code as if that bug doesn’t exist at all.

[00:04:49] You might ship that bug into production knowing it’s there.

[00:04:54] Now why is this an important state to bring up?

[00:04:57] Well, because this is something that we do more often than we realize, most likely.

[00:05:03] We are choosing to prioritize one thing over another, understanding that there’s a mistake

[00:05:12] that we’re not rectifying.

[00:05:15] And in some ways, this is actually functional.

[00:05:17] This is important to be able to do with the right kinds of mistakes.

[00:05:21] But the part that breaks down and what’s unhealthy about this stage is the idea that we’re choosing

[00:05:28] to kind of stick our head in the sand, we’re willfully ignorant.

[00:05:34] It’s a little bit different to be cognizant of the mistake, to understand it, and to be

[00:05:40] able to categorize it into a category that says, oh, this is a low priority mistake,

[00:05:46] right?

[00:05:47] But that’s not what this stage is.

[00:05:48] The stage one is willfully ignorant, so you don’t know what the priority is because you’re

[00:05:52] choosing not to inspect any further.

[00:05:56] Now you can be on the opposite end of the scale, and we’ll talk about the opposite

[00:05:59] end of the scale shortly, but you could be on the opposite end of the scale and still

[00:06:04] choose to ship known bugs into production because they’re low priority.

[00:06:11] Maybe you found workarounds or whatever the case is, but you’re not being ignorant on

[00:06:17] that end of the scale.

[00:06:18] Right?

[00:06:19] We’re going to talk about that end of the scale, but understand this willful ignorance

[00:06:23] is the idea that somehow you expect the universe or some other force to manage the mistakes

[00:06:31] for you.

[00:06:32] Now, what’s strange is that sometimes that actually happens, right?

[00:06:36] Sometimes we ship a bug into production, and then we write code, we rip out some old code

[00:06:43] not even knowing that that code contained the bug that we shipped to production, and

[00:06:47] that bug, of course, because it’s been replaced with new code, that bug goes away.

[00:06:52] So sometimes this accidentally works, right?

[00:06:56] But this is not by design.

[00:06:58] We’re not dealing with our mistakes by design.

[00:07:01] We’re dealing with them haphazardly or by chance.

[00:07:05] Okay, let’s move on to stage number two.

[00:07:09] And this is still not a very healthy stage, but at the very least, we’re not willfully

[00:07:13] ignorant.

[00:07:14] This stage is treating mistakes as anomalies, treating mistakes as anomalies.

[00:07:21] The idea here is that when a mistake occurs, we consider it to be an exception.

[00:07:28] We consider it to be out of the norm.

[00:07:31] And so we don’t plan for mistakes if we’re in this stage, right?

[00:07:35] We end up having to work extra over time because we expect that we can work at, let’s say,

[00:07:42] 80 or 90% utilization of our time, and we’ll be fine because we don’t make mistakes regularly.

[00:07:49] And so why would we build in time to deal with them?

[00:07:53] And this is where we find our problem, right?

[00:07:56] Because any time a mistake occurs, not only do we immediately jump into kind of an urgent

[00:08:03] state, but we also don’t plan ahead for them.

[00:08:07] Because if mistakes are anomalies, then on average, we’re not going to have them, right?

[00:08:14] On the average day, we shouldn’t spend extra time preparing for those mistakes because

[00:08:21] they don’t happen often enough to prepare for them.

[00:08:25] Of course, in that stressful state, when we’ve made a mistake and we’re already at our limit,

[00:08:32] we’re having to fix our mistake above our limit.

[00:08:39] This is a critically important thing for managers, especially to understand if you push your

[00:08:43] team to their limit when it comes to a critical moment.

[00:08:50] Like for example, if you ship a bad bug into production, but you’re already at your limit,

[00:08:56] you’re already pushing people to the point that they can’t really give anymore, they’re

[00:09:02] tired or they’re mentally burned out, then you’re in a really bad scenario to deal with

[00:09:10] that mistake.

[00:09:12] Even though you’re not willfully ignoring it, this is still a bad scenario to be in.

[00:09:17] This is still a bad relationship with mistakes because you’re already at the limit.

[00:09:23] You’re probably going to make another mistake, and you can see where this goes, right?

[00:09:28] As we continue to snowball our mistakes on top of each other rather than slowing down

[00:09:33] and having the headspace to deal with them, those mistakes continue to compound.

[00:09:41] This leads to really bad culture, and of course, treating mistakes as anomalies makes

[00:09:47] people feel horrible.

[00:09:50] It makes people feel bad, and not only bad, but also scared.

[00:09:55] They’re afraid to make mistakes, and we know from plenty of research, and we already kind

[00:10:00] of alluded to this at the beginning, that the opportunity to make mistakes is critical

[00:10:06] to success.

[00:10:09] It’s critical to having an innovative and healthy team, and this is something that has

[00:10:16] been shown in study after study, right?

[00:10:19] This is not novel.

[00:10:20] If we have people who are afraid because they think they’re going to make a mistake and

[00:10:25] it’s going to push everybody past their limit because mistakes are supposed to be anomalies,

[00:10:31] that’s a really bad situation to be in, both individually and as teams.

[00:10:37] We’re going to come back in just a moment and talk about the last three stages of your

[00:10:41] relationship with mistakes, but first, I want to talk about today’s sponsor, Imagix.

[00:10:46] I’ve been using Imagix for a long time now, and I absolutely love Imagix.

[00:10:51] This is a product that’s made for developers, but it has a super simple API, okay?

[00:10:57] There’s plenty of libraries for basically every language, pretty much every front-end

[00:11:02] framework, and they have a global image CDN, and this helps developers deliver lightning

[00:11:09] fast sites and apps through automated image optimization.

[00:11:13] It makes responsive design and development easy.

[00:11:16] Images are automatically optimized for every browser and device, and it’s used by thousands

[00:11:21] of developers from companies like Unsplash, Kickstarter, and Prismic, and here’s the thing.

[00:11:27] The API for this is so simple that you can kind of adapt it to pretty much anything

[00:11:34] you’re doing, right?

[00:11:35] There’s so many options, and it’s all driven off of this parameter-based API.

[00:11:41] You just have to try it out to understand what I’m saying.

[00:11:44] It feels like magic every time I use it.

[00:11:47] Go and check it out.

[00:11:48] Head over to Imagix.com, that’s I-M-G-I-X dot com slash developer T to get started.

[00:11:56] I’ll say one more thing about Imagix because it’s such an important part of what they do.

[00:12:01] It’s not just about optimizing photos for the web, right?

[00:12:05] You can also manipulate those photos with Imagix.

[00:12:07] There’s all these cool filters, and you can lay text over the top of them, and you have

[00:12:11] to do basically none of the back-end work.

[00:12:14] You don’t have to mess around with image manipulation libraries or anything like that.

[00:12:20] It’s all available on Imagix, and of course, it’s super, super fast.

[00:12:24] Go and check it out, Imagix.com slash developer T.

[00:12:26] Okay, let’s talk about the last three stages of our relationship with mistakes.

[00:12:33] The third stage, we’ve already been through stages one and two.

[00:12:36] Number one was willful ignorance.

[00:12:38] Number two is treating mistakes as anomalies.

[00:12:42] Number three moves on from treating something as an anomaly, and instead, it anticipates

[00:12:47] mistakes.

[00:12:48] You’re anticipating that they may happen.

[00:12:52] What happens when you get to an anticipation stage?

[00:12:55] This is where you might plan for the mistakes to happen.

[00:12:59] You might build in some overhead time to deal with the mistakes when they happen, right?

[00:13:06] You may even review mistakes as they occur, but most likely, most of what you’re doing

[00:13:12] here is just allowing for mistakes to happen and not kind of bearing down on people.

[00:13:19] This is really the culture shift moment.

[00:13:22] When you recognize that mistakes are not anomalies, you change over to believing that, hey, you

[00:13:28] know what?

[00:13:29] Actually, mistakes happen frequently, and they happen to even the best engineers, right?

[00:13:36] They happen to the highest caliber talent in any field, and so we should prepare for

[00:13:43] them.

[00:13:44] We should plan for them.

[00:13:45] We should make space for them.

[00:13:47] And we should not make people feel afraid to make mistakes.

[00:13:52] So this is a massive culture shift, and you can imagine there’s kind of a rift between

[00:13:58] stage two and stage three where you change your mindset and your relationship with mistakes.

[00:14:05] But there’s still two more stages to go, because here’s the reality.

[00:14:10] Even though you make space for the mistakes to happen, you’re not improving purely by

[00:14:16] making space for them to happen, right?

[00:14:20] And so if you’re just anticipating the mistakes, if you’re just making space for them, you’re

[00:14:25] not changing yourself.

[00:14:28] You’re not using the mistakes as a kind of jumping off platform for improvement, which

[00:14:34] is kind of the whole point, right?

[00:14:37] It’s the whole point of allowing mistakes to be normalized in your culture so that you

[00:14:44] can improve.

[00:14:45] You’re not just saying, oh, mistakes are a wonderful thing, and then you just let them

[00:14:50] happen.

[00:14:52] We need to respond to the mistakes in some particular way.

[00:14:56] So that’s stage four.

[00:14:58] Stage four is responsive stage, responsive stage.

[00:15:03] Or you can also view this as kind of adaptive stage, right?

[00:15:08] When a mistake occurs, we change our approach.

[00:15:13] We might do a postmortem in this stage.

[00:15:15] We might create some tests based on previous failures.

[00:15:21] We might see areas where we are weak, where that mistake is kind of costing us a lot of

[00:15:28] resources.

[00:15:29] And we might respond to that by improving in those particular areas, right?

[00:15:34] So this is a relatively healthy relationship with mistakes.

[00:15:39] It’s where a lot of engineering, good engineering organizations, end up sitting, right?

[00:15:45] Is in this responsive state where we don’t know what the mistakes are going to be, but

[00:15:50] we know that we can handle them and we can improve in our handling of mistakes, right?

[00:15:57] Stage five, stage five, this is kind of the, you know, the best possible relationship with

[00:16:02] mistakes and that is to engineer the mistakes into your process.

[00:16:10] This is kind of the fully integrated stage where you are actually taking mistakes that

[00:16:17] haven’t ever happened before in your testing against them.

[00:16:21] You might have some automated mistake generators, right?

[00:16:26] This is a chaos engineering falls into this category where you’re creating new states.

[00:16:33] These are states that maybe you’ve never had before in the past.

[00:16:36] And those states are actually kind of bringing out mistakes that you’ve made, whether it’s

[00:16:42] in your code or in your organization or in your personal life.

[00:16:47] You engineer ways to stress test any system that you are, you know, working with, right?

[00:16:57] So this is how you’re being proactive in engineering mistakes into your process.

[00:17:05] At this stage, you might hold something called a premortem where you try to imagine what

[00:17:11] are all the possible ways that things could go wrong.

[00:17:13] You’re predicting future mistakes.

[00:17:17] Some companies that are at this stage will have people whose job it is to explicitly

[00:17:22] try to come up with an offensive strategy to disable their company.

[00:17:29] Of course, they’re not going to employ this, but if they can come up with an offensive

[00:17:33] strategy that disables or otherwise could dismantle an effort at their current company,

[00:17:42] can defend against that in a novel way.

[00:17:48] So there’s investment into understanding and preparing for future mistakes that we

[00:17:55] didn’t even know were going to happen, or they may never happen at all.

[00:18:01] And you can see how this is almost in direct opposition, right?

[00:18:06] It’s almost the exact binary opposite of stage one, which is willful ignorance.

[00:18:14] Here we are not only on the opposite end where we’re incredibly aware of the mistakes that

[00:18:20] are being made and we’re responding to those, but we’re also preparing and engineering

[00:18:25] new mistakes into our process so that we know how to deal with them if they were to happen.

[00:18:32] This is a predictive kind of offensive strategy that requires upstream thinking.

[00:18:40] It requires that we change the way that we interact with mistakes.

[00:18:47] We invite them into our thought process rather than waiting for them to happen as a result

[00:18:54] of a bunch of factors that we can’t control.

[00:18:56] If we can simulate mistakes in scenarios that we can control.

[00:19:01] If we can lower the stakes of the scenarios where mistakes are occurring, then we can

[00:19:09] deal with them in a much more controlled environment.

[00:19:13] We can also prepare for them so that when they do happen in a higher stakes environment,

[00:19:18] we’ve kind of had a dress rehearsal.

[00:19:21] We know what to do if that occurs.

[00:19:24] So those are the five stages of a relationship with mistakes.

[00:19:30] I hope that you found yourself somewhere on that spectrum and I’d love for you to

[00:19:35] reach out and let me know where you’re at.

[00:19:39] I’d love to know what is your relationship with mistakes, but also how is it changing?

[00:19:45] How has it changed in the past?

[00:19:48] You can find me on Twitter at at developer T or my personal handle at at Jake Trell.

[00:19:53] Thank you so much for listening to this episode.

[00:19:55] Thank you again to Imgix for sponsoring today’s episode.

[00:19:58] Head over to Imgix.com, that’s I-M-G-I-X dot com slash developer T to get started today.

[00:20:05] Thanks so much for listening to this episode.

[00:20:07] This episode and every other episode of developer T can be found on spec.fm.

[00:20:11] Today’s episode was produced by Sarah Jackson.

[00:20:14] My name is Jonathan Cottrell and until next time, enjoy your tea.

Visão de gráfico