A 1967 study gave us the concept of learned helplessness — but the same researchers later reversed it. Passivity is our default state; control is what we learn. In this episode, I unpack what that neuroscience means for how you face hard things in your career, and why the action you take doesn't have to match the size of your problem.

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.

Accountability is one of the most important concepts in your career—and one of the most frequently weaponized. In this episode, I unpack why so many of us have a visceral reaction to the word, and offer a pragmatic, functional definition that reframes accountability as something a good engineer actually invites. Drawing a parallel to software bug reports and root-cause analysis, I explain how healthy accountability creates clarity of expectation rather than surprise punishment.

The skills you've built for reading people, reviewing code, and making calls under uncertainty all rely on the same brain shortcut: substituting an easier question for a hard one. In this episode, Jonathan explores how to take that automatic mental trick and use it on purpose — shrinking weighty, paralysis-inducing decisions down to the small, low-stakes actions they're actually made of.

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.

The skills you spent years building are getting cheaper to replicate—but that's not where the friction lives. In this throwback episode, I unpack why agentic coding hasn't made your team faster, and why the answer is the oldest model in the book: the theory of constraints. If you're a manager or a senior engineer being asked "why can't this go faster," this one's for you.

The skills problem isn't going anywhere — it's just wearing new clothes. In this episode, I unpack how the lessons we learned decades ago (limiting work in progress, the theory of constraints, test-driven development) are coming roaring back as the fundamentals that will carry you through the agentic shift. The bottleneck has moved, and knowing where it went changes how you should work.

The skills that survive every industry shakeup aren't the ones you can Google — they're softer, harder to name, and far more durable. In this episode, Jonathan explores principle-oriented thinking: the practice of stripping away the labels we attach to tools, roles, and even ourselves to see what something actually does at its core. It's the difference between handing your coding off to an agent and rethinking your entire workflow around what these new materials are truly capable of.

Feedback is one of the hardest skills in any career, and most of us have only experienced a handful of moments where it actually drove positive change. In this episode, Jonathan explores how to give and receive feedback that leads to real growth — starting with setting your ego aside, getting clear on your goal, and using behavior-based models like SBI and Netflix's Four A's. It's a durable skill that turns a contentious, dreaded conversation into a genuine pathway to career development.

If you're a software engineer right now, the questions you're asking about your career probably feel existential. We've been spending a lot of time on this show preparing for the changing industry—what skills matter, what mindset works—and one answer keeps surfacing: your ability to update your mental models is itself the critical skill. In today's episode, I push on that idea directly. Some of the thinking models that defined good software engineering for the last decade deserve real scrutiny now, and a few of them may deserve to be thrown out entirely. This is an uncomfortable ask, especially for those of you who earned your wisdom the hard way—but the engineers who can hold their hard-won models loosely are the ones who won't hit a ceiling.