app_store_button

google_play_button

PL - Details page - Device banner - 894x1036

Słuchaj i czytaj kiedy chcesz

Jonathan Cutrell

Developer Tea exists to help driven developers connect to their ultimate purpose and excel at their work so that they can positively impact the people they influence.

With over 17 million downloads to date, Developer Tea is a short podcast hosted by Jonathan Cutrell, engineering leader with over 15 years of industry experience. We hope you'll take the topics from this podcast and continue the conversation, either online or in person with your peers. Email: developertea@gmail.com

Developer Tea

As you grow as an engineer, something counterintuitive happens: the systems you build get simpler, not more complex. In this episode, I explore why senior engineers tend to collapse abstractions, accept certain risks, and reduce the surface area they're responsible for — and what drives that shift underneath the surface. Understanding the reasons behind the trend is what lets you get there on purpose instead of waiting a decade to arrive there accidentally.

Early in your career, output goes up fast. You're building more than ever, especially with AI in the mix, and a lot of what you build carries real complexity. But watch engineers who have been doing this a long time and you'll notice the opposite of what you'd expect: as their craft improves, their code, their architectures, and their systems get simpler. In today's episode, I dig into why that happens — and why chasing simplicity directly is less useful than understanding the underlying forces that produce it.

 Simplicity Isn't the Goal — It's the Byproduct: • Trying to "make things simpler" as a directive doesn't get you very far. If you can understand the core reasons complexity tends to fall as engineers mature, you can aim at those reasons instead and arrive at simplicity organically.

 Why Simpler Code Pays Off: • Simpler things are easier to understand, which means junior engineers can pick up your code, and future-you can return to a project you've long since left and still make sense of it. Adapting a simple thing is almost always easier than adapting a complex one.

 The Pain of the Refactor Teaches You: • A big part of this shift is scar tissue. Once you've lived through a massive refactor of a complex system, you start making different trade-offs — not from theory, but because you don't want to do that again.

 Collapsing Vertical Abstractions: • One of the most common refactors senior engineers reach for is collapsing long chains of abstraction that only ever get used in one place. It's abstraction without reuse, and it forces you to re-load enormous context just to make a small change.

 Refining Your Risk Tolerance: • Early on, we hedge against every possible risk. Later, we learn some risks are acceptable. Hedging is insurance, and sometimes it's very expensive insurance — paid in velocity, in onboarding difficulty, and in only being able to hire people who can hold all that complexity in their heads.

 Knowing When to Break Best Practices: • Maybe the best practice says abstract this. But if it isn't that hard to understand, and you can get most of the benefit through better naming or tighter scoping, the "correct" move might be the wrong one.

 The Library Trap (In Both Directions): • Seniors often take a trip through "let's not use external packages, we don't know what's in them" — and end up maintaining a shadow version of the thing they avoided. The more experienced call is often to accept the trade-off, adopt the well-documented dependency, and shrink what 
you • are responsible for.

 Reducing Surface Area Creates Focus: • The through-line in all of these trade-offs is a shrinking surface area. Fewer things to maintain means more focus, and more focus means the things you 
are • responsible for get done very well. It's an open question whether those behaviors follow seniority or cause it.

 Drive to the Fundamentals: • Think about a machine built from a ramp, a screw, a rubber band, and a motor. A more senior craftsperson recognizes the problem is fundamentally about conservation of energy, and reconfigures it down to two parts instead of eight. Slightly less efficient, maybe — but far less to teach, maintain, and break.

 Episode Homework: • Ask yourself: what am I responsible for right now that I could simplify? Where can I get away from the tactics and the surface-level stuff, get down to the core of the thing, and focus on doing that core really well?

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.

📮 Join the Discord

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

🗞️ Subscribe to The Tea Break

We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.

🧡 Leave a Review

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

Why Reducing Complexity Is A Sign of Seniority

Accountability is a word you'll hear in your performance reviews, from your manager, and increasingly as you step into leadership. It's also one of the most abused and misunderstood concepts in our industry. Many of us have a visceral, negative reaction to it—not because the concept is broken, but because the companies and people we've worked with have bastardized its meaning. In today's episode, I want to strip away the scary parts and offer you a pragmatic, working definition of accountability: one that a good engineer would actually invite rather than dread.

