Explorez tous les épisodes du podcast Developer Tea

If you are a manager, a lead engineer, or anyone growing into more responsibility, this throwback episode is built for you. We keep hearing the same question, now louder than ever: "Why can't this go faster?" AI and agentic coding have made the literal coding step dramatically cheaper, so product leaders reasonably expect the whole pipeline to speed up. But it hasn't—and in today's short, focused episode I explore why. The answer isn't new at all. It's the theory of constraints, and it has everything to do with friction you may not be looking at.

• Speed Isn't the Story—Friction Is: When a fast component gets introduced into the pipeline, the instinct is to celebrate the velocity. But pay attention to what comes after. The real question is what keeps work from naturally flowing faster, and that lives in the friction, not the energy you're pouring in upfront.
• The Universal Bottleneck: I rarely claim universal truths on this show, but here's one: anything that looks like a pipeline will have a bottleneck. If you're not paying attention to it, it doesn't matter how fast every other step gets. Faster coding just exposes where the constraint really sits.
• The Two Places Friction Shows Up: For teams fully adopting agentic coding, the bottlenecks cluster in two spots—requirements gathering at the front, and verification, validation, and testing at the back. Rushed requirements upstream create even more painful rework downstream.
• Why Agents Punish Vague Specs: Human engineers fill in gaps by being close to the work. Agents fill in gaps too, but sometimes incorrectly. If your requirements aren't detailed, the agent guesses, and you pay for it in review. Spend more time in the planning phase, not less.
• The Foundation You Build On: Agents glob extra code onto a weak structure—unnecessary models, redundant endpoints, patterns that don't fit. A code base organized with clear conventions, good documentation in your CLAUDE.md or AGENTS.md, and dependable patterns lets the agent discover and extend rather than guess and hope.
• Specification and Validation Are Bookends: Good requirements translate directly into good tests. Acceptance criteria on one end, changes in the middle, validation on the other end—directly connected. Poor specification sitting on a poor structure guarantees poor execution and poor validation.
• Reframing Your Objections: Think scope creep is the problem? That's a requirements issue. Think you lack the talent? That's a foundation issue—because the engineer's job now is to cultivate the foundation so generated code enriches it instead of toppling it.

This is not a new problem. We asked it of the internet, of web frameworks, of CSS. Now it's time to apply the same principles to agentic velocity: look at your requirements, your foundation, and your validation. Somewhere in those three is your bottleneck. I guarantee it.

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.

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!

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.

If you're enjoying the show and want to support the content head over to iTunes and leave a review!

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.

A lot of what we're learning about building with agentic tooling isn't new at all — it's a re-emphasis on lessons software engineers learned twenty years ago, just arriving in a new form. In today's episode, I walk through why the fundamentals are becoming more important than ever, why so many of us feel scattered despite having the most powerful tooling we've ever had, and where the real bottleneck in software delivery has quietly moved. My goal isn't to convince you that your job is now babysitting AI — it's to show you which parts of the work are still squarely yours, and how older principles can make you faster and more confident right now.

• Limiting Work in Progress Is Back: Just because you can spin up fifty agents doesn't mean you should split your focus across fifty things. Orchestrated fan-outs are powerful, but a human juggling agents across hiring, on-call, and a project all at once still pays the same old context-switching tax — and the quality drops while the speed never improves.
• Work Deeper, Not Wider: Instead of spreading yourself shallowly across more tickets, run multiple sessions on the same domain. Write a competing or adversarial version that critiques your assumptions, develop better documentation, or capture what you're learning as a reusable skill. Depth beats breadth.
• The Scattered-Engineer Epidemic: Engineers are burning out faster, not slower. We have the capacity to push more through the pipeline, so we're getting handed (or choosing) more than we can carry. Reducing parallelism often holds your delivery speed steady while dropping your cycle time and raising quality.
• The Theory of Constraints, Revisited: Treat your software development lifecycle as a pipeline with a bottleneck — and if you can't find one, you've optimized one part too far. Writing code used to be the choke point, so we spent enormous energy de-risking work before it ever reached an engineer.
• The Bottleneck Has Moved: When production gets cheap, it's no longer worth heavily de-risking upstream — which is why engineers are picking up more experimental, proof-of-concept, discovery work, and product folks are prototyping with these tools too. The new constraint isn't writing the code; it's verifying the agent didn't ship something broken.
• Verification Scales With Your Effort: The more an agent produces, the bigger the pile of PRs, MRs, and outputs waiting on human review. That backlog is the new bottleneck — and skepticism is creeping in because we're not even sure our tests are sufficient to verify what the agent built.
• Why TDD Fits This Moment: The honest question isn't "Can I trust the agent?" — it's "What verification loop do I need to build so I can trust it more?" Clear requirements feed a clear testing loop: write the failing test, let the agent write the code to turn it green, and you bridge the gap between requirements gathered and requirements met. It's not as simple as "go write a test," but it's a strong fit for where we are right now.
• Episode Homework: Go dig into the fundamentals — limiting WIP, the theory of constraints, test-driven development. Find the old lesson that still applies to your workflow today, bring it to your team's flow, and email me about what you discover.

Your coding agents probably have access to your codebase — and maybe your tools and MCPs too — but access doesn't mean context. Agents don't know your architectural decisions, your team's patterns, or why your API is shaped the way it is, so Claude ends up building a new model when it should have changed an existing one, and you're left clawing back bad outputs and burning tokens on correction loops. Unblocked is the smart context layer your agents are missing. Instead of dumping everything into a giant context window, it builds reasoning over shared context — turning code, docs, tickets, and conversations into actionable context so engineers move faster, agents make better plans, write higher quality code, use fewer tokens, and need fewer corrections. If you're running Claude Code, Cursor, or any agentic workflow, go check it out. Free three-week trial at getunblocked.com/developertea.

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.

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!

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.

If you're enjoying the show and want to support the content head over to iTunes and leave a review!

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.

If you've been following along with our recent focus on durable skills, you know we've been hunting for the abilities that translate beyond this month, this year, or whatever AI does to our industry next. Today's skill doesn't have a tidy name you can search for — it's softer than that. Jonathan calls it "principle-oriented thinking": the habit of deconstructing the labels we put on things to understand their core components, properties, and capabilities. It's how NASA engineers turned a sock into a water filter on Apollo 13, and it's how forward-thinking engineers are reframing what AI can actually do rather than jamming it into a predetermined slot.

• Labels Are Useful Shortcuts — Until They Aren't: Every label, from "software engineer" to "sock," carries baggage, heuristics, and presupposition. That's not a flaw — labels are how we move through the world quickly. But when a label is the only lens you have, it quietly caps how much value you can get out of the thing you're looking at.
• The Apollo 13 Sock: When the crew needed to fix a life-threatening problem with mismatched parts, the engineers on the ground had to forget what a sock was for and ask what it actually is — a piece of cloth with tensile strength, flexibility, and filtering properties. Strip the assumption that it goes on a foot, and a whole new set of uses opens up.
• Stop Slotting AI Into Old Roles: The common move is to take one responsibility — coding, debugging, refactoring — hand it to an agent, and keep everything else the same. That works, but it's low-leverage. The more powerful approach starts by asking what the agent is fundamentally capable of, then rebuilding the workflow around those raw materials.
• See Things as Materials, Not Fixed Functions: When you deconstruct out from under a label, tools and concepts start to look like craftable raw materials. You can then combine them in new, valuable ways they haven't been combined before — alloying old methods with new capabilities to create properties neither had on its own.
• Reason From Properties, Not Personas: Ask what the actual properties of an LLM are. Non-determinism isn't a bug to apologize for — it's a property you can exploit. The existence of many different models is a property too, which is exactly what makes adversarial review possible. That's principle-oriented thinking applied to agents.
• Extend the Latticework: Charlie Munger talked about a latticework of mental models that weave together rather than sit in isolation. The durable skill isn't quarantining your concept of "AI" off to the side — it's grafting a new section onto the existing tapestry and letting it reshape everything you already understood.
• Episode Takeaway: Look at how you spend your time and ask new questions of it. What is the material here? What kind of thinking does the agent actually do? What can a human do that an LLM can't — and the other way around? That's how you avoid believing a sock is only ever good for a foot.

Your coding agents have access to your code, your repos, and probably a pile of connected MCPs filling up their context — but access isn't the same as good context, and a bloated context window can actually degrade the very reasoning you're relying on. Agents don't know your architectural decisions, your team's patterns, or why an API was shaped the way it was, so they look in the wrong place and deliver bad outputs you then spend time and tokens correcting. ● Unblocked is the smart context layer your agents are missing. ● Instead of ingesting everything and getting lost, it builds reasoning over shared context. ● It turns code, docs, tickets, and conversations into actionable context — so engineers move faster, agents make better plans and write higher-quality code, and you burn fewer tokens and fewer correction loops. If you're running Claude Code, Cursor, or any agentic workflow, it's worth a look. A free three-week trial is available at getunblocked.com/developertea.

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.

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!

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.

If you're enjoying the show and want to support the content head over to iTunes and leave a review!

A lot of what we've been talking about lately is durable skills — the abilities that last regardless of how our tools and tech environment change. In today's episode, I want to step back from the AI conversation and focus on one of the most durable skills of all: feedback. We've all been on both the giving and receiving side, and we can probably count on one hand the times someone gave us feedback that genuinely drove a good change — that left us wanting to do better without feeling torn down. So how do we accomplish that kind of feedback, on both sides of the table? That's what this episode is all about.

• Start With Your Goal, Not Your Frustration: Before you give feedback, recognize that your gut impulse often comes from a negative emotion — frustration, feeling slighted, feeling disrespected. Those feelings are valid signals that something is off, but they aren't a sufficient reason to give feedback. Effective feedback is goal-oriented: ask yourself what you actually want to change before you say a word.
• Premature vs. Mature Feedback: Premature feedback is really about making sure someone knows how you feel — which can quietly turn into an attack so they share your pain. Mature feedback is forward-looking and aimed at improvement. Venting may give you catharsis in the moment, but if the behavior worsens or the relationship is damaged, the net outcome is negative.
• Why Asking for Feedback Changes Everything: Even hearing "can we meet for ten minutes, I have some feedback" measurably raises your heart rate and pushes you into a defensive state. But when you ask for feedback, your mind and body register that you're in control — same information, completely different physiological response.
• Make It Behavior-Based and Specific: Good feedback is about observable behavior — what a camera would have caught — not someone's core identity. If your feedback violates a person's self-concept (painting a competent engineer as incompetent), they have to change who they believe they are to accept it, and that gap rarely gets bridged in a 30-minute call.
• Use a Model — But Add the Intervention: The popular SBI model (Situation, Behavior, Impact) is a strong backbone, but it stops short. Don't just describe the past — partner with the person on what comes next. Think of it as SBI + Intervention: what can you commit to trying differently so the impact changes? That's where feedback becomes coaching.
• The Netflix Four A's: Aim to assist, make it actionable, show appreciation, and accept or discard. Lead with the intent to help, get specific about the behavior, appreciate the person's willingness and intent, and recognize that not every piece of feedback will be useful — both sides get to keep what's valuable and let the rest go.
• Receiving Feedback Well: When someone hands you messy, un-modeled feedback, you can walk them through the framework — "help me understand the situation, what behavior did you see, what was the impact?" People respect that you're engaging, shift into problem-solving mode, and give you more actionable feedback as a result.
• Episode Homework: Pay attention to patterns over time. One piece of feedback shouldn't be attached to your identity — but three or four that point in the same direction are worth introspecting on. Career development and feedback are two sides of the same door; walk through it and you grow.

No matter what you're building, SerpApi is the web search API for your needs. If you're building an application that needs real-time search data—whether that's an AI agent, an SEO tool, or a price tracker—SerpApi handles it for you. ● Make an API call and get back clean JSON. ● They handle the proxies, CAPTCHAs, parsing, and all the scraping so you don't have to. ● They support dozens of search engines and platforms, and are trusted by companies like NVIDIA, Adobe, and Shopify. ● If you're building with AI, they even have an official MCP to make getting up and running a simple task. Get started with a free tier to build and test your application before you commit. Go to serpapi.com.

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.

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!

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.

If you're enjoying the show and want to support the content head over to iTunes and leave a review!

Right now, the questions we have about our careers feel existential. We keep coming back to the same theme: how do you prepare for an industry that's changing this fast, and what mindset actually works in this new reality? One skill keeps surfacing as the answer — your ability to update your own mental models. In today's episode, I want to push on that further and put some of software engineering's most beloved thinking models under scrutiny. Some of these models served you well for years. Some of them now deserve to be challenged, replaced, or thrown out entirely — and learning how to tell the difference is itself the skill that will determine whether you hit a ceiling.

