Finding A Way Through Forced Change of AI Transformations

You likely chose most of the changes in your career yourself, and many engineers now feel AI-driven change is being forced on them. In this episode, I talk about why that shift feels so personal, and how three ideas can help you face it: the Stoic principle that "the obstacle is the way," Nassim Taleb's antifragility, and the biological cycle of stress and adaptation. For most of my career, the changes I went through happened at my own pace. I picked what to learn, whether that was jQuery animations or the next framework, and each new skill felt like a superpower. Many engineers today will recognize that progression, and it's a big part of why we love this work. Now the AI-driven shift in our industry is changing that for a lot of people. The change isn't chosen anymore, and for many engineers it's scary. In today's episode, I talk about why this shift feels so personal, and I share a framework you can use to grow through it instead of avoiding it. Change You Chose vs. Change Chosen for You: A lot of what made software engineering rewarding was agency. We picked our tools, our learning paths, and often our jobs. Agentic engineering is taking away some of that choice, and it's worth naming that loss honestly. A Note for Engineering Managers: If you never went through this kind of progression as an engineer, this part is for you. Code is more than a convenient tool for your engineers. It's something many of them love. Like a blacksmith with a hammer they've used for 20 years, they may not want the "better" tool, and a purely rational argument about better tooling misses the human side of the conversation. The Obstacle Is the Way: Drawing from Ryan Holiday's book and the Stoic philosophy of Marcus Aurelius it's based on, consider treating the obstacle in front of you as the path forward instead of something standing in your way. Antifragility and Stress Adaptation: Nassim Taleb's Antifragile describes systems that are actually improved by stressors. The same pattern shows up in biology, as in strength training: stress, adaptation, recovery, repeat. With proper recovery, the stressor leaves you more resilient to it. Why Avoidance Makes It Worse: Cognitive behavioral therapy shows that avoiding what we fear tends to feed rumination. Safely and rationally confronting that fear, and learning that you survived it, is what drives the adaptation. An Integrated Path Forward: If you want to stay in this industry and keep building software, you don't have to give up what you loved about the work. You can face the thing you're afraid of, give yourself time to recover, and then go again. Episode Homework: Find a quiet space and reflect honestly. Ask yourself, "What about this industry shift am I avoiding?" There's no right answer, but what you're avoiding may be the most useful thing for you to confront. 📮 Ask a Question If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com. 📮 Join the Discord If you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today! 🗞️ Subscribe to The Tea Break We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com. 🧡 Leave a Review If you're enjoying the show and want to support the content head over to iTunes and leave a review!