What We Cover

 The Bad Version of Accountability: • Recognize the weaponized version of this word—being audited for things you didn't know you were responsible for, having unrealistic goals coerced onto you, and getting surprised at performance review time. This is how leaders shirk their real responsibility to grow people and create clarity, hiding hard performance conversations behind a single loaded term.

 Accountability as Debugging: • Shift the frame to how we think about software. When payroll software overpays your team by $100, you file a bug report—something deviated from the agreement about what should happen. The engineer who investigates is performing an accounting function, tracing a root cause. That's what being "held to account" really means: identifying what happened against a known standard.

 The Churning Customer Problem: • Understand what happens when the bug report never gets filed. A customer who hits something unexpected and just leaves never gives the company a chance to fix it. The same thing happens between you and your manager when the communication lines aren't established—you find out at review time instead of when it could have mattered.

 Accountability at Every Step: • In a healthy team, accountability isn't a once-a-year audit. It's continuous, giving you the ongoing opportunity to notice when something has deviated from the agreement—so you have something concrete to hold to account before it becomes a surprise.

 Estimates vs. Commitments: • Learn to separate the two things you say to a stakeholder. One is a forecast, a guess, a belief. The other is a commitment. Bad accountability coerces the estimate into a commitment it never was; too-soft accountability treats everything as up in the air. The healthiest organizations hold both: a high-confidence forecast, plus a commitment to do whatever is necessary if it looks like it won't get done.

 Why Good Engineers Invite It: • If you want to grow in your career and confront reality, you invite accountability and commitment inspection. Done well, it creates clarity of expectation for exactly how you're doing—which is a gift, not a threat.

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.

📮 Join the Discord

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

🗞️ Subscribe to The Tea Break

We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.

🧡 Leave a Review

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

A Pragmatic Definition for Accountability

There's a cognitive trick our brains play whenever we face a hard question or a difficult decision: we quietly swap the hard thing for something easier to answer. It's called substitution, and we do it constantly — usually without noticing, and sometimes to our detriment. In today's episode, I make the case that you can take this same shortcut your brain already runs automatically and start using it intentionally to break decision paralysis and get moving.

 The Substitution Heuristic: • Understand the mental move at the heart of this episode — when "How are you?" becomes "Is there anything I urgently need to say?", your brain isn't being lazy, it's compressing. It runs a quick calculation: what's the downside of the substitute? Usually it's low, so the shortcut holds.

 Code Review as Substitution: • See why you almost never review a big PR line by line. "Was it tested? Does it follow our best practices? Does anything look obviously wrong?" are all stand-ins for the harder, mostly-unnecessary work of reading every line — and most of the time, they're enough.

 Performance Reviews Are a Best Guess: • Recognize that your rubrics, metrics, and frameworks are themselves substitutes. You can't deterministically rate a person on a scale, so every measure you use is an approximation of an immeasurable question: how much value is this person really generating, and where are they headed?

 Turn the Trick Around on Purpose: • Learn how to use substitution deliberately to defeat paralysis. Instead of "I'm deciding to leave my job and chase something new," substitute "I'm going to send an email." The weight of sending an email is tiny — and the dream job is just a series of small, iterative steps like that one.

 Unbundle Your Big Decisions: • Notice how we fuse trivial mechanical actions with heavy imagined meaning. Merging a branch isn't "declaring this production-ready and putting my name on the line" — it's moving bits into the cloud. Separate the labeling from the action and the action gets a lot less intimidating.

 Lower Your Commitment Threshold: • Swap "this code is great" for "I believe this code is shippable." Swap "this is the perfect hire" for "this is a good bet we can course-correct." The actions you take are identical — but the internal stakes, and the fear, drop dramatically.

 Favor Reversible Moves: • We consistently overestimate the risk of acting and underestimate the risk of doing nothing. Most decisions aren't permanent — you can roll back the deploy, divert from a bad hire, find an exit path. Look for the way back, and the decision gets easier to make.

Episode Homework

Next time you feel a big decision looming, break it into its most fundamental pieces. Ask: what am I actually doing here? What are the physical actions, the words, the mechanical steps? What's the true worst-case downside — and do I really have to attach all of my worth to it? You're likely already substituting easier questions without realizing it. This week, try doing it on purpose.

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.

📮 Join the Discord

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

🗞️ Subscribe to The Tea Break

We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.

🧡 Leave a Review

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

Using Substition to Make Decisions Simpler

The skills you build and the tools you master matter, but they aren't your most important asset when things go wrong — and something eventually will. In this episode, I work through why our careers and lives are governed more by avoiding catastrophic downside than by chasing upside, and why the single best tool for surviving a bad event isn't testing, insurance, or money — it's genuine trust with the people around you.