• Move Past "So What" Questions: The typical engineering objection to agentic coding is that it produces quality issues. But the people deciding to adopt these tools already accept that. Our job is to stop arguing the surface-level point and start asking the real one: so what do we actually do about this new economic reality?
• The Economics of Acceptable Loss: Abstraction always leaves something to be desired. An agent's code may not match what a staff engineer produces by hand over months — but that gap is usually an acceptable trade against shipping something two, three, or four times faster. Understand the cost-benefit picture instead of pretending the cost doesn't exist.
• Abstraction Has Always Done This: This isn't new. The calculator dissolved the specialization once required for complex math. Spreadsheets commoditized ledgering and accounting. Agentic coding is the same pattern arriving for our work — making something that required deep specialization suddenly far more accessible.
• Roles Are Blurring: As these generic tools raise everyone's ability to abstract, the boundaries soften. You're already seeing product managers open pull requests and engineers making product decisions. The neat lines around "what an engineer is" are not as fixed as they used to feel.
• Why Your Hard-Won Wisdom Is the Target: If you've spent years in this industry, your models were bought with blood, sweat, and failed projects. That experience is real wisdom — and it's exactly what I'm asking you to be willing to challenge, because the thing that always worked for you is the thing most likely to become a ceiling.
• This Skill Survives Either Way: Even if you think AI is mostly hype and I've been infected by it — fine. The ability to challenge your pre-existing models is a critical skill regardless. It's how you keep growing as you get more senior instead of repeating what used to work.
• Models Are Approximations: The whole point of a model is to approximate the reality around us. That's their value and their limitation. When the underlying reality shifts this dramatically, holding tightly to an old approximation stops being wisdom and starts being a liability.

Your coding agents have access to your codebase and probably a lot more — tools connected through MCPs, skills, and more. But access isn't the same as context. Agents aren't great at reasoning across MCPs, and they don't know your architectural decisions, your team's patterns, or why your API is shaped the way it is. So they look in the wrong place and deliver bad outputs, and you burn time and tokens correcting them. ● Unblocked is the smart context layer your agents are missing. ● Instead of dumping tons of data into a giant context window and getting lost, it builds reasoning over shared context. ● It turns code, docs, tickets, and conversations into actionable context, so engineers move faster and agents make better plans, write higher quality code, use fewer tokens, and need fewer correction loops. ● If you're running Claude Code, Cursor, or any other agentic workflow, it's worth a look. Get a free three-week trial at getunblocked.com/developer-tea.

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.

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!

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.

If you're a software engineer right now, you likely feel like your world is changing overnight. We are writing half or less the amount of code that we wrote even a year ago, which represents a seismic, groundbreaking shift in our industry. For many of us, this career has always been engaging for deeply creative and intellectual reasons—and that excitement is still here. But our mental models of what it means to be a good engineer, and what it means to keep improving, have gone a little stale. In today's episode, I want to talk about a distinction that I believe will become the cornerstone mistake for seasoned engineers: confusing _practice_ with _adaptation_, and leaning on the wrong one at the worst possible moment.

• Two Surfaces Coming Into Contact: Picture your knowledge, skills, and toolset as one surface, and the actual state of the art as another. We've always known the surface area we could learn far exceeds what we can learn, which forces us to place bets on a learning strategy. What's changing is how fast that second surface is moving underneath us.
• Improvement by Practice vs. Improvement by Change: Practice is wielding what you've already adopted—smoothing out errors, building muscle memory, refining what you already know. Adaptation is fundamentally folding something new into your repertoire. Both are real forms of improvement, but they are not interchangeable.
• The Cornerstone Mistake for Senior Engineers: Later in your career, the time you spend adapting naturally goes down as you settle into practice. The biggest error I'm already watching engineers make is moving too quickly toward practice when the industry is loudly calling for adaptation instead.
• Inspect and Adapt—at the Right Altitude: Sprint retros were never really about getting marginally better at the thing you already do. The intent of "inspect and adapt" is to step up one level and examine the system. The trap is treating adaptation like a minor refinement—getting a little better at prompting—when it should mean asking whether you're thinking about prompting in the wrong way entirely.
• Question the Ratio, Not Just the Output: Real adaptation looks like asking whether you have the right mix of human and agent on a problem. Are you leaning on the agent for things you shouldn't, or failing to lean on it for the things you should? Have you genuinely thought about how sub-agents or an agent team are working the problem you're producing?
• A Spectrum, Not a Binary: On one end, you make micro-adjustments to your refinement process. On the other end of experimentation, you ask whether refinement—or even having engineers plan the work—is the right thing at all. The point isn't that practice is dead; it's that the industry is changing fast enough that the adaptive end of that spectrum deserves far more of your attention than it used to.
• Episode Homework: Take something you currently treat as a practice problem—"how do I refine tickets faster?"—and step up a level. Ask the adaptive version of the question instead: "Is refinement even the right thing anymore?"

No matter what you're building, SerpApi is the web search API for your needs. If you're building an application that needs real-time search data—whether that's an AI agent, an SEO tool, or a price tracker—SerpApi handles it for you. ● Make an API call and get back clean JSON. ● They handle the proxies, CAPTCHAs, parsing, and all the scraping so you don't have to. ● They support dozens of search engines and platforms, and are trusted by companies like NVIDIA, Adobe, and Shopify. ● If you're building with AI, they even have an official MCP to make getting up and running a simple task. Get started with a free tier to build and test your application before you commit. Go to serpapi.com.

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.

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!

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.

If you've heard that your job in the agentic coding era is to "become a manager of agents," you may have noticed something doesn't quite fit. Most of us never trained to be managers, and frankly, that's not the role most engineers want. In today's episode, I unpack what that shift _actually_ means — it's closer to a tech lead or architect mindset — and zoom in on a specific interviewing and on-the-job skill that will help you stay employable: how you think about, talk about, and take ownership of failure.

• Don't Just Bring Star Stories — Bring Failure Stories: Interviewers don't only want to hear how you succeeded. They want to know what you do when the pressure's on and things fall apart. If every story you tell is a highlight reel, there's a built-in social signal that you're hiding something. Get comfortable telling the other kind of story.
• Identify the Real Problem, Not the Proximal One: The most common failure story I hear in interviews is "the knowledge transfer was bad" or "the docs weren't good." That's not wrong — it's just incomplete. The senior mindset asks why that happened. Why didn't we have docs? Why was context insufficient? Walk it back until you hit something actionable but not too abstract.
• The Systemic Diagnosis is the Leveled-Up Answer: Fixing the proximal cause fixes this instance. Fixing the root cause fixes the system that keeps producing instances like this. When you connect what you learned to a systemic adjustment, you stop sounding like someone who survived a bad project and start sounding like someone who improves the organization around them.
• Ownership Means Owning the Outcome, Not the Task: Use the homeowner metaphor. A homeowner doesn't personally fix every leaking pipe — but the outcome of the home is theirs. As an engineer, your scope of ownership has expanded dramatically in the agentic era. You're now responsible for outcomes of code you may not have even read, and the deciding skill is how you carry that responsibility.
• The Word to Pair With Ownership is Relentlessness: Not in an anxious, burn-yourself-out way. Relentlessness means following a thread to its natural end — through escalation, through asking the next question, through finding the right person if it's not you. It's the antidote to "I'll let someone else handle it" syndrome.
• You Don't Have to Do It All Yourself: Relentless ownership is not "carry every task across the finish line personally." If you're not qualified, the owner's job is to find who is, communicate risk to stakeholders, and keep the trail alive until the outcome is resolved. That's the differentiator between a senior thinking engineer and a junior one working through assigned tickets.
• Failure Is Usually a Lapse in Ownership: If you make a list of five things you've failed at (and you should), you'll often find the through-line isn't lack of skill — it's that you stopped escalating, stopped following up, stopped staying with the thing until it was actually resolved.
• Episode Homework: Write down five real failures. For each one, ask: where did I stop being relentless? What system produced this outcome — and what would I change upstream next time?

No matter what you're building, SerpApi is the web search API for your needs. If you're building an application that needs real-time search data—whether that's an AI agent, an SEO tool, or a price tracker—SerpApi handles it for you. ● Make an API call and get back clean JSON. ● They handle the proxies, CAPTCHAs, parsing, and all the scraping so you don't have to. ● They support dozens of search engines and platforms, and are trusted by companies like NVIDIA, Adobe, and Shopify. ● If you're building with AI, they even have an official MCP to make getting up and running a simple task. Get started with a free tier to build and test your application before you commit. Go to serpapi.com.

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.

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!

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.

What happens when you discover that a book that fundamentally changed how you think is built on a shaky foundation? In today's episode, I share my own struggle with the replication crisis surrounding Daniel Kahneman's *Thinking Fast and Slow*, and I use it as a springboard to talk about a much bigger skill: knowing how to update your beliefs when reality shifts underneath you. This isn't about throwing out science or losing trust in your heroes. It's about developing the muscle to replace old explanations with better ones — a skill that has never been more important for software engineers.

• The Replication Crisis, Briefly Explained: Understand the difference between reproducing a study (re-running the analysis on the original data) and replicating one (recreating the study from the ground up), and why a surprisingly large portion of well-respected psychology research, including studies cited in Thinking Fast and Slow, doesn't hold up under scrutiny.
• Base Rates Matter: Kahneman didn't pick uniquely bad studies. If you randomly sampled from the broader academic literature, you'd hit the same failure rate. The lesson isn't about one author — it's about how we evaluate any body of knowledge.
• The Beginning of Infinity Framework: Drawing from David Deutsch's book, explore the idea that all progress is rooted in the assumption that we are fundamentally incorrect, and that improvement comes from continually building better explanations on top of incomplete ones.
• Beliefs as Calibration, Not Truth: Your beliefs about what makes a good engineer, what makes good code, or what makes a good career move are not eternal truths. They are calibrations to your current reality, and that reality is changing fast.
• The Ego Trap of Old Beliefs: Notice the very human, very subtle pull to defend things you previously argued for — not because they're still right, but because admitting otherwise creates a discontinuity with your former self. This is one of the biggest blockers to learning.
• Two Competing Explanations of AI Adoption: Walk through a worked example of holding two predictions about AI in tension and asking honestly which one better explains the reality you're seeing — at both a macro industry level and the micro level of debugging a system.
• Moving Goalposts Aren't a Conspiracy: A lot of what feels like shifting goalposts in our industry is just goalposts moving on their own. A big part of our job as engineers is figuring out where they are now and predicting where they're heading next.
• Episode Homework: Pick one belief you hold strongly about your work — about what makes a good engineer, about a tool, about a process. Try to deconstruct it into its parts and ask whether a better explanation exists for what you're actually seeing.

No matter what you're building, SerpApi is the web search API for your needs. If you're building an application that needs real-time search data—whether that's an AI agent, an SEO tool, or a price tracker—SerpApi handles it for you. ● Make an API call and get back clean JSON. ● They handle the proxies, CAPTCHAs, parsing, and all the scraping so you don't have to. ● They support dozens of search engines and platforms, and are trusted by companies like NVIDIA, Adobe, and Shopify. ● If you're building with AI, they even have an official MCP to make getting up and running a simple task. Get started with a free tier to build and test your application before you commit. Go to serpapi.com.

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.

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!

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.

• Why I'm Not "Picking a Fight" on AI: A listener asked if I'm intentionally stoking a flame war by treating agentic coding as a foregone conclusion. The honest answer is that I've used it, the data points one direction, and a show built around pretending otherwise would slowly drift away from reality — and away from being useful to you.
• Respecting the Misgivings, Without Getting Stuck in Them: Ethical concerns, skill atrophy worries, and questions about long-term effects are all legitimate. But the goal of this show is practical applicability, so we focus on mental models you can use Monday morning rather than litigating every angle of the debate.
• The "Minecraft" Principle: If I ask you to "build Minecraft," I've handed you several chapters of specification in a single word. That's meaning-rich abstraction — language that points at a huge amount of shared context with very little token cost.
• Meaning-Rich AND Specific: "Human history" is meaning-rich but uselessly broad. "Block-building game" is specific but loses fidelity. The sweet spot is vocabulary that is both compact and unambiguous — sitting in the top right of the meaning-density / specificity graph.
• A Real Example — Strategy Pattern: When working on authorization rules, I didn't want a pipeline. Instead of describing base classes, shared interfaces, and parallel execution to the LLM, I used the words "strategy pattern." Three words did the work of three paragraphs, and the output landed where I wanted it.
• Vocabulary as Leverage: Named patterns, named algorithms (Monte Carlo, etc.), named architectural concepts — these act like compressed pointers. The more of them you genuinely understand, the higher the leverage of every prompt you write and every conversation you have with another engineer.
• How to Build This Vocabulary: Have conversations with senior engineers. Ask an LLM what patterns are at play in a codebase, which ones you're using incorrectly, and which ones you're tricked into thinking you're using. Learn the abstraction layer that sits one step above your day-to-day implementation work.
• The Asterisk — Shared Context Required: This only works when both sides know the term. Public, well-documented concepts (patterns, papers, algorithms) translate immediately to LLMs. Private or organization-specific concepts need to be loaded into context — via CLAUDE.md, AGENTS.md, or skills — before that compression kicks in.
• Episode Homework: Pick one area of your current codebase. Ask an LLM to name the patterns in play, the patterns you're using incorrectly, and the ones you might be missing. Use that conversation to add at least one new piece of meaning-rich vocabulary to your working set.