Your brain is constantly trying to simplify the world. It takes a snapshot of what it sees, builds a picture that makes sense, and then works from that picture. Most of the time this works well enough. But when we plan projects, set goals, or try to predict where something is headed, these default modes of thinking can lead us in the wrong direction. In today's episode, I cover three of these defaults: linear thinking, static thinking, and infinite or non-discrete thinking. I also talk about how they show up in your career and in the way engineering leaders set vision for their teams. Static Thinking and the Snapshot Problem: We tend to fix our beliefs about people very quickly, which is why first impressions carry so much weight. If someone acts a certain way in one meeting, we assume that's how they act in every meeting. This is closely related to the fundamental attribution error, where we treat a person's behavior in one moment as a permanent part of who they are instead of a response to their environment. Linear Thinking and Exponential Change: When something is changing, we assume it will keep changing at about the same rate. AI agents are a good counterexample. Research suggests their effectiveness roughly doubles on a timescale of a few months, and even if the exact numbers are off, the curve is exponential. That kind of growth is hard to picture intuitively, and it probably won't last forever. At some point it will likely level off into something closer to logarithmic. Where Our Intuition Comes From: Nonlinear patterns are all around us in nature. Think about how quickly heat rises as you move your hand toward a fire, or how loudness changes as you get closer to a speaker. But our social lives mostly involve slow, roughly linear change, and over the course of human history our minds have adapted to that kind of linear model. Your Career Isn't a Straight Line: Many of us expect our salary and growth to rise steadily, in steps, for our whole careers. That expectation often breaks down, especially later on, and it makes exponential income growth hard to even imagine. Infinite Thinking and Missing Endpoints: We aren't naturally good at thinking in discrete stages. We rarely design our careers in phases or plan for how they end until those moments are right in front of us. Cultural habits like contributing to a retirement account do some of that planning for us almost by accident, but most areas of our lives get no such help. Two Traps for Engineering Leaders: When setting direction for a team or department, leaders often fall into one of two traps. The first is a "forever vision," an unbounded picture of perfection that the org is supposed to chase. The second is purely linear planning, where you only do the next thing in front of you and never step back to look further ahead. The Productive Middle: The most useful vision work usually happens on a timescale of months to years. That's harder than it sounds, because it calls for a concrete plan, a lot of saying no, and putting the pieces together in a discrete way that doesn't come naturally to us. Episode Homework: Becoming aware of these defaults is the first step. Add linear, static, and infinite thinking to your planning checklist. Next time you set a goal or a vision, ask yourself which of these defaults might be shaping your picture of reality. 📮 Ask a Question If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com. 📮 Join the Discord If you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today! 🗞️ Subscribe to The Tea Break We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com. 🧡 Leave a Review If you're enjoying the show and want to support the content head over to iTunes and leave a review!

Keeping up has always been part of the job for software engineers, and with AI it's harder than ever. In this episode, I talk about two signals that you, your coworkers, or the people you manage might have a regressive mindset, which shows up as quietly avoiding the learning you need to stay current.Keeping up has always been part of being a software engineer, and right now it's harder than ever. A lot of us are tired, skeptical, or just overwhelmed by the constant stream of AI news, and it's easy to slide into habits that slowly cut us off from new information. In today's episode, I talk about two signals to watch for in yourself, your coworkers, or your reports that point to a regressive mindset. That's a pattern of avoiding progress and learning, often without realizing you're doing it.What a Regressive Mindset Actually Is: A progressive mindset doesn't require jumping on every new tool or throwing out your whole toolset. Constant upheaval isn't progress. What matters is that your understanding of the world keeps growing. The regressive mindset shows up as avoiding learning and leaning on defense mechanisms that shield you from more nuanced information.Signal #1: Avoiding Information by Category: Watch for the moment you click away from an article or video just because it mentions AI or agents. You don't have to read everything, but if you're skipping things purely because of the subject, it's worth figuring out why. Fatigue might mean you need a break. Skepticism or discomfort is a different story.The Ostrich Effect: Avoiding uncomfortable information is a lot like sticking your head in the sand. It feels protective, but over time it leaves you behind and out of touch with what it takes to stay competitive as the industry changes.What Is Your Alternative Path?: If your plan is to keep avoiding this information, ask yourself honestly what that looks like a year or five years from now. I'd argue that avoiding it forever just isn't possible.Signal #2: Tying a Concept to a Person: Many organizations have one or two people carrying the flag for AI adoption. If "the AI enthusiast" has become the whole of what that person means to you, you may be dismissing everything they say, even on topics that have nothing to do with agents.The Flip Side and Fundamental Attribution Error: The same trap works in reverse. If you don't trust someone, you may throw out good information simply because they're the one bringing it. This is closely related to fundamental attribution error, where we explain someone's choices by who they are and judge the information by the messenger.Episode Homework: This week, notice when you skip, dismiss, or tune out information. Ask yourself whether it's because of the topic or the person sharing it, and what your long-term alternative really is.📮 Ask a QuestionIf you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.📮 Join the DiscordIf you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today!🗞️ Subscribe to The Tea BreakWe are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.🧡 Leave a ReviewIf you're enjoying the show and want to support the content head over to iTunes and leave a review!