Here's a question to sit with: what is the most important tool you have as a software engineer and as a leader? Most of us reach for something technical, but the answer runs deeper than that. In this episode, I start with the humble premortem — the practice of assuming something has already gone wrong so we can pressure-test our plans — and use it to explore why so much of our work is really about predicting and mitigating risk. From there, I make the case that because we're all exposed to a far larger downside than upside on any given day, the tool that matters most is the one that helps you survive the bad event you couldn't prevent: your relationships with other people, built on real trust.

 The Premortem as a Risk Lens: • Learn why assuming failure ahead of time is such a useful counter to our natural optimism. Our plans quietly assume everything will go right, and a premortem forces us to inspect the gaps our best-laid plans never covered.

 Life Is Already About Predicting Risk: • Nearly every action we take — stepping forward, eating the sushi, merging into traffic — is a small bet on an outcome we can't prove in advance. Much of what we're managing isn't even our own behavior, but the risk other people put us through.

 Why the Downside Dwarfs the Upside: • On a typical Monday, your potential gain is limited, but your potential loss is not. A single catastrophic event — a breached customer, untested code shipped, an injury for an athlete — can undo far more than any single good action could ever build. This is why avoiding failure, not chasing brilliance, quietly shapes most successful careers.

 Likelihood Times Impact: • Even a one-in-a-hundred-days negative event can cost you your job or your company a fortune, while very few actions could produce a commensurate gain like doubling your salary. Our behavioral aversion to risk turns out to be rational.

 Mitigate the Blast Radius, Not Just the Incidence: • You can never be 100% certain a bad event won't happen. Good people who show up, stay reliable, and grow their skills still get laid off. So beyond reducing the likelihood of harm, you have to reduce its impact when it lands.

 Relationships Are the Real Safety Net: • The most important tool in your belt isn't technical — it's your relationships with other human beings. Invested in honestly, they pay you back forever, and they're the thing you fall back on when the negative event you tried to prevent happens anyway.

 Trust Is the Core Currency: • Genuine relationships require reality — real curiosity and care, not performed name-remembering, which people can see through. Trust compounds like an asset, while money spent to buy loyalty is gone the moment it's paid. When you hit a hard deadline or discover something's broken, a reservoir of trust is what lets people extend their best effort without you having to throw more money on the table.

 Episode Homework: • Go invest in your relationships regardless of your current risk profile. Spend extra time in your one-on-ones, with your team, and in your retros — and get curious about what the people around you actually want, instead of assuming you already know.

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.

📮 Join the Discord

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

🗞️ Subscribe to The Tea Break

We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.

🧡 Leave a Review

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

Your Single Most Important Tool for Managing the Uneven Downsides of Risk

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.

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.

📮 Join the Discord

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

🗞️ Subscribe to The Tea Break

We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.

🧡 Leave a Review

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

Why Can't You Go Faster With AI? Focus on the Friction to Find Out

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.

🙏 Today's Episode is Brought To you by: Unblocked

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.

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.

📮 Join the Discord

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

🗞️ Subscribe to The Tea Break

We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.

🧡 Leave a Review

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

Software Engineering Principles That Still Hold Up in an Agentic World - Old Lessons Made New

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.

🙏 Today's Episode is Brought To you by: Unblocked

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.

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.

📮 Join the Discord

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

🗞️ Subscribe to The Tea Break

We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.

🧡 Leave a Review

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

Principles Oriented Thinking as a Durable Skill in an AI First World

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.

🙏 Today's Episode is Brought To you by: SerpApi

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.

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.

📮 Join the Discord

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

🗞️ Subscribe to The Tea Break

We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.

🧡 Leave a Review

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

What the Science Actually Says About Effective Feedback

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.

🙏 Today's Episode is Brought To you by: Unblocked

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.

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.

📮 Join the Discord

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

🗞️ Subscribe to The Tea Break

We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.

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

Rebuilding Your Mental Models In the Midst Of an AI Tech Revolution

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?"

🙏 Today's Episode is Brought To you by: SerpApi

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.

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.

📮 Join the Discord

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

🗞️ Subscribe to The Tea Break

We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.

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

Practice Isn't Enough for Senior Engineers - Adaptation Is a Key Skill in an AI-First Industry

How do you consolidate all of the advice you receive? More importantly, how can you put it into practice day in and day out? We'll talk about two strategies for making this happen in today's episode.
🙏 Today's Episode is Brought To you by: Rollbar
Rollbar is the leading platform that enables developers to proactively discover and resolve issues in their code, allowing them to work on continuous code improvement throughout the SDLC. Rollbar has plans for all situations, from free to large enterprise. With Rollbar, developers deploy better software faster, and can quickly recover from critical errors as they happen.
📮 Ask a Question
If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.
📮 Join the Discord
If you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community 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.

Assimilating Advice - Dealing with Information Overload

Słuchaj i czytaj kiedy chcesz

Możesz polubić także ...