Your coding agents have access to your code base — and probably more — but access isn't the same as context. Agents can't reason well across MCPs on their own, they don't know your architecture decisions, and they don't know which docs are reliable versus written by someone in their free time two years ago. ● Unblocked is the context layer your agents are missing. ● It synthesizes your PRs, docs, Slack messages, and Jira issues into organizational context that agents actually understand. ● That means better plans, higher quality code, fewer tokens, and fewer correction loops. ● Whether you're running Claude Code, Cursor, Codex, or any agentic workflow, it's worth a look. Get a free three-week trial at getunblocked.com/developertea.

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.

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!

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.

• The Coding-Is-My-Value Trap: For years, we've treated the ability to write code as the flagship skill of software engineering. It's concrete, it's teachable, it's the thing big box stores sell kits for. But conflating "what I enjoy about the job" with "what I'm actually valuable for" is dangerously reductive — and AI is now exposing that gap.
• The Skills You've Been Discounting: Domain expertise, systems thinking, risk and bottleneck analysis, organizational design, tech-lead-level sequencing of work, relational skills that unblock hard moments in a company's life. These have always been where a lot of your real value lived. You probably just weren't writing them down.
• The Three-Part Framework — Valuable, Durable, Transferable: A skill worth investing in hits as many of these as possible. Valuable means it meets a clear business need. Durable means it survives industry shifts. Transferable means it applies across domains and scales up as you grow more senior.
• What "Durable" Actually Means: Ask yourself: what would have to change for this skill to become obsolete? Coding, on its own, has a lower durability answer than it used to. Relationship building, architectural thinking, and the ability to reason about complexity require much bigger shifts before they stop mattering.
• Transferability Is Vertical, Not Just Lateral: Don't just ask whether a skill moves across industries. Ask whether it keeps paying off as you move into more senior, higher-leverage roles. Soft skills, systems thinking, and mental models like compound interest compound themselves the further up you go.
• Episode Homework: Make your own list. Which of your skills are valuable, durable, and transferable? Every engineer's list looks different — and the ones you've been quietly discounting are often the ones that matter most going forward.

Your coding agents have access to your codebase — but access isn't context. They don't know your architectural decisions, your team's patterns, or why the API was shaped the way it was. So they look in the wrong places and deliver bad outputs, and you burn time and tokens correcting them.
● Unblocked is the context layer your agents are missing.
● It synthesizes your PRs, docs, Slack messages, Jira issues, and more into organizational context agents actually understand.
● Better plans, higher quality code, fewer correction loops, fewer tokens spent.
● Works with Claude Code, Cursor, and any agentic workflow. Get a free three-week trial at getunblocked.com/developertea.

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.

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!

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.

If you're enjoying the show and want to support the content head over to iTunes and leave a review!

If you're an engineering leader right now, everything around you feels like it's changing at once — new tools, new processes, new expectations. It's tempting to accept chaos as the new normal, but in today's episode, I make the case that your job is to go on the offense and *create* order. Not by clinging to old processes, but by becoming the groundskeeper of your team's ceremonies — the regular, repeated actions that give your team a foundation to actually improve from.