You're tired of hearing that you need to pick up AI, so today I'm not going to add to that pile. Instead, we'll look back at two moments in history that look a lot like this one: the arrival of Fortran in the 1950s, and the spread of autopilot in commercial aviation. Both show how new abstractions change the shape of our work without being purely good or purely bad. You've heard plenty of engineering leaders tell you to use more AI and more agents, often in a way that seems out of touch with your day-to-day work. I'm not going to add to that today. Instead, I want to share some history. If it feels like our industry is in a completely unique moment, it helps to look at earlier times that had a similar shape. In this episode, I look at the early skepticism around Fortran and the effects of autopilot on pilot skill. Then I explain why a dualistic "good or bad" view of AI leaves out most of what is actually happening. Fortran and the Skeptics: In the 1950s, Fortran became widely known as the first high-level language, generating machine code so programmers didn't have to write it by hand. Skeptics doubted it. John von Neumann reportedly questioned why a serious scientific machine should do "clerical work," and many engineers didn't trust the generated code. The Critics Were Partly Right: Early generated code wasn't very good and needed a lot of massaging. The Fortran team didn't go back to the old way. They put their effort into improving the new abstraction. The criticisms of the new tool became the fuel for making it better. Autopilot and Cognitive Saturation: Commercial aviation is one of the safest forms of travel, and automation is a big reason why. Taking the manual work of flying off the pilot frees up mental capacity for radio calls, navigation math, and diagnosing problems. That adds a safety margin to every flight. Children of the Magenta Line: Automation also brought a new risk. When pilots rely on GPS and autopilot, their manual flying skills can atrophy, and that matters in the rare cases where the automation fails. Something similar can happen to engineers who lean heavily on tools like Claude Code. Some might choose to work in their codebase without AI now and then, or practice LeetCode-style problems, just to keep those skills sharp. Beware Dualistic Thinking: New technology rarely pushes things in only one direction. It brings new easier things and new harder things, more quality and new risks to quality, skill atrophy and room to focus on completely new problems. Whenever you catch yourself framing something as a simple good-or-bad duality, ask whether your brain is just trying to make it easier to understand. A Warning for Team Leaders: It's a mistake to push agents into your existing workflow as if they were a simple accelerant. These tools change who is attracted to the work. They may draw in new people who were never interested in engineering before, and they may push away engineers who loved the job as it was five years ago. Where This Is Probably Headed: If this follows the pattern of past technological revolutions, today's rapid pace will eventually level off. The unreliability we see now is likely to drive future reliability, and wider adoption tends to follow once tools stabilize. In the meantime, the fatigue is real, and it's worth paying attention to what it's doing to your mindset. Episode Homework: Pick one opinion you hold about AI in your work. Ask yourself whether you've framed it as all good or all bad, then list the new risks and new opportunities it creates together. 📮 Ask a Question If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com. 📮 Join the Discord If you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today! 🗞️ Subscribe to The Tea Break We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com. 🧡 Leave a Review If you're enjoying the show and want to support the content head over to iTunes and leave a review!

Fundamentals get talked about constantly, but rarely defined. In this episode I dig into what a fundamental actually is — the building blocks, heuristics, and core characteristics that don't change — and why they matter more than ever in a profession where abstraction moves faster than almost anywhere else. If you feel like you can't keep up with every new framework, model, or tool release, the answer isn't to read faster. It's to step up a level. Fundamentals get talked about constantly — in sports, in hobbies, in software — but we rarely stop to define what one actually is. In today's episode, I unpack what makes something fundamental, why software engineering in particular buries its fundamentals under layer after layer of abstraction, and how principles-first thinking gives you a way to keep up with an industry that never stops moving without needing to learn every single new thing that ships. What Actually Counts as a Fundamental: Fundamentals aren't rules — they're building blocks, behaviors, habit patterns, and heuristics. In basketball it's dribbling. In football it's blocking. In software it's readability, reliability, the setup-execute-teardown shape of a test, basic logic structures. In communication it's sender, receiver, feedback, and noise. Why Software Abstracts Faster Than Almost Anything Else: Compare the practice of law, where the fundamentals look largely the same as they did fifty years ago, to software, where the work is symbolic at its core. We build symbols that mean something to humans but map down to a hard physical reality of flipped bits and moving electrons — and that symbolic nature is exactly what lets abstraction pile up so quickly. The Rise of Linguistic Abstraction: Our abstractions have become increasingly language-shaped. Object, function, flow, durable object, mesh, graph — these are primitive ideas expressed as words, and understanding that shift explains a lot about how the industry actually progresses. Abstractions Have Fundamentals Too: This is the key move. If you understand what makes Postgres a good fit — structured, predictable, relational data — you can evaluate any other relational database without learning it from scratch. Understand the primitives of NoSQL, or of an index lookup, and you no longer need to chase every implementation. Decompose, Then Recompose: Principles-first thinking means breaking things down into their underlying characteristics so you can recombine them into solutions you care about. It works on databases, on business offerings, on competitive positioning — anywhere you'd otherwise be tempted to evaluate things as wholly separate. Applying It to LLMs: When a new model drops from one provider or another, you don't need to start over. If you know which characteristics matter, you can see what changed here versus there — and treat them as variations on shared fundamentals rather than two entirely different things. Practice vs. Analysis: There are two flavors here worth separating. Fundamentals in practice are the things you do repeatedly — giving feedback regularly, for example. Fundamentals as analysis is a way of looking at new technology and asking what core characteristics make it up. You want both: composable actions and composable tools. Risk as a Fundamental: A live example from my current role — determining the right level of risk in a given scenario can't be a one-size-fits-all rule. It requires understanding the fundamental characteristics of the risk and reward you're accepting. Episode Homework: Look at your work and ask where you're too deep in the weeds. Where are you thinking too granularly? Where are you missing the abstraction class — the consistent things shared across multiple iterations that you could be watching from a step away? That distance is what gives you leverage to notice when something fundamental actually changes. 📮 Ask a Question If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com. 📮 Join the Discord If you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today! 🗞️ Subscribe to The Tea Break We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com. 🧡 Leave a Review If you're enjoying the show and want to support the content head over to iTunes and leave a review!

In 1967, a study on shock avoidance gave us "learned helplessness," and for nearly fifty years that was the prevailing explanation for why people give up. Then the original authors published a follow-up with brain scan data showing they had it backwards. We don't learn to be helpless — passivity is the default. What we learn is control. In today's episode, I explore what that reversal means for anyone facing a hard problem right now, and why a single small action can shift your entire orientation toward a challenge you haven't solved yet.The Study That Reversed Itself: Understand how the 1967 learned helplessness research was revised roughly a decade ago by its own authors. The brain scan data showed the neurological change wasn't happening in the animals who gave up — it was happening in the ones who discovered their actions relieved the negative experience.Passivity Is the Default, Not the Result: This is a fundamental shift. If helplessness were learned, we'd have a lot to reverse. But if passivity is simply where we start, then exerting control isn't undoing damage — it's activating something that was always available.Your Action Doesn't Have to Match Your Problem: If you're out of work, you don't need to land a job to get the neurological realignment. The brain doesn't measure whether your control input is equal in magnitude to the thing making you feel helpless. A much smaller input does the work.The Effect Persists: The research showed the behavioral change held up a week later, even against a new stressor that didn't pattern match the original. This isn't a momentary mood shift — it changes how you operate in the world.Why "Action Orientation" Shows Up on Every Job Description: These words look like corporate filler until you see the neuroscience underneath them. Being proactive isn't a personality trait some people happen to have; it's a mode you can enter by noticing that your control has an impact.Agency, Not Control: A careful distinction — this isn't about controlling outcomes. It's about your immediate environment. Set the temperature in your office. Clear your desk before you start work. Take back your calendar. Learn one thing you didn't know yesterday. Simple inputs where you can actually see the feedback.Episode Homework: Find the area of your life or work that feels most chaotic right now. Don't try to fix it. Find one 5% improvement — a single step in the right direction — and take it. My bet is you'll feel the realignment before the problem is anywhere close to solved.📮 Ask a QuestionIf you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.📮 Join the DiscordIf you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today!🗞️ Subscribe to The Tea BreakWe are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.🧡 Leave a ReviewIf you're enjoying the show and want to support the content head over to iTunes and leave a review!

As you grow as an engineer, something counterintuitive happens: the systems you build get simpler, not more complex. In this episode, I explore why senior engineers tend to collapse abstractions, accept certain risks, and reduce the surface area they're responsible for — and what drives that shift underneath the surface. Understanding the reasons behind the trend is what lets you get there on purpose instead of waiting a decade to arrive there accidentally. Early in your career, output goes up fast. You're building more than ever, especially with AI in the mix, and a lot of what you build carries real complexity. But watch engineers who have been doing this a long time and you'll notice the opposite of what you'd expect: as their craft improves, their code, their architectures, and their systems get simpler. In today's episode, I dig into why that happens — and why chasing simplicity directly is less useful than understanding the underlying forces that produce it. Simplicity Isn't the Goal — It's the Byproduct: Trying to "make things simpler" as a directive doesn't get you very far. If you can understand the core reasons complexity tends to fall as engineers mature, you can aim at those reasons instead and arrive at simplicity organically. Why Simpler Code Pays Off: Simpler things are easier to understand, which means junior engineers can pick up your code, and future-you can return to a project you've long since left and still make sense of it. Adapting a simple thing is almost always easier than adapting a complex one. The Pain of the Refactor Teaches You: A big part of this shift is scar tissue. Once you've lived through a massive refactor of a complex system, you start making different trade-offs — not from theory, but because you don't want to do that again. Collapsing Vertical Abstractions: One of the most common refactors senior engineers reach for is collapsing long chains of abstraction that only ever get used in one place. It's abstraction without reuse, and it forces you to re-load enormous context just to make a small change. Refining Your Risk Tolerance: Early on, we hedge against every possible risk. Later, we learn some risks are acceptable. Hedging is insurance, and sometimes it's very expensive insurance — paid in velocity, in onboarding difficulty, and in only being able to hire people who can hold all that complexity in their heads. Knowing When to Break Best Practices: Maybe the best practice says abstract this. But if it isn't that hard to understand, and you can get most of the benefit through better naming or tighter scoping, the "correct" move might be the wrong one. The Library Trap (In Both Directions): Seniors often take a trip through "let's not use external packages, we don't know what's in them" — and end up maintaining a shadow version of the thing they avoided. The more experienced call is often to accept the trade-off, adopt the well-documented dependency, and shrink what you are responsible for. Reducing Surface Area Creates Focus: The through-line in all of these trade-offs is a shrinking surface area. Fewer things to maintain means more focus, and more focus means the things you are responsible for get done very well. It's an open question whether those behaviors follow seniority or cause it. Drive to the Fundamentals: Think about a machine built from a ramp, a screw, a rubber band, and a motor. A more senior craftsperson recognizes the problem is fundamentally about conservation of energy, and reconfigures it down to two parts instead of eight. Slightly less efficient, maybe — but far less to teach, maintain, and break. Episode Homework: Ask yourself: what am I responsible for right now that I could simplify? Where can I get away from the tactics and the surface-level stuff, get down to the core of the thing, and focus on doing that core really well? 📮 Ask a Question If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com. 📮 Join the Discord If you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today! 🗞️ Subscribe to The Tea Break We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com. 🧡 Leave a Review If you're enjoying the show and want to support the content head over to iTunes and leave a review!

Accountability is a word you'll hear in your performance reviews, from your manager, and increasingly as you step into leadership. It's also one of the most abused and misunderstood concepts in our industry. Many of us have a visceral, negative reaction to it—not because the concept is broken, but because the companies and people we've worked with have bastardized its meaning. In today's episode, I want to strip away the scary parts and offer you a pragmatic, working definition of accountability: one that a good engineer would actually invite rather than dread. What We Cover The Bad Version of Accountability: Recognize the weaponized version of this word—being audited for things you didn't know you were responsible for, having unrealistic goals coerced onto you, and getting surprised at performance review time. This is how leaders shirk their real responsibility to grow people and create clarity, hiding hard performance conversations behind a single loaded term. Accountability as Debugging: Shift the frame to how we think about software. When payroll software overpays your team by $100, you file a bug report—something deviated from the agreement about what should happen. The engineer who investigates is performing an accounting function, tracing a root cause. That's what being "held to account" really means: identifying what happened against a known standard. The Churning Customer Problem: Understand what happens when the bug report never gets filed. A customer who hits something unexpected and just leaves never gives the company a chance to fix it. The same thing happens between you and your manager when the communication lines aren't established—you find out at review time instead of when it could have mattered. Accountability at Every Step: In a healthy team, accountability isn't a once-a-year audit. It's continuous, giving you the ongoing opportunity to notice when something has deviated from the agreement—so you have something concrete to hold to account before it becomes a surprise. Estimates vs. Commitments: Learn to separate the two things you say to a stakeholder. One is a forecast, a guess, a belief. The other is a commitment. Bad accountability coerces the estimate into a commitment it never was; too-soft accountability treats everything as up in the air. The healthiest organizations hold both: a high-confidence forecast, plus a commitment to do whatever is necessary if it looks like it won't get done. Why Good Engineers Invite It: If you want to grow in your career and confront reality, you invite accountability and commitment inspection. Done well, it creates clarity of expectation for exactly how you're doing—which is a gift, not a threat. 📮 Ask a Question If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com. 📮 Join the Discord If you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today! 🗞️ Subscribe to The Tea Break We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com. 🧡 Leave a Review If you're enjoying the show and want to support the content head over to iTunes and leave a review!

There's a cognitive trick our brains play whenever we face a hard question or a difficult decision: we quietly swap the hard thing for something easier to answer. It's called substitution, and we do it constantly — usually without noticing, and sometimes to our detriment. In today's episode, I make the case that you can take this same shortcut your brain already runs automatically and start using it intentionally to break decision paralysis and get moving. The Substitution Heuristic: Understand the mental move at the heart of this episode — when "How are you?" becomes "Is there anything I urgently need to say?", your brain isn't being lazy, it's compressing. It runs a quick calculation: what's the downside of the substitute? Usually it's low, so the shortcut holds. Code Review as Substitution: See why you almost never review a big PR line by line. "Was it tested? Does it follow our best practices? Does anything look obviously wrong?" are all stand-ins for the harder, mostly-unnecessary work of reading every line — and most of the time, they're enough. Performance Reviews Are a Best Guess: Recognize that your rubrics, metrics, and frameworks are themselves substitutes. You can't deterministically rate a person on a scale, so every measure you use is an approximation of an immeasurable question: how much value is this person really generating, and where are they headed? Turn the Trick Around on Purpose: Learn how to use substitution deliberately to defeat paralysis. Instead of "I'm deciding to leave my job and chase something new," substitute "I'm going to send an email." The weight of sending an email is tiny — and the dream job is just a series of small, iterative steps like that one. Unbundle Your Big Decisions: Notice how we fuse trivial mechanical actions with heavy imagined meaning. Merging a branch isn't "declaring this production-ready and putting my name on the line" — it's moving bits into the cloud. Separate the labeling from the action and the action gets a lot less intimidating. Lower Your Commitment Threshold: Swap "this code is great" for "I believe this code is shippable." Swap "this is the perfect hire" for "this is a good bet we can course-correct." The actions you take are identical — but the internal stakes, and the fear, drop dramatically. Favor Reversible Moves: We consistently overestimate the risk of acting and underestimate the risk of doing nothing. Most decisions aren't permanent — you can roll back the deploy, divert from a bad hire, find an exit path. Look for the way back, and the decision gets easier to make. Episode Homework Next time you feel a big decision looming, break it into its most fundamental pieces. Ask: what am I actually doing here? What are the physical actions, the words, the mechanical steps? What's the true worst-case downside — and do I really have to attach all of my worth to it? You're likely already substituting easier questions without realizing it. This week, try doing it on purpose. 📮 Ask a Question If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com. 📮 Join the Discord If you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today! 🗞️ Subscribe to The Tea Break We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com. 🧡 Leave a Review If you're enjoying the show and want to support the content head over to iTunes and leave a review!