• Humans Are the Limiting Factor (And That's Okay): Our fundamental cognitive capabilities haven't changed in tens of thousands of years. Progress is collective — better tools, better documentation, better knowledge systems — but individually, our brains work the same way they always have. Any process that involves humans has to account for this.
• Why Ceremony Matters More Than Ever: Whether you call them scrum ceremonies, team rituals, or just "the way we work," regular and repeated team actions aren't bureaucratic overhead. They're how humans learn, build comfort, and reduce cognitive load. Just like sitting in the same seat at your coffee shop or driving the same route to work, repeated patterns free up mental energy for the things that actually require your attention.
• Regularity of Action Over Specific Process: This isn't a prescription for scrum or kanban or any particular framework. The point is that your team has some determined, repeated way of doing things — whether that's a weekly planning session, a daily standup, or a trigger-based refinement process. The specific process matters less than the consistency.
• Ceremony Enables Experimentation: If you want to get better, you need to be able to change one variable at a time and measure the result. That's impossible when everything is changing at once. Holding your core processes steady gives you the controlled environment you need to actually learn what's working and what isn't.
• Spot the Anomalies: When you maintain regularity, deviations become visible. If productivity dips but your ceremonies stayed constant, you have a much better shot at diagnosing what actually changed. Without that baseline, every signal gets lost in the noise.
• Episode Homework: Sit down with your team this week and talk about what your ceremonies are. What do you want to hold constant? What do you want to be true on a regular basis? Name them, write them down, and commit to tending them — even as everything else shifts around you.

No matter what you're building, SerpApi is the web search API for your needs. If you're building an application that needs real-time search data—whether that's an AI agent, an SEO tool, or a price tracker—SerpApi handles it for you. ● Make an API call and get back clean JSON. ● They handle the proxies, CAPTCHAs, parsing, and all the scraping so you don't have to. ● They support dozens of search engines and platforms, and are trusted by companies like NVIDIA, Adobe, and Shopify. ● If you're building with AI, they even have an official MCP to make getting up and running a simple task. Get started with a free tier to build and test your application before you commit. Go to serpapi.com.

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.

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!

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.

Your tool set isn't just a collection of utilities — it's the environment you live in every day, and it's shaping you whether you realize it or not. In today's episode, I explore two principles that senior engineers consistently apply to their workflows, regardless of which specific tools they're using. As our industry goes through one of the most rapid periods of change in the last 20 years, the engineers who thrive won't be the ones chasing every new tool — they'll be the ones who obsess over reducing friction in the work they do most often.

• Honor the Grief: Many engineers are experiencing a real sense of loss as the deep cultural connections to languages, communities, and hand-written code begin to shift. Recognizing and processing that grief — rather than letting it turn into reflexive rejection of new tools — is essential to thinking clearly about what comes next.
• "We Shape Our Tools, Then Our Tools Shape Us": Your tools aren't neutral. A bad monitor height, a faulty keycap, or a clunky deployment process all shape you back — draining focus, breaking flow, and compounding over time. The most senior engineers treat this relationship as a first-class concern.
• Principle 1 — Tools Are Your Environment: There's a spectrum from "tool" to "environment," and most of what you work with sits somewhere in between. Your terminal, your desk, your claude.md file — all of these are environment. Sharpening your tools means shaping your environment, and shaping your environment is sharpening your tools.
• Friction Is the Lever: You don't need a dramatic overhaul to change your behavior. Tiny reductions in friction — a two-letter alias, a key binding to run tests, setting your shoes out the night before — have an outsized effect on how often you actually do the things you want to do. James Clear's Atomic Habits framework applies directly to engineering workflows.
• Principle 2 — First Order Thinking: Borrowed from Adam Savage's concept of "first order retrievability," the idea is simple: identify what you do most often and invest in making that better. Not faster, not just automated — better. If you do something a hundred times a day, even a small improvement compounds dramatically.
• Invest in the Fundamentals: Your standups, your one-on-ones, your specifications, your prompting skills — these are the repetitive, high-frequency activities where your biggest growth opportunities live. Stop assuming you've "arrived" on the basics just because nobody is giving you negative feedback.
• Episode Homework: Look around your workspace right now — physical and digital. Identify one thing you do repeatedly where friction is slowing you down or discouraging follow-through, and make one small change to reduce that friction today.

No matter what you're building, SerpApi is the web search API for your needs. If you're building an application that needs real-time search data—whether that's an AI agent, an SEO tool, or a price tracker—SerpApi handles it for you. ● Make an API call and get back clean JSON. ● They handle the proxies, CAPTCHAs, parsing, and all the scraping so you don't have to. ● They support dozens of search engines and platforms, and are trusted by companies like NVIDIA, Adobe, and Shopify. ● If you're building with AI, they even have an official MCP to make getting up and running a simple task. Get started with a free tier to build and test your application before you commit. Go to serpapi.com.

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.

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!

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.

If you're enjoying the show and want to support the content head over to iTunes and leave a review!

• When Good Thinking Becomes Overthinking: Discover why the pursuit of perfect analysis often undermines good decision-making. Loading every caveat, every exception, and every alternative into your working memory doesn't produce better outcomes — it produces paralysis.
• Heuristics as a Feature, Not a Bug: Your brain is an efficiency machine that creates shortcuts — cached concepts, stored routines, snap judgments. These heuristics are always incomplete, but they let you move through complex problems quickly. The opportunity is to deliberately choose which heuristics to exploit.
• "All Models Are Wrong, Some Models Are Useful": Useful illusions don't need to be perfectly true. They need to be true enough that acting on them produces better outcomes than endlessly debating their accuracy.
• Useful Illusion: Coding by Hand Is Going Away: Whether or not this is literally true in every case, the engineer who acts as if it is will invest in agentic workflows, LLMs, and new tooling — while the engineer who picks the argument apart risks being labeled a skeptic and falling behind.
• Useful Illusion: Hard Work Pays Off: You can poke holes in this all day — wrong direction, burnout, culture-dependent — but people who follow this heuristic tend to build reputations as reliable and capable. Few of us want to be known for the opposite.
• Useful Illusion: As Long As I'm Learning, I'm Growing: Learning becomes less directly correlated with career advancement over time, but continuing to act on this belief keeps you flexible, curious, and in a growth mindset.
• More Useful Illusions for Your List: Clean code is better. Always think about the user's experience. Go with the tool you know. Volume of delivered work correlates with career success — especially during performance review season.
• The Key Insight: You don't have to believe any of these things literally. You're exploiting your own heuristic system to drive efficient action and avoid wasting time on low-utility debates. The result is a more decisive, action-oriented version of yourself.

Your coding agents have access to your codebase, but access doesn't mean good context. Agents can't easily reason across MCPs without guidance — they don't know your architectural decisions, your team patterns, or what that acronym actually means. Unblocked is the context layer your agents are missing. It synthesizes your PRs, docs, Slack messages, and JIRA issues into organizational context so agents make better plans, write higher quality code, use fewer tokens, and require fewer correction loops. Get a free three-week trial at getunblocked.com.

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.

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!

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.

• The Bottleneck Is Moving: Borrowing from traditional manufacturing theory, the coding step used to define your team's total throughput. AI tooling hasn't incrementally improved that bottleneck — it has drastically shrunk it, which means the constraint is now upstream in product decisions, specifications, and prioritization. Engineers who recognize this shift early will redirect their energy accordingly.
• Sharing Your Opinion Is Not a Free Action: Every time you weigh in on a decision, you're making a transaction. You're asking others to consider your input, and in return, they will update their beliefs about your judgment based on whether you turn out to be right. This means your credibility is a finite resource that appreciates or depreciates over time.
• Trap #1 — Arguing About Things You Don't Care About: Engineers often feel an intellectual itch to engage when they hear an argument they disagree with, even when the outcome doesn't matter to them. If the only utility of sharing your opinion is your own self-satisfaction, the risk to your social capital almost never justifies the reward. Pick your battles so that when something does matter to you, people actually listen.
• The Watchful Waiting Approach: If you predict a decision will lead to a bad outcome, sometimes the most effective move is to wait and let the result speak for itself. You get the learning for free without putting your reputation on the line — especially for decisions outside your core responsibilities.
• Trap #2 — Arguing on the Wrong Axis: When you do engage, make sure your argument is aligned with what the decision-maker actually cares about. A product manager asking engineers to delay optimization work is not going to be moved by arguments about on-call load. An engineering manager introducing a systems design interview won't be swayed by the fact that you personally dislike them. If your reasoning doesn't connect to their criteria, it lands as noise.
• Naive Realism and the Alignment Fix: We all default to believing our perspective is the balanced, unbiased one. This tendency causes us to assume anyone who disagrees must be missing information. The fix is to start by understanding what the other person is optimizing for. Once you know their criteria, you can either recognize their decision is perfectly reasonable — or reframe your argument in terms they actually care about.
• The One Takeaway: Understand what the other person wants, what they care about, and why. Decision-making in a collaborative environment is fundamentally negotiation, and the best negotiators optimize for multiple axes rather than treating every disagreement as zero-sum.

Your coding agents have access to your codebase, but access doesn't equal context. Agents can't reason across MCPs — they don't know your architectural decisions or why the API is shaped the way it is — so they look in the wrong place and deliver bad outputs. Unblocked is the context layer your agents are missing. It synthesizes your code, PRs, docs, Slack messages, and Jira issues into organizational context that agents actually understand, so they make better plans, write higher quality code, and use fewer tokens. Get a free three-week trial at getunblocked.com/developertea.

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.

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!

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.

• The Power of Physical Checklists: Inspired by aviation, Atul Gawande's The Checklist Manifesto, and Daniel Kahneman's Noise, I've been experimenting with printed, physical checklists for repetitive tasks — from producing this show to running one-on-ones. The rigor of writing precise procedures carries over into clearer communication with both humans and AI agents.
• Small Interventions, Big Returns: A Brother P-Touch label maker. Reorganizing scattered hobby gear. 3D printing organizational tools with a new Bambu Labs P1S. None of these are revolutionary on their own, but the compounding effect of better organization — essentially building a fast index for your physical life — pays back over and over.
• Context Shapes Focus: Switching from a home gym to working out at Planet Fitness with my brother-in-law was one of the best focus interventions I've made. The change in environment eliminated the procrastination and context-blending that came from being steps away from my computer. If you're struggling with a habit, sometimes the environment is the variable to change, not your willpower.
• The Reading List: Good Strategy, Bad Strategy by Richard Rumelt (and its follow-up The Crux), The Art of Action by Stephen Bungay (a great framework for thinking about agentic workflows), How to Know a Person by David Brooks, and my top recommendation: 4,000 Weeks by Oliver Burkeman — a book that will help you stop looking for the productivity hack that fixes everything and start thinking about what actually matters.
• Learning as a Habit: Right now I'm learning to drive a stick shift on a 1983 Bronco. The point isn't the skill itself — it's staying in the beginner's seat. Intentional practice, setting small goals, refining through repetition. Keeping this habit alive is more important than ever when the industry demands rapid adaptation.
• How I'm Actually Using AI: Claude Code for one-shotting tools with clear boundaries, local environment improvements, and terminal troubleshooting. OpenClaw for experimental agents like a personalized trip planner and Home Assistant automations via YAML. Claude Co-Work for file system management and screenshot organization. Obsidian as the connective tissue — a markdown knowledge base that gives AI agents personal context to work with. And at work, spec-driven development is showing real promise for shaping agent output quality.
• A Framework for Thinking About AI's Role: I break AI use cases into categories: automating existing workflows (where most gains are today), operational restructuring (what happens when you free humans from a task), execution of complex technical work (agents on the front lines), iterative consulting on intent and goals, and the emerging frontier of exploratory connections and strategic synthesis.
• What You Should Actually Do: Be action-oriented — the cat is out of the bag. Invest heavily in planning and specification before sending agents off to work. But more importantly, invest in mindful change: understand your own values, figure out who you want to be when you look back on this moment in 10 years, and let that guide your decisions about adoption, learning, and career direction.

If you're building an application that needs real-time search data — whether that's an AI agent, an SEO tool, or a price tracker — SerpApi handles it for you. Make an API call, get back clean JSON. They handle the proxies, CAPTCHAs, parsing, and all the scraping so you don't have to. They support dozens of search engines and platforms, and are trusted by companies like NVIDIA, Adobe, and Shopify. If you're building with AI, they even have an official MCP to make getting up and running a simple task. Get started with a free tier at serpapi.com.

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.

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!

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.

If you're enjoying the show and want to support the content head over to iTunes and leave a review!

If you're a software engineer right now, you likely feel like your world is changing overnight. We are writing half or less the amount of code that we wrote even a year ago, which represents a seismic, groundbreaking shift in our industry. However, the rapid introduction of new tools can slide quickly from exciting to purely chaotic, leaving you feeling like you are falling behind. In today's episode, I explore how this changes the nature of our day-to-day work, and why the key to surviving this transition is shifting your mindset from a traditional "Software Engineer" to an "Agent Manager".

• The Illusion of Velocity vs. Actual Chaos: While the big-picture promise of AI is that the software development pipeline will move exponentially faster, the reality on the ground often feels like unadulterated chaos. Trying to adopt every new tool while spinning up multiple agents to work on parallel tickets introduces a massive new cognitive burden.
• The Context-Switching Trap: Understand why parallelizing agent workflows fundamentally changes your context-switching overhead. You are no longer just reloading context to build something yourself; you are reloading it to manage, review, and validate a building agent, which rapidly drains your cognitive ability and leads to burnout.
• The "Agent Manager" Mindset: Treating AI as just a "smart autocomplete" while you try to do the same old job will not work. You need to start viewing your role more like assembly line or process management, focusing on facilitating the system rather than typing every line of syntax.
• Adopt Old-School Quality Control Tactics: Discover how traditional management methods are becoming essential for individual contributors. Just like a factory manager doesn't inspect every single item off the line, you must develop methods for spot checks, anomaly detection, and standardizing outputs to evaluate the quality and quantity of your agents' work.
• Shift Your Work Upfront: Recognize that your core effort must move to the specification and planning phases. Your job is increasingly about setting the context, defining the prompt, and establishing strict guardrails before the agent begins its work.
• Redefining Your Work in Progress (WIP): Proven principles like limiting WIP and focusing on finishing rather than starting are more important than ever to reduce cognitive burden. However, you must adapt these principles to fit a workflow where you are managing processes rather than manually coding.
• Episode Homework: Take a step back and ask yourself: "What is my true work in progress? Am I actually manually doing these tickets, or am I managing the processes that produce quality ticket work?".

No matter what you're building, SerpApi is the web search API for your needs. If you're building an application that needs real-time search data—whether that's an AI agent, an SEO tool, or a price tracker—SerpApi handles it for you. ● Make an API call and get back clean JSON. ● They handle the proxies, CAPTCHAs, parsing, and all the scraping so you don't have to. ● They support dozens of search engines and platforms, and are trusted by companies like NVIDIA, Adobe, and Shopify. ● If you're building with AI, they even have an official MCP to make getting up and running a simple task. Get started with a free tier to build and test your application before you commit. Go to serpapi.com.

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.

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!

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.

If you're enjoying the show and want to support the content head over to iTunes and leave a review!

AI is bringing massive changes to our industry, but it's not just about how fast you can write code or use agentic flows. In this episode, I explore how AI is fundamentally shifting the economic bottleneck of software development, and how you can use your systems-thinking engineering mindset to adapt and thrive in this new era.

For years, the software development pipeline was designed around one core assumption: engineering is the most expensive and restrictive bottleneck. Because of this, organizations optimized heavily for upstream risk mitigation to ensure we only built what was absolutely necessary. But AI is changing that math, making the act of coding significantly cheaper and faster. Here is what happens when that bottleneck breaks:

• The Historical Cost of Bugs: I look back at the Windows 95 era, where physical software delivery meant post-release bugs were incredibly expensive, demanding massive upfront QA.
• The Continuous Delivery Precedent: Discover how the internet made software updates cheap, which fundamentally changed the ROI of risk mitigation and enabled fast, iterative soft releases.
• The Upstream Shift: Understand why, as engineering throughput increases by 50% to 100% due to AI, the new organizational bottlenecks will rapidly shift upstream to product, design, and decision-making.
• Optimizing for Speed Over Risk: Learn why companies will likely begin to lessen their focus on risk mitigation (outside of catastrophic data breaches) to prioritize higher volume throughput and decision speed.
• The New Iterative Workflows: Explore the potential for consolidated roles where engineers, PMs, and designers use AI to make rapid, on-the-fly product decisions together without traditional hand-offs.
• Your Core Engineering Value: Remember that punching cards or manually managing memory didn't define engineers in the past, and manually typing code doesn't define you now. Your true value is your ability to approach problems with a systems-thinking mindset.

Your coding agents have access to your codebase, but access doesn't directly translate into context. Agents often lack the reasoning to understand your architectural decisions, team patterns, or why an API is shaped the way it is—leading to bad outputs and wasted tokens. Unblocked is the context layer your agents are missing. It synthesizes your PRs, docs, Slack messages, and Jira issues into organizational context that agents actually understand so they write higher-quality code with fewer correction loops. Get a free three-week trial at getunblocked.com/developertea.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content, head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

Today, we are tackling the natural tension between the desire to make more money—getting a raise, finding financial stability—and the desire to have meaningful, purpose-driven work.

We are diving into a fantastic listener question from Abdul, a front-end engineer with 10 years of experience who has hit a salary ceiling. He is trying to figure out how to pivot into higher-paying domains like backend or AI without making a risky leap that forces him to start over at the bottom rung.

🎧 Episode Notes: Balancing Money, Meaning, and Skill Transitions

When you hit a wall in your career, it often feels like you have to trade away the work you love just to achieve your financial goals. In this coaching-style episode, we break down Abdul's situation to help you rethink how you navigate financial constraints and career transitions.

• Question Your Assumptions About Money: Discover why "making more money" isn't inherently a bad or vague goal. If your intent is to provide for your family, help elderly parents, and build a risk-mitigating financial buffer, your goal is actually highly instructive and values-driven.

• The Illusion of Static Roles: Learn why job descriptions exist primarily as "skill buckets" to help companies hire. Once you are inside the company, your role is not concrete—it is a fluid spectrum that can shift as you adapt to new technologies.

• Grow Where You Are Planted: Instead of making a massive, unrealistic leap to a completely new role, learn how to organically expand your skill set. Talk to your manager about taking on backend or AI tickets, or trading tasks with coworkers to build new skills without uprooting your career.

• Redefining Financial Necessity: Understand how to evaluate the timeline and "shape" of your financial constraints. If financial necessity is your absolute dominant constraint, you must optimize your strategy specifically for stability and risk mitigation.

📮 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

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 by visiting developertea.com/discord today!.

🧡 Leave a Review

If you're enjoying the show and want to support the content, head over to iTunes and leave a review! It helps other developers discover the show and keeps us focused on what matters to you.

I've been delaying this episode for a long time because the topic is genuinely difficult and, for many of us, scary. AI is threatening not just to our livelihood, but to our sense of self-worth as creators.

In this episode, I don't offer false guarantees about job security. Instead, I frame the problem through the lens of microeconomics and rational incentives to help you understand how to remain employable. We discuss why you must separate your ego from your current skill set and how to position yourself not as a competitor to AI, but as a force multiplier.

• The Hard Truth: I explain why the "abstinence" approach—hoping the industry rejects AI or that it turns out to be a bubble—is a high-risk gamble that is unlikely to succeed.

• Ego vs. Employability: We discuss the difficult mental shift required to disconnect your self-worth from the act of writing code manually, allowing you to adopt new tools without feeling like you are losing your identity.

• The Microeconomics of Your Job: Understand the cold reality that a rational market only pays you if you generate more value than you cost; if AI can do the same task with less risk or cost, the market will choose AI.

• The Non-Zero Sum Game: Learn why the economy isn't a fixed pie. The goal isn't just to survive, but to recognize that the combination of Human + AI can generate more total value than either can alone.

• Multiplicative Value: I challenge you to stop thinking about linear skill acquisition and start thinking like a manager: how can you use AI to multiply your output and become indispensable?

• Accepting Atrophy: We confront the reality that your core coding skills may degrade over time as you rely on AI, and why accepting this trade-off might be necessary for your career survival.

🙏 Today's Episode is Brought To you by:

If you are building an application that needs real-time search results—especially if you are working with LLMs—you know that stale data is a problem. SerpApi is the live web search API for your application.

• Get real-time search results fast, directly in your app as JSON.

• Bridge the gap for LLMs that are locked to a training date.

• Trusted by companies like NVIDIA, Adobe, and Shopify. Get started with a free tier to build your full integration before you commit. Go to serpapi.com

📮 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

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!

🧡 Leave a Review

If you're enjoying the show and want to support the content, head over to iTunes and leave a review!

Do you remember the early days of your career? You likely spent hours coding late into the night, fueled not by a paycheck, but by the sheer joy of building. But somewhere along the way, that intrinsic fire faded, replaced by the extrinsic motivators of Jira tickets, performance reviews, and ultimately the almighty dollar.

In this episode of the Career Growth Accelerator, I explore why this shift happens and how it might be the very thing keeping you stuck. We discuss the "Overjustification Effect"—how getting paid for your passion can actually degrade your performance—and how to reclaim the autotelic personality required to enter a flow state and accelerate your career.

• The Overjustification Effect: Learn why introducing extrinsic rewards (like a salary) for a task you inherently enjoy can weaken or completely replace your intrinsic motivation, eventually making the work feel like a chore.

• The Loss of Flow: Discover how moving from hobbyist to professional changes your relationship with the work, often stripping away the conditions necessary for "flow state," such as risk-taking and immediate feedback.

• Autotelic Personality: Understand the concept of being "autotelic"—doing something for its own sake—and why this trait is critical for high-quality, creative work that pushes your career forward.

• The Stagnation Trap: Recognize that if your only motivation is doing what is required to get paid, you are unlikely to take on the voluntary challenges necessary to grow to the next level.

• Reclaiming Your Drive: I discuss how finding pockets of intrinsic motivation—even if they are ancillary to your main job—can reignite your ability to enter flow, improve your work quality, and break through career plateaus.

🙏 Today's Episode is Brought To you by:

If you are building an application that needs real-time search results—especially if you are working with LLMs—you know that stale data is a problem. SerpApi is the live web search API for your application.

• Get real-time search results fast, directly in your app as JSON.

• Bridge the gap for LLMs that are locked to a training date.

• Trusted by companies like NVIDIA, Adobe, and Shopify. Get started with a free tier to build your full integration before you commit. Go to serpapi.com

📮 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

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!

🧡 Leave a Review

If you're enjoying the show and want to support the content, head over to iTunes and leave a review!

In today's episode, we are discussing one of the most common habits I see in high-performing managers and senior engineers. It isn't a single trick, a morning routine, or a specific productivity hack—it is a meta-habit. It is a specific way of thinking about how you spend your energy and time to avoid the burnout that comes from working hard without seeing commensurate gains,.

• The Burnout Trap: Understand that if you keep putting more energy in without getting equal or greater results out (sub-linear returns), you are heading for a wall. You cannot simply "grind" your way to the next level,.
• Recognize Your Default Loops: Whether you know it or not, you are already running "loops"—automatic heuristics and behaviors that define your decisions, like "while happy at job, stay at job",.
• The Inner vs. Outer Loop: Learn the difference between the Inner Loop (your execution, habits, and daily protocols) and the Outer Loop (the meta-observation that evaluates the system).
• Governing the Experiment: Discover how to use an Outer Loop to set longer-term conditionals for your career experiments (e.g., "I will try this until X"), preventing you from reacting emotionally to single data points,.
• Systematic Evaluation: Move from making random changes to making informed adjustments by stepping out of the daily grind to evaluate the trajectory of your habits,.

There’s a good chance you’ve already tried a few AI code review tools — and you’re probably ignoring most of their comments.

Not because AI can’t review code, but because it’s missing context. Most AI reviewers focus on surface-level issues: style nits, obvious refactors, or restating what’s already clear from the diff. Meanwhile, the things you actually care about, like whether a change violates an earlier architectural decision or quietly duplicates existing logic, go unnoticed.

That’s the problem Unblocked is built to solve.

Unblocked’s AI code review is grounded in decision-grade context, prior PRs, design discussions, documentation, and system-level constraints—the same context senior engineers rely on when reviewing code.

Teams using Unblocked report fewer comments, higher signal, and automated reviews they actually trust — enough that many have turned off other AI review tools entirely.

Even if you’ve already written off AI code review, Unblocked is worth a look.

Get a free three-week trial at getunblocked.com/developertea.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

It is review season, and you might be finding yourself confused: you received high ratings and "exceeded expectations," yet the promotion you expected didn't happen. In this episode of the Career Growth Accelerator, I break down exactly why high performance doesn't always lead to promotion, helping you identify the structural roadblocks and strategic shifts necessary to move from senior individual contributor to staff, principal, or leadership roles,.

• Understand why your performance review is never conducted in a vacuum and why your manager’s peers—not just your manager—are the "voters" you need to convince with clear evidence,.

• Learn why high ratings often fail to translate into a promotion if you haven't demonstrated specific impact on the company's strategic goals rather than just your own deliverables.

• Discover the first major roadblock: Structural limitations where the role you want simply doesn't exist because the business context or organizational pyramid doesn't currently support it,.

• Explore the concept of "Outer Layers" of scope—moving from self-focus to team-focus, and finally to business-strategy focus—to unlock the next stage of your career,,.

• Identify the "indispensable trap" where performing too well at your current inner-layer responsibilities makes you terminal in your role rather than promotable.

There’s a good chance you’ve already tried a few AI code review tools — and you’re probably ignoring most of their comments.

Not because AI can’t review code, but because it’s missing context. Most AI reviewers focus on surface-level issues: style nits, obvious refactors, or restating what’s already clear from the diff. Meanwhile, the things you actually care about, like whether a change violates an earlier architectural decision or quietly duplicates existing logic, go unnoticed.

That’s the problem Unblocked is built to solve.

Unblocked’s AI code review is grounded in decision-grade context, prior PRs, design discussions, documentation, and system-level constraints, the same context senior engineers rely on when reviewing code.

Teams using Unblocked report fewer comments, higher signal, and automated reviews they actually trust — enough that many have turned off other AI review tools entirely.

Even if you’ve already written off AI code review, Unblocked is worth a look.

Get a free three-week trial at getunblocked.com/developertea.

🎥 Subscribe to our Youtube Channel here! https://www.youtube.com/@developertea

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

In this episode, we explore how to de-risk your career roadmap by identifying the hidden vulnerabilities that hold your decision-making hostage.

True career growth requires gaining autonomy over your choices. This episode provides a framework for performing a "pre-mortem" of career failure by identifying the sources of power that currently influence your life and limiting their leverage over your future.

• Identify Your Sources of Power: Perform an exercise to list the people, situations, and physical things (like money or debt) that drive your current decision-making and could shift your behavior if they changed.
• Conduct a Career "Pre-mortem": Use this diagnostic approach to recognize what has the power to change your decisions, helping you prepare for potential failures before they occur.
• Understand the "Hostage" Dynamic: Realize that while some leverage is aligned with your values, other factors—like large amounts of debt—can hold your career hostage, forcing you to make decisions you otherwise wouldn't.
• Balance Vulnerability and Autonomy: Distinguish between healthy vulnerability (such as in relationships with family) and unhealthy vulnerability (such as with creditors), and work to de-risk the latter to reclaim your agency.
• The Link Between Debt and Career Risk: Learn how eliminating financial vulnerabilities, like credit card debt, increases your autonomy, potentially allowing you to take "principled" career risks you previously couldn't afford.
• Re-evaluate Your Non-Negotiables: Use introspection to determine which parts of your job are truly essential and which "imagined" risks are preventing you from seeking better alignment with your personal purpose.
• Shift Your Control Systems: Understand that growth often requires giving up control in one area (like spending habits) to gain control and autonomy in your professional path.

Devs, if you think website builders mean limited control—think again. With Wix Studio’s developer-first ecosystem you can spend less time on tedious tasks and more on the functionalities that matter most: ● Develop online in a VS Code-based IDE or locally via GitHub. ● Extend and replace a suite of powerful business solutions. ● And ship faster with Wix Studio’s AI code assistant. All of that, wrapped up in auto-maintained infrastructure for total peace of mind. Work in a developer-first ecosystem. Go to wixstudio.com.

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.

If you want to be a part of a supportive community of engineers working to improve their lives and careers, join us on the Developer Tea Discord community today!

If you're enjoying the show and want to support the content, head over to iTunes and leave a review!

Most career assessments try to paint a static picture of what you can do well with the least effort, but they often fail to provide a practical roadmap for your next career move. This episode provides a simplified, multidimensional version of a classic management tool to help you prioritise your growth:

• Understand the Nine-block Matrix: Visualise a grid where the x-axis represents your current performance (how well you are doing now) and the y-axis represents your potential (your capacity to grow to the next level).
• The Energy Dimension: Go beyond a 2D map by evaluating the energy cost of each skill on a scale of 1–5; this helps you identify where you are on "autopilot" versus where a skill is draining you.
• The Risk Factor: Assign a risk or criticality score to your skills to determine which are "fundamental" to your role (like software delivery) and which can be safely dropped to make room for more valuable growth.
• Spot Opportunity Flags: Identify areas where you have high potential but low performance and low energy output; these represent your best opportunities for rapid improvement with the least input.
• Make the Counterintuitive Trade-off: Learn why you might need to drop a skill you are already good at if it has low growth potential, redirecting that energy toward a new skill that offers higher long-term value for your career.
• Categorise Your "Bread and Butter" Skills: Recognise those mid-level skills that ensure your reliability and help you get the job done but shouldn't be the primary focus of your intense energy and development.

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.

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! I am in there as well, and you can message me directly.

If you're enjoying the show and want to support the content, head over to iTunes and leave a review! It helps other developers discover the show and keeps us focused on what matters to you.

This episode marks the 11th anniversary of the show, and I want to celebrate by continuing our Career Growth Accelerator series. Today, we’re moving beyond the "autopilot" mode that many engineers find themselves in and learning how to define goals that are uniquely yours so you can find the specific challenges that will actually move the needle.

Many of us operate on instinct, chasing goals like "get a promotion" or "make more money" without understanding the "why" behind them. This episode is designed to help you interrogate those automatic responses and find a path that is optimized for what you uniquely value.

• Break the Autopilot Loop: Understand why common goals like "getting a promotion" are often just survival mechanisms intended to keep us safe within social norms rather than reflections of our true values.
• The "Never Again" Pressure Test: Use the mental exercise of imagining you will never get another promotion; if this causes visceral anxiety, it’s a sign that your goal is rooted in a sense of safety rather than self-actualisation.
• Move from Post-Rationalisation to Purpose: Instead of backwards-justifying the status quo, learn to be honest about what you truly desire—whether it's the affirmation of intelligence, the freedom of discretionary time, or a specific mission.
• Create Instructive Goals: Discover why a goal must be personal and specific to be useful; a generic goal provides no roadmap, whereas a unique goal acts as an instruction for what to do next.
• Find Your True Challenge: Once your goal is defined, identify the specific obstacle standing in your way that requires ingenuity and isn't already decided for you.
• The "Asterisk" of Solvability: Learn the most critical rule for picking a challenge: it must be something you can reasonably solve given your current means to avoid falling back into paralysis and autopilot.

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/contact

Join our supportive community of engineers working to improve their lives and careers at https://developertea.com/discord.

If you're enjoying the show, head over to iTunes and leave a review! It helps other developers discover the show.

This episode kicks off the Career Growth Accelerator series, focused on the specific hurdles faced by mid-to-senior level engineers, managers, and leaders who are looking to move to the next level. Before diving into specific strategies, I’m addressing the fundamental prerequisite for real growth: getting out of your own way. We often block our own progress because our ego conflates our self-worth with our career position, making it impossible to see the real problems or lessons we need to learn. In this episode, I share a vital mental exercise to help you disconnect your identity from your job title and begin diagnosing your career challenges honestly.

• Understand why protecting your ego is one of the most dangerous ways to control your career, leading you to discount valid reasons for stagnation or failure by focusing only on external factors.
• Discover the fundamental shift needed: disconnecting your self-worth from your career aspirations. Your position is merely a fact and has little bearing on your innate value or capacity to succeed more generally.
• Learn how to use a distancing thought experiment—viewing your situation as if it were an acquaintance’s story—to remove your ego from the diagnostic process and gain necessary clarity and perspective.
• Explore why effective growth advice, whether for promotion or post-mortem analysis, requires focusing almost exclusively on the diagnostic aspect ("What happened and why?") rather than building justifications based on your worthiness or past performance.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

Are you a mid-to-senior level engineer or leader who has hit a career roadblock or found yourself stagnated? I'm launching the new Career Growth Accelerator series, focused on the difficult, non-obvious hurdles that prevent you from moving to the next level.

In this foundational Episode Zero, I cover the critical prerequisite for growth: Getting Out of Your Own Way. Our ego often protects our self-worth by blaming external factors for failures, making honest diagnosis impossible,.

• Learn why protecting your ego is the most dangerous way to control your career.

• Discover the fundamental shift: disconnecting your self-worth from your career aspirations to gain clarity.

• I introduce a distancing thought experiment to help you diagnose the real problems blocking your path.

• Start focusing on the diagnostic aspect—What happened and why?—to build real momentum.

Subscribe now so you don't miss out on this series!

When you hit a career roadblock, the methods that worked for you before often stop working. Today, I’m diving into why that happens, and why the first and most critical step in progressing past stagnation isn't doubling down on skills, but clearly defining the problem standing in your way.

My goal on the show is to help driven developers like you find clarity, perspective, and purpose in their careers. This episode is for everyone trying to grow, especially if you have hit some kind of roadblock. Most career progression, especially early on, happens somewhat automatically through natural experience, domain expertise, and skill accumulation,. However, as you progress, you will hit missing rungs or roadblocks—things preventing you from progressing in promotions, positions, or specific projects.

When blocked, most people rely on the same things they did before, such as gaining experience, reading blogs, or building side projects, using a "scattershot approach" to try and guess what their managers want,. Unfortunately, relying on activity that previously got you ahead will not necessarily work later in your career,. As you climb the career ladder, the number of positions available decreases (the pyramid shape), meaning that even being highly qualified may not lead to the next role if it simply doesn't exist,.

If you haven't defined the problem, you have no way of knowing whether the actions you are taking will help you progress where you want to go. Instead of continuing the never-ending cycle of self-improvement, you need to step outside your own context and try to see the problem from an external viewpoint, like a consultant. Recognizing the core problem—like a lack of available roles—allows you to shift your focus away from only improving your skill set and toward solving that specific organizational problem, perhaps by expanding the necessary scope for the role to open up,. Redefining the problem may mean shifting your goal from getting a promotion to convincing someone to let you perform the activities associated with that higher role, which is a different process entirely. In almost every circumstance where you are blocked, there is a problem that you need to work on defining better; this is the first step towards moving past the roadblock,.

• Explore why the natural career progression that works early on—driven by experience and skill accumulation—slows down and fails when you hit later-stage roadblocks,,.
• Discover why relying on a "scattershot approach" of extra activity, like reading blogs or building side projects, is often ineffective when facing a structural block in your career path,,.
• Understand that if a desired role doesn't exist within the company structure, becoming more skilled or qualified won't solve the organizational problem,.
• Learn how redefining your career problem—for instance, shifting from needing a promotion to needing permission to do high-level tasks—can open up entirely new pathways for growth.
• Challenge your self-improvement cycle by stepping outside your own context and defining your career roadblock as if you were an external consultant,.

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.

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 by visiting https://developertea.com/discord today! I'm also in the community, and you can message me directly there.

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keeps us focused on what matters to you.

We often look for ways to reduce the load on our brains, seeking shortcuts and optimizations to get ahead. Sometimes this works, reinforcing the belief that we can hack our way around every problem. However, this episode addresses the truth that many fundamental aspects of your career require something difficult, messy, slow, or inefficient, demanding deep thought and repeated failure.

This episode details the difficult truths about facing the most essential challenges in your career:

• Understand the Hard Path: Recognize that many aspects of your career, skill set, relationships, and hobbies require something difficult, messy, slow, or inefficient, demanding deep thought and repeated failure.
• Identify Your Primary Obstacles: Pinpoint the hard things you are procrastinating on, such as developing essential domain knowledge, deepening relationships with crucial co-workers or your manager, or getting the necessary "reps" of difficult building and practice.
• The Path to Mastery: Realize that becoming a great engineer (e.g., a great Python developer) is achieved not by reading books or finding perfect tools, but by building things over and over. This practice includes receiving feedback from peers and applying what you learn under challenge.
• The Pain of Decision: Explore why it is difficult to even decide to do a hard thing. By committing to the challenging path, you are choosing to cut off your optionality and giving up the hope of finding an easier, lower-investment alternative.
• Sustaining Commitment: Understand that initial motivation or an energetic feeling will not carry you through the obstacle when the development process becomes awkward, slow, or frustrating. Staying committed requires reinforcing your core underlying reason for doing the hard work.
• The Reward: Recognize that if you successfully address the hard thing you know needs doing, everything else in your life and career becomes easier.

Devs, if you think website builders mean limited control—think again. With Wix Studio’s developer-first ecosystem you can spend less time on tedious tasks and more on the functionalities that matters most: ● Develop online in a VS Code-based IDE or locally via GitHub. ● Extend and replace a suite of powerful business solutions. ● And ship faster with Wix Studio’s AI code assistant. All of that, wrapped up in auto-maintained infrastructure for total peace of mind. Work in a developer-first ecosystem. Go to wixstudio.com.

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.

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 by visiting https://developertea.com/discord today! There are other engineers there going through similar things in their careers, and I am also in there, where you can message me directly.

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

If you're looking to accelerate your career growth, this episode gives you what may feel like hard truths about the path forward. So many engineers fall into traps of overthinking, chasing minor optimizations (like 5% or 10% productivity boosts), or playing the games of politics and networking. While these sideline activities aren't necessarily useless, I want to help you focus on the "big engines" and "primary considerations"—the things that will make the monumental difference in your career building strategy.

• I explain why arguments based on nuance—such as trying to convince your manager that your work is valuable despite low throughput, or doing "glue work"—are often based on flawed strategies that cause your career to suffer and not grow easily.

• I use an allegory (discussing the primary path of treatment for low testosterone) to illustrate that many engineers are trying to fix a fundamental, mainline career problem with a sideline, nuanced solution, instead of focusing on the gold standard primary path.

• I debunk the skill collection fallacy: the misconception that broadening your skill set (learning more languages, frameworks, or techniques) provides the same level of career benefit as it did early on.

• Discover the fundamental path to growth: I advise you to set down new languages and skill sets and instead become a craftsman of a limited set of tools, fully understanding the domain, business problems, and how value flows through the organization.

• Learn why the most important factor that substitutes for very few other things is engaging in the deliberate practice of solving a sheer volume of problems encountered and solved over and over.

• I detail how to avoid the comfort zone: while solving problems is vital, you must ensure those problems progress with you by increasing complexity, scope, responsibility, or sheer volume of work, otherwise, your potential for growth will become limited and you will stall out.

• I caution that a lack of challenge (feeling no discomfort ever) can lead to boredom, disengagement, and eventual burnout, because your brain adapts, reducing the flow state you experience. I suggest finding ways to introduce discomfort that pushes you.

• Understand that the primary course of treatment for a failing or stalled career is simple: become incredibly good at your core set of responsibilities, making things like networking, resume writing, and managing relationships easier as a result.

📮 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

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 by visiting https://developertea.com/discord today!

🧡 Leave a Review

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

If you're an engineer looking to move into a senior role, you have likely heard that you need to demonstrate "ownership". Unfortunately, this crucial term is often poorly defined and leads to a major misconception: that ownership means being assigned a full project or a Tech Lead role. I want to dispel that myth and explain why ownership is actually a necessary behavior and mindset shift, applicable in almost every action you take, regardless of whether you’re leading a project.

• Understand why ownership is a critical aspect of moving along your career track, especially for engineers moving from the associate or mid-level engineer role up to senior.
• Uncover the misconception that ownership requires a specific scope of responsibility, such as owning a project or a deliverable.
• Discover the crucial phrase that defines the ownership mindset: "What now?" or "What next?" which should guide you through every situation you encounter.
• Learn why true ownership is not about inherently knowing every technical detail or executing every step, but about being willing to take responsibility and accountability for figuring out what happens next.
• Explore how a senior engineer's ownership behavior means translating identified problems (like those found in a retro) into action or decisions, thereby ensuring things continue moving forward and don't stall out.
• I explain that engineers show ownership by choosing to opt in to be held accountable for outcomes, rather than waiting for a manager to intervene or ask for a status update.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

Hey everyone, welcome to today's episode of Developer Tea. This is the second part of my interview with Bryan McCann, the CTO at you.com. If you haven't listened to Part One, I'd encourage you to go back, as it provides crucial context for our continued discussion. In this episode, we dive into how you can think about relating to and integrating the massive changes that AI is bringing to your job, whether you are a software engineer, manager, director, or product professional. Bryan and I discuss his interests beyond research, including art and organizational design.

• Explore the two primary paths for developers in the long run: specializing as managers of AI tools (like a product manager with engineering insight) or striving to be better than AI at building better versions of AI itself (the "neurosurgeon" type).
• Understand why refining your intuitions about what should be built becomes increasingly crucial as automation makes execution easier.
• Examine how conceptual biases often become the bottleneck when interacting with powerful AI tools, such as focusing on very narrow tasks for a broad tool.
• Learn how to approach AI failures: treat a failed output as an opportunity to dig in and figure out why, perhaps by asking the AI to write a better prompt or identifying a fundamental missing capability that could become a great startup idea.
• Conceptualize AI as the earliest versions of magic, where the manipulation of symbols (like embeddings) allows us to extend our influence into the world in a flexible and powerful way.
• Discover principles of organizational design by studying how neural networks learn, focusing on strong information flow, skip connections, and aligning with the objective.
• Consider the idea that the next phase of human development might involve emulating AI’s learning mechanisms (rather than expecting AI to become more human-like) to unlock the next phase of humanity and continue our search for meaning.
• Hear Bryan’s final piece of advice for listeners: focus on learning and working on things you are passionate about that will have the highest possible impact.

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..

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 by visiting https://developertea.com/discord today!.

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

Hey everyone and welcome to today's episode of Developer Tea. It's been quite a while since I've had a guest on the show. Today, I'm joined by Bryan McCann, CTO at you.com. We dive into a wide-ranging discussion, exploring the philosophical origins of his career—from studying meaning and language to working in very early AI research. This discussion is less advice-heavy and more focused on kind of theory and discussion. I hope this is insightful for you and helpful as you crystallize your own philosophies on these subjects.

• Explore the philosophical journey that led Bryan McCann from being a philosophy major interested in meaning to pioneering early AI research. Bryan views his current work as an extension of those original philosophical questions.
• Discover how Bryan shifted from hitting a dead end in "armchair philosophy" to using computational tools to study language and try to make machines that could create meaning.
• Understand why Bryan believes that meaning, in the sense he originally sought it, is an innately human thing, tied to purpose and the narratives we use to shape our sense of reality.
• Discuss the profound realization that AI breakthroughs might be akin to discovering electricity, suggesting we are tapping into a fundamental framework of meaning or connection that has always existed.
• Examine the concept of super intelligence and the "flywheel effect," where AI accelerates research and development, building better versions of itself and potentially surpassing the classic anthropomorphic vision of machine intelligence.
• Explore Bryan’s other interests, including organizations, people, and art, which he sees as continuing the uniquely human search for meaning.
• Consider the idea that humanity's constant need to differentiate itself from machines may simply be a mechanism for survival, enabling our continued dominance.

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..

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 by visiting https://developertea.com/discord today!.

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

I'm tackling a massive challenge today: burnout. While the standard advice usually involves working less, I want to show you a practical dimension of burnout you have more control over, focusing on increasing your agency and autonomy to manage chronic workplace stress more effectively. Burnout is classified by the ICD-11 as a syndrome resulting from chronic workplace stress that has not been successfully managed.

This episode includes practical advice for understanding and addressing burnout by shifting focus from reducing work volume to increasing control and resources.

• Understand the three dimensions of burnout as classified by the ICD-11: feelings of energy depletion or exhaustion, increased mental distance/negativity toward the job, and reduced professional efficacy.
• Discover why the amount of time you work is not a direct input to burnout, meaning working less is often impractical and may not solve the underlying issue.
• Learn the core philosophy for addressing burnout: In order to control stress, provide control (meaning agency and autonomy).
• Explore why stress is directly correlated to the ratio of demands placed on you versus the resources (including decision-making power, training, and tooling) you have to meet those demands.
• I’ll give you practical ways to approach your manager to secure necessary resources, training, or mentoring to improve your professional efficacy and reduce job negativity.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

In this episode, I dive into the management mantra that "what is measured is managed" and explain why this simple assertion often leads to a complex trap. We discuss why the act of measuring team productivity is never neutral—it's an intervention that immediately changes behavior, often resulting in unintended consequences like gaming the metrics. We'll explore how to collaborate with your team to find measurements that truly drive desired behaviors.

• Understand why the phrase "what is measured is managed" means that measuring something triggers management of that thing, in varying degrees.
• Learn why the act of measuring something is an intervention, especially when done with the intent of turning it into a target (e.g., increasing PRs or decreasing bugs), and how this action is shown to change behaviors around the thing being measured.
• Discover how measurement can lead to unintended consequences, such as when tracking velocity via story points causes team members to inflate or deflate their estimates, making the measurement itself less meaningful.
• Explore why giving ownership of metrics to the people acting to improve them makes sense, and how you can collaborate with your team to determine what kinds of measurements should be taken.
• Recognize that if you want something to survive—such as paying down tech debt—you must feed it with time, resources, and attention, ensuring your actions line up with what you claim to care about.
• Understand that since your calendar and dashboards will get crowded if you measure everything, the exercise of choosing metrics is as much about accepting that you have to choose what you will actively manage and invest in.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

I want to dive into the concept of Deliberate Practice, which sets the greatest apart in fields ranging from sports to writing to engineering. I’ll explain why it’s much more than just repetition or experience, and why applying it to your career can lead to rapid improvement. Most importantly, I will provide concrete ways you can apply deliberate practice to level up your engineering and leadership skills, especially in areas that are traditionally difficult to practice, such as communication and strategic decision-making.

• Differentiate Practice from Deliberate Practice: Understand that while repetition is part of practice, deliberate practice specifically involves engaging in a very narrow set of activities with the intentional goal of improvement, requiring very quick feedback for continuous incorporation.
• Identify Opportunities for Rapid Improvement: Learn why deliberate practice is much more effective at achieving rapid improvement than simply engaging in repetition.
• Apply DP to Leadership Skills: Discover how to incorporate deliberate practice into roles like engineering manager, tech lead, or IC (Individual Contributor) leader, where the activity of practice is often harder to pinpoint.
• Leverage Existing Work for Practice: I suggest a mindset shift where you begin looking at existing responsibilities, such as one-on-ones, as opportunities for practice. For example, you can focus on improving your clarity when providing constructive criticism and ask for specific feedback on that aspect.
• Generate Novel Value Through Practice: Explore how engaging in deliberate practice activities—like recording a video to communicate a technical concept or creating documentation—serves the primary goal of practice, while almost certainly creating unexpected value for your team (often net neutral or positive).
• Use Backwards Training for Strategy: Find out how to practice strategic decision-making and forecasting by using "backwards training". This involves reviewing past decisions or work scopes, creating your own rationale or estimate, and then calibrating it against the known reality.
• Simulate Difficult Conversations: Consider leveraging Large Language Models (LLMs) to engage in deliberate practice around language-heavy skills, such as modelling sensitive or difficult topics, or practicing receiving harsh feedback.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

This episode explores the concept of Locus of Control and why developing a more internal locus of control is beneficial for your career and life. You'll learn the difference between internal and external perspectives, why one is more useful than the other, and practical exercises to shift your mindset to believe you have more influence over the outcomes you care about.

• Understand Locus of Control: Discover what psychologists mean by locus of control—whether you believe outcomes are determined by your own actions (internal) or by external forces like luck and chance (external).
• Adopt a More Useful Mindset: Learn why an internal locus of control, while not a perfect reflection of reality, is a more useful and effective mindset for your career, as it prevents you from missing opportunities to influence outcomes.
• Recognise Your Influence: Find encouragement in the idea that you almost certainly have more influence and control over situations in your life and career than you currently believe.
• Shift Your Perspective with Practical Exercises: Engage in two research-based exercises to help you recalibrate your default beliefs and intentionally develop a more internal locus of control.
• Leverage Your Strengths: See how focusing on your strengths can create a positive feedback loop, reinforcing the belief that your efforts directly impact outcomes and helping you build a stronger sense of agency.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

In this episode we'll discuss why "Résumé Driven Development" is a powerful mental model for building a thriving career. Instead of seeing your résumé as just a job-hunting tool, you'll learn to use it as a guide for setting measurable, impactful goals that benefit you, your manager, and your company.

• Focus on Impact, Not Just Tasks: Discover why a great résumé is built on proof of impact, not just a list of completed projects. The best way to improve your career is to focus on achieving measurable goals that demonstrate real value.
• Have the Goals Conversation: Learn how to initiate a critical conversation with your manager to define measurable goals for your role. If your manager can only provide project deadlines, take the initiative to propose your own impact-oriented goals.
• Connect Goals to Business Value: Understand the importance of linking your work to business metrics. While there's a risk that a project might not meet its business goals, you can also measure impact through clever technical solutions or process improvements, like reducing team cycle time.
• Take Control of Your Career: Realise that your career success is ultimately dependent on your own actions. By proactively setting and tracking goals, you take control and can clearly tell the story of the value you bring to the table.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

In this episode, we introduce a simple yet powerful mental model from the world of sports: forced vs. unforced errors. By understanding this concept, you can shift your focus from things outside your control to the simple, foundational behaviours that truly define a successful career.

• Understand the Difference: Learn the distinction between forced errors—mistakes caused by chance, situation, or randomness that are hard to prevent—and unforced errors, which are avoidable blunders resulting from a lack of attention or care.
• Focus on What You Control: Discover why the most successful engineers prioritise reducing their unforced errors. While most people worry about hard-to-predict "forced errors," top performers concentrate on the fundamentals they can directly influence.
• Identify Your Unforced Errors: Recognise common unforced errors in your career, such as not testing your work, being late for meetings, erratic communication, or posting unprofessional content online. These simple mistakes can significantly impact your career over time.
• Conduct a Self-Audit: Learn the value of regularly performing a "self-audit" to identify and correct the simple, common-sense things you may be failing at. By improving in these areas, you can dramatically increase your reliability and competitiveness.

Devs, if you think website builders mean limited control—think again. With Wix Studio’s developer-first ecosystem you can spend less time on tedious tasks and more on the functionalities that matters most:

• Develop online in a VS Code-based IDE or locally via GitHub.
• Extend and replace a suite of powerful business solutions.
• And ship faster with Wix Studio’s AI code assistant. All of that, wrapped up in auto-maintained infrastructure for total peace of mind. Work in a developer-first ecosystem. Go to wixstudio.com

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

In this episode, we introduce two fundamental thought experiments to help you uncover your true priorities and core values. By exploring scenarios of scarcity and abundance, you'll learn to align your daily actions with what truly matters, leading to a more satisfied career and life.

• Uncover Your Priorities: Engage in a "5% exercise" where you imagine only being able to complete a tiny fraction of your to-do list. This thought experiment leverages a scarcity mindset to reveal your genuine priorities, helping you distinguish between what you perceive as important and what truly is.
• Discover Your Values: Participate in an "abundance exercise" by imagining all your obligations are met and you have complete autonomy. What you choose to do next in this state reflects your core values and helps you move beyond aspirational or culturally normative answers.
• Go Deeper: Learn to challenge superficial answers when identifying your values, pushing beyond the obvious to find unique and potentially surprising insights that genuinely guide your decision-making.
• Unify for Satisfaction: Explore the profound insight that the most likely path to a satisfied career and life comes from unifying your priorities and values, thereby avoiding actions that don't align with what truly matters to you.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

This episode explains what is arguably the best career advice you'll hear this week: the one skill that signifies seniority in software engineers is the ability to synthesise and optimise for multiple factors at once. Instead of focusing on a single factor, such as performance or maintainability, senior engineers identify and weigh the various trade-offs involved in any decision.

• Discover the key skill that distinguishes a senior engineer: It's the ability to synthesise multiple, competing factors—like performance, maintainability, cost, and time to market—rather than focusing on just one.
• Learn why single-factor thinking can hold you back: Junior engineers often optimise for what they know best or what is easiest to measure, which can harm the overall solution, the team, and their professional reputation.
• Understand how to demonstrate seniority in interviews and at work: You can show your maturity and wisdom by identifying the crucial trade-offs for any given problem, asking what factors need to be balanced, and exploring options that might satisfy multiple goals at once.
• Explore how to find better solutions by thinking in trade-offs: The goal isn't just to make sacrifices; often, the mark of a great senior engineer is finding a third option that effectively balances or optimises for multiple important factors simultaneously.
• Start practising this skill today: Challenge yourself to identify what you are giving up with any decision and consider factors you don't normally prioritise. Ask "What am I saying no to?" to develop this crucial skill.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

This episode focuses on the critical importance of having a backup plan, not just for technical redundancies but especially for situations involving human error, which are highly prevalent in one's career. The core argument hinges on understanding risk and reward curves, highlighting the disproportionate impact of failures compared to incremental successes.

Understanding Risk and Reward Curves:

• Successes are often incremental. Delivering a project on time typically leads to opportunities for more projects, good performance reviews, and modest pay increases (e.g., 5-7%). These are positive, but linear or slightly bumpy gains.
• Failures, especially uncaught ones, have a much longer negative tail. The potential for loss from a significant mistake or a disastrous project significantly outweighs the potential for gain from a success.
• A bad performance review, for example, can affect future reviews, decrease promotion likelihood, and follow you for a much longer period than a good one.
• Uncaught failures can place individuals in a pool for budget cuts or layoffs, leading to catastrophic curves where negative effects compound much faster, resembling a logarithmic function. One or two significant negative events could wipe out all accumulated incremental gains.

The Criticality of Backup Plans:

• Backup plans are essential to avoid these catastrophic negative curves and major "wipeout scenarios".
• This preparedness applies to project failures, personal career contingencies (e.g., getting laid off), and even events beyond direct control.
• It's crucial to prepare for theoretically possible catastrophic events, not just those that have historically occurred. Even "Black Swan" events or things you're not prepared for can cause major issues.
• Thinking like this (e.g., similar to life insurance, which you only need once if at all) encourages hedging efforts with basic backup plans, such as redundancy.

Benefits of Preparedness:

• The more you prepare for contingencies, the more likely you can deal with the majority of failures, preventing the catastrophic curve.
• Having backup plans can create a "flywheel effect", where your ability to respond to negative events actually increases the speed of stacking up further positive outcomes.
• Being proactive in your career (e.g., interviewing even when you're happy in your current role) builds resiliency.

Actionable Advice:

• Focus on what could go wrong: Try to figure out how things could fail and what catastrophic events are possible, even if they haven't happened yet.
• Identify vulnerabilities: Locate areas where a catastrophe could lead to a steep drop-off in your career trajectory.
• Implement a basic backup plan: The recommendation is to put just one in place this week for something that could catastrophically impact your career. This provides a sense of relief and ensures readiness if needed. Taking this first step is likely to encourage creating more backup plans for professional situations.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

Todays episode delves into understanding and leveraging second and third-order consequences – the ripple effects that occur after an initial action – and introduces forcing functions, which are an inverted way of thinking about these consequences, designed to drive desired outcomes by first determining "what must be true" for them to occur. The episode also connects these concepts to the importance of effective goal setting, explaining how well-defined goals provide clarity, focus, and a strategic framework for decision-making and career advancement.

• Grasp Second and Third-Order Consequences: Learn to identify the downstream effects of initial actions. For instance, setting a target for test coverage (first action) might lead to people adding tests that don't genuinely test anything but merely inflate the metric (second-order consequence), potentially resulting in disillusionment with testing or continued incidents despite high coverage (third-order consequence). Conversely, giving someone ownership or autonomy (first action) can lead to them proactively filling out details and owning ambiguity (second-order consequence), which may result in higher quality work, freeing up managerial time, and setting the individual up for promotion (third-order consequence).
• Utilise Forcing Functions for Desired Outcomes: Understand forcing functions as an inverted approach to consequences, where you begin with a desired outcome and then identify the upstream requirements or desirable effects that must be true for that outcome to be achieved. This method helps to focus efforts on one to three key areas for improvement, rather than trying to enhance everything simultaneously.
• Implement Effective Forcing Functions: Discover how various elements can act as deliberate or accidental forcing functions:
  • A prioritised backlog acts as a forcing function for essential discussions, decision-making, gathering sufficient information for prioritisation, and ensuring knowledgeable individuals are involved in the process.
  • Presentations, demos, or all-hands meetings serve as powerful social forcing functions, as the desire to avoid the discomfort of not having progress to show incentivises action and preparation.
  • Sprint planning is a forcing function that necessitates a clear understanding of priorities and team capacity for the upcoming sprint.
  • Quality metrics or Service Level Agreements (SLAs), such as a P95 response time, act as forcing functions by requiring other system components to be correctly aligned to meet the target.
  • The choice of technology or tech stack can be a significant forcing function for hiring, unintentionally selecting for specific types of engineers (e.g., Java for enterprise experience, TypeScript for full-stack, functional languages for functional programming experience).
  • Workplace restrictions, like requiring night availability, can be accidental forcing functions, potentially selecting against individuals with community involvement, family commitments, or social lives.
  • Successful hiring and recruiting is a strong forcing function for many positive aspects of a company, indicating technical success, high retention, competitive salaries, and a high standard for talent across the organisation.
• Harness Goals for Clarity and Focus: Recognise that a well-positioned goal is paramount for finding clarity, perspective, and purpose in your career. Goals provide a framework to make decisions about what to do, ensuring your time is spent on what matters to you rather than just on tasks handed to you, thereby enabling personal career growth.
• Set Relevant and Directionally Correct Goals: Emphasise the relevance of your goals; even if they are specific, measurable, actionable, and time-bound (SMART), they are ineffective if they are not relevant to your desired career path. Aim for goals that are directionally correct, moving you generally towards a long-term outcome (e.g., leading a project if your long-term aspiration is to lead teams), rather than being paralysed by the pursuit of a "perfect" goal.
• Leverage Manager Feedback for Goal Setting: If you are unsure how to set goals, consider what your boss would look for in your performance in six months. Proactively engage your manager by initiating conversations about career growth and goal setting, framing it as an opportunity for mutual success and seeking their input on what constitutes a "home run" for your role.
• Set Sustainable and Challenging Goals: Avoid goals that are too abstract (lacking clear actions) or that significantly over- or underestimate your capacity, as both can lead to disengagement. Instead, strive for challenging but sustainable goals that require focus and making difficult choices (e.g., saying "no" to other things) but do not lead to burnout.
• Be Mindful of Your Choices: Deliberately choose your forcing functions and become aware of those you are accidentally opting into. Consistently consider the downstream effects (second and third-order consequences) of your actions today, and set goals that imply a desired future state rather than dictating the exact methods. Consistency in this mindful approach to goal setting and understanding consequences is key to long-term career success.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

This episode delves into the philosophical concept of hyperobjects – problems so vast and complex they lack clear boundaries and cannot be "solved" once and for all. It explores why attempting to permanently fix issues like technical debt, user experience, or performance management is often ineffective. Instead, it offers a new perspective: how to interact with and manage these intractable problems by focusing on specific outcomes and accepting their ongoing nature.

• Understand hyperobjects as problems that extend beyond clear boundaries and time, such as technical debt or performance management, which cannot be truly "solved".
• Discover why a "one-time fix" approach is an anti-pattern for hyperobjects, as their dynamic nature means solutions must also be continuous.
• Learn to shift your mindset from "solving" to "interacting" with these large, persistent problems, focusing on managing their effects rather than trying to contain them.
• Explore the importance of focusing on specific, achievable outcomes and taking "snapshots" of the problem's current state, acknowledging that the hyperobject itself will continue to evolve.
• Recognise that language and conceptualisation play a crucial role in framing and addressing these intractable challenges within your work and organisation.

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..

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 by visiting https://developertea.com/discord today! It's totally free, and always will be, for people who listen to this show.

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

This episode delves into a powerful model for encouraging behaviour change, applicable to both managing others and self-improvement, by focusing on three critical factors: Trigger, Incentive, and Ability. It challenges common, ineffective management approaches and provides insights into fostering new habits and desired actions by making the 'right' thing the 'easy' thing.

• Uncover why naive management approaches, such as mandating rules or blaming individuals, are ineffective at solving underlying behavioural problems or creating new, lasting habits.
• Learn about the Trigger, Incentive, and Ability model, a set of principles that can be applied to encourage specific actions in others or to facilitate self-betterment and incorporate new behaviours into your own life.
• Understand that Incentives are the critical factor in deciding what actions to pursue, driven by the question, "what's in it for me?". It's crucial for incentives to be clear and understood; an unclear incentive is effectively no incentive at all. Beneficial incentives tend to be more effective from a scientific standpoint.
• Discover the importance of a clear Trigger, which is the cross point or moment at which a decision to act is made. Assuming triggers will be self-generated is often a flawed management practice, especially when encouraging new behaviours.
• Explore how Ability goes beyond just skill, encompassing clarity on how to do something and the reduction of friction and variability in the desired behaviour. The goal is to reduce cognitive overload and make the desired action the easiest option, thereby facilitating habit formation.
• Realise the interconnection between Ability and Incentive, as a lack of clarity in how to perform a task (Ability) can make the incentive unclear because the reward for completion becomes uncertain.
• Learn that the investment in encouraging behaviour change should focus on creating a better trigger, a better (and clearer) incentive, and higher ability (lower friction, higher skill) to ensure people engage in the desired behaviour.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

This episode delves into the crucial role of well-positioned goals in a developer's career. It asserts that goals provide clarity, perspective, and purpose, particularly focusing on clarity as a primary benefit. The discussion challenges common struggles with goal setting, including the often-overlooked importance of relevance (the 'R' in SMART goals), suggesting that an irrelevant goal, no matter how specific or measurable, is ultimately ineffective. The core message highlights that the purpose of a goal is to serve as a clarifying and prioritising tool, enabling you to make decisions about what to do and focus your efforts, rather than simply doing work that is handed to you. You will learn to start small and focus on desired outcomes or what you want to be true, accepting that a goal only needs to be "directionally correct" rather than perfect. The episode also provides a practical heuristic: to set goals by considering how your boss will evaluate your performance in the future. It emphasises the importance of setting goals that are challenging but sustainable, avoiding common pitfalls like overly abstract, too easy, or demoralisingly difficult goals, to prevent disengagement and burnout. Ultimately, consistent goal setting and reflection are presented as key drivers for long-term career success.

• Understand the fundamental importance of goals in providing clarity, perspective, and purpose in your career, especially for driven developers.
• Recognise that relevance is the most critical factor in goal setting; a goal's specificity or measurability is meaningless if it is not the right goal for you.
• Grasp that the primary function of a goal is to help you make decisions about what to do, acting as a clarifying, prioritising, and focusing tool for your efforts.
• Challenge the mindset that your goal as a software engineer is merely to complete assigned work; without personal goals, your career changes and skill development will be difficult.
• Learn to start small when setting goals and focus on desired outcomes or what you genuinely want to be true in your career.
• Embrace the concept of a "directionally correct" goal, understanding that a goal does not need to be perfect to guide you effectively towards a larger, long-term outcome.
• Utilise reflection after meeting a goal to assess whether it moved you closer to your long-term objectives, providing valuable steering for future goals.
• Employ a practical heuristic for goal setting: imagine how your boss would evaluate your performance in six months or a year, and set goals around those anticipated factors.
• Be proactive in discussing career growth and goal setting with your manager, framing it as an opportunity for them to direct your efforts towards organisational wins.
• Identify and avoid common pitfalls in goal setting, such as goals that are too abstract (not tractable), too easy (causing disengagement), or too difficult (leading to demoralisation).
• Strive for goals that offer a challenging but sustainable chance of success (e.g., around a 60% probability), requiring focus and the ability to say no, without leading to burnout.
• Understand that consistency in setting and pursuing goals is what ultimately defines long-term success, rather than the perfection of any single goal.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

For further reading (external sources):

• SMART Goals: The episode mentions the SMART framework (Specific, Measurable, Attainable, Relevant, Time-bound) as a good set of checks for goals. You can find more information about SMART goals on their Wikipedia page. (Please note: This link provides information from outside of the provided sources and you may want to independently verify that information.)
• The discussion on goal success probability (e.g., 60% chance of success) alludes to studies on optimal challenge levels for engagement and achievement. You may find further research on goal-setting theory and motivational psychology to explore these concepts in more detail. (Please note: This information is not explicitly from the provided sources and you may want to independently verify it.)

Today we explore Cognitive Load Theory. This concept can profoundly influence how you structure your workday, manage teams, and approach learning in your career. The episode highlights that much of professional work, particularly in knowledge-based roles like software engineering, is fundamentally about learning. You will discover that there is an optimal amount of information processing for effective learning, and both overloading and underloading your cognitive capacity can be detrimental. A key insight is that cognitive load does not discriminate; all external factors, whether work-related or personal (e.g., tiredness, a messy desk), consume your finite cognitive capacity, leaving less "headroom" for optimal performance. Furthermore, cognitive load is not static but varies daily, impacted by an individual's diverse life experiences. The episode also delves into how skill development effectively lowers the cognitive load required for specific tasks, allowing individuals to achieve more with less mental effort or take on new challenges. It underscores the importance of self-awareness in recognising signals of overload or underload, and for managers, it emphasises fostering empathy by understanding how external life factors can impact a team member's cognitive capacity.

• Understand the pervasive nature of learning in professional careers, particularly for developers, where acquiring new information and making connections is a constant.
• Grasp the core principle of Cognitive Load Theory: there is an ideal level of information processing that maximises your learning ability. Both excessive (overload) and insufficient (underload) cognitive demands can negatively impact this learning rate.
• Recognise that your cognitive load does not differentiate between sources. This means that personal factors such as being tired, anticipating events, or even having a cluttered workspace contribute to your overall cognitive load, reducing your capacity for work-related tasks.
• Appreciate that an individual's cognitive load is not a fixed value; it fluctuates daily due to various life experiences.
• For managers, learn to proactively discuss cognitive load with your team members to help them operate at an appropriate engagement level. A simple way to initiate this conversation is by asking about their energy and positivity levels.
• Discover that while reducing non-value-producing cognitive load provides more mental overhead, it also carries the risk of underloading, which can lead to disengagement and reduced performance. The challenge lies in finding the optimal balance.
• Learn how developing skills and gaining experience reduces the cognitive load required to perform a task. This means you become more efficient and can accomplish the same outcomes with less mental effort, freeing up capacity for new learning or additional responsibilities.
• Consider career growth through the lens of cognitive load: it involves either increasing efficiency (doing more of the same with less load) or expanding your repertoire by taking on new types of cognitive load in parallel.
• Understand why managing your personal life is intrinsically linked to your career success (and vice versa), as cognitive load universally affects your capacity to learn and handle challenges.
• Build empathy by understanding that a person's capacity to perform difficult tasks can be significantly moderated by their current cognitive load, which may be influenced by challenging personal circumstances.
• Recognise task saturation as the point of cognitive overload where performance declines rapidly, as observed in flight training. Repeated exposure to this point, however, can lead to skill development that lowers the cognitive load for those specific tasks over time.
• Understand that multitasking often increases cognitive load due to switching costs, making it less efficient than sequential task completion.

Devs, if you think website builders mean limited control—think again. With Wix Studio’s developer-first ecosystem you can spend less time on tedious tasks and more on the functionalities that matters most:

• Develop online in a VS Code-based IDE or locally via GitHub.
• Extend and replace a suite of powerful business solutions.
• And ship faster with Wix Studio’s AI code assistant.

All of that, wrapped up in auto-maintained infrastructure for total peace of mind. Work in a developer-first ecosystem. Go to wixstudio.com.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

For further reading (external sources):

• To learn more about the academic background of Cognitive Load Theory, you may find additional information on its Wikipedia page. (Please note: This link provides information from outside of the provided sources and you may want to independently verify that information.)
• The concept of "task saturation" discussed in the episode, particularly in the context of flight training, relates to a point of cognitive overload. More on this can be explored on its Wikipedia page. (Please note: This link provides information from outside of the provided sources and you may want to independently verify that information.)

This episode focuses again on the fundamental principle that your systems are perfectly designed for the outcomes you are experiencing, regardless of whether those systems were intentionally or accidentally created.

Here are the key takeaways from the episode:

• Uncover how your systems, whether intentionally or accidentally designed, are perfectly configured for the outcomes you experience. The implication of design means choices have been made in setting up a system, but your intent is less important than the actual outcomes produced.
• Learn why your intent is less important than the actual outcomes when evaluating your systems. If your intent was the sole factor, everyone would achieve their desired results. Instead, systems should be judged by the outcomes they generate.
• Discover the concept of "accidental design," where unseen factors influence system behaviour. This can be inspired by Goodhart's law, where a measure becomes a target and changes behaviour, or by environmental factors, such as how your workspace impacts your thinking and heart rate.
• Explore how "invisible systems" – the unexamined rules and assumptions that govern your daily life – profoundly influence your actions and results. These are forces changing your behaviour that you likely haven't evaluated, such as automatically accepting all meeting invites.
• Understand that human behaviour, including your own, can be an outcome of your systems. This perspective offers the highest leverage opportunity for change, as modifying the underlying system is more effective than relying on temporary motivation or addressing knowledge gaps in isolation.
• Realise that system boundaries are often arbitrary, and a system's design must account for all factors influencing its outcomes. For example, a quality assurance system cannot be considered good if it fails due to a "talent" issue; the talent pool and hiring procedures are part of the overall system affecting the outcome. Ignoring such factors because they fall outside perceived boundaries of responsibility can lead to irreducible or expensive risks.

You are encouraged to investigate the invisible parts of your systems and write down the assumed rules that govern your life, even if you haven't evaluated their truth or helpfulness.

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

This episode discusses why perfection is a dangerous and fragile goal, explaining how striving for 100% leads to unsustainable outlier states. It highlights how setting perfection as a bar can cause commitments to break and plans to fail due to a lack of slack, and offers strategies like building redundancy and planning with slack to achieve goals more effectively without relying on perfection.

• Uncover why perfection is a dangerous and fragile goal, as it often requires exorbitant, unsustainable effort and creates outlier states that are unlikely to be maintained, referencing the "Wedies effect" where things tend to regress to the mean.
• Learn how planning for 100% utilisation or setting perfection as a commitment can lead to fragility, causing plans to fail when unexpected changes occur or leading to giving up altogether once a "perfect" streak is broken.
• Discover practical strategies to avoid fragile perfectionism, such as planning with slack to accommodate change and building redundancy into your systems and personal commitments for more robust outcomes.
• Explore why actively avoiding requirements or expectations of perfection is crucial, as investing in it can be an exponential or even asymptotic step, leading to an unsustainable and fragile state.

Note: sorry about the plane noise in the background. I decided to publish it, since it's imperfect (and that's kind of making the point!).

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.

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 by visiting https://developertea.com/discord today!

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.

This episode introduces the potentially controversial principle that your system is perfectly designed for its current outcomes, urging listeners to embrace greater responsibility for systemic issues. It explores how to redefine system boundaries to holistically integrate all influencing factors, like talent and organisational processes, ensuring that interventions are effective and targeted.

• Uncover the principle that your system is perfectly designed for the results you are getting, prompting a re-evaluation of what constitutes a "good" system when outcomes are undesirable.
• Learn why arbitrary system boundaries often lead to critical factors, such as talent, being excluded, and how to consider a system's full scope regardless of traditional lines of responsibility.
• Discover how incorporating talent and other seemingly external factors into your system design can lead to more efficient and effective solutions, rather than simply patching symptoms.
• Explore the distinction between judging decisions by their outcomes (resulting) and designing systems that proactively reduce uncertainty and improve the likelihood of success.
• Understand that system thinking extends beyond technical architecture to encompass processes, policies, culture, and interpersonal dynamics, which collectively influence organisational outcomes.

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..

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 by visiting https://developertea.com/discord today!.

If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.