The skills you build and the tools you master matter, but they aren't your most important asset when things go wrong — and something eventually will. In this episode, I work through why our careers and lives are governed more by avoiding catastrophic downside than by chasing upside, and why the single best tool for surviving a bad event isn't testing, insurance, or money — it's genuine trust with the people around you. Here's a question to sit with: what is the most important tool you have as a software engineer and as a leader? Most of us reach for something technical, but the answer runs deeper than that. In this episode, I start with the humble premortem — the practice of assuming something has already gone wrong so we can pressure-test our plans — and use it to explore why so much of our work is really about predicting and mitigating risk. From there, I make the case that because we're all exposed to a far larger downside than upside on any given day, the tool that matters most is the one that helps you survive the bad event you couldn't prevent: your relationships with other people, built on real trust. The Premortem as a Risk Lens: Learn why assuming failure ahead of time is such a useful counter to our natural optimism. Our plans quietly assume everything will go right, and a premortem forces us to inspect the gaps our best-laid plans never covered. Life Is Already About Predicting Risk: Nearly every action we take — stepping forward, eating the sushi, merging into traffic — is a small bet on an outcome we can't prove in advance. Much of what we're managing isn't even our own behavior, but the risk other people put us through. Why the Downside Dwarfs the Upside: On a typical Monday, your potential gain is limited, but your potential loss is not. A single catastrophic event — a breached customer, untested code shipped, an injury for an athlete — can undo far more than any single good action could ever build. This is why avoiding failure, not chasing brilliance, quietly shapes most successful careers. Likelihood Times Impact: Even a one-in-a-hundred-days negative event can cost you your job or your company a fortune, while very few actions could produce a commensurate gain like doubling your salary. Our behavioral aversion to risk turns out to be rational. Mitigate the Blast Radius, Not Just the Incidence: You can never be 100% certain a bad event won't happen. Good people who show up, stay reliable, and grow their skills still get laid off. So beyond reducing the likelihood of harm, you have to reduce its impact when it lands. Relationships Are the Real Safety Net: The most important tool in your belt isn't technical — it's your relationships with other human beings. Invested in honestly, they pay you back forever, and they're the thing you fall back on when the negative event you tried to prevent happens anyway. Trust Is the Core Currency: Genuine relationships require reality — real curiosity and care, not performed name-remembering, which people can see through. Trust compounds like an asset, while money spent to buy loyalty is gone the moment it's paid. When you hit a hard deadline or discover something's broken, a reservoir of trust is what lets people extend their best effort without you having to throw more money on the table. Episode Homework: Go invest in your relationships regardless of your current risk profile. Spend extra time in your one-on-ones, with your team, and in your retros — and get curious about what the people around you actually want, instead of assuming you already know. 📮 Ask a Question If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com. 📮 Join the Discord If you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today! 🗞️ Subscribe to The Tea Break We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com. 🧡 Leave a Review If you're enjoying the show and want to support the content head over to iTunes and leave a review!