Most of the hardest moments in our careers don’t come from bad code.They come from protecting a version of ourselves.

In this episode of Beyond the Stack, Michael explores how the professional identity we build over time can quietly distort clarity—especially in technical work. What begins as competence, experience, and expertise can harden into something fragile. And once that happens, feedback stops feeling like information and starts feeling like a threat.

Rather than framing this as immaturity or arrogance, this episode looks at ego in a more precise way: not as a flaw to eliminate, but as a constructed professional identity that often goes unnoticed—and therefore unchecked.

Through familiar examples from software and IT work, Michael unpacks how this shows up in everyday environments: code reviews that turn into negotiations, architectural discussions that become performances, and retrospectives that quietly devolve into blame avoidance.

The focus isn’t on fixing others. It’s on learning to see what’s happening in ourselves.

In this episode, we explore:

* Why smart, capable professionals sometimes defend fragile decisions

* How feedback becomes personal without anyone intending it to

* What “ego” really means in a professional context—and why it’s often misunderstood

* Common ways ego distorts perception:

* Selective hearing

* Narrative locking

* Threat inflation

* Why technical roles are especially vulnerable to identity attachment

* Why ego isn’t the enemy—but an unnoticed ego is

Reflective questions offered in this episode:

These aren’t actions to take. They’re questions to notice.

* What part of this feedback feels threatening?

* If I weren’t protecting my role, what would I hear differently?

* What matters more here: being right, or seeing clearly?

* Am I defending a decision—or an identity?

Closing reflection:

When we work to protect the professional identity we’ve constructed, clarity tends to slip away.But when that identity is brought into the light—seen for what it is—it loses its grip.

This week, notice the moment when certainty tightens.That’s usually where clarity is trying to get your attention.

Mentioned in this episode:

* Beyond the Commit: The Human Side of Software Development

* Beyond the Stack on Substack

* Michael Payne on LinkedIn

Episode Summary

In this episode, Michael explores the idea that teams are living systems, not static structures. Using a simple but revealing example from coaching youth soccer, he unpacks how teams change even when the surface details appear identical: same uniforms, same schedules, same rules.

From there, the episode draws a direct parallel to professional and engineering teams. People come and go. Responsibilities shift. Stressors appear. Energy changes. And yet we often behave as if teams should remain stable once assembled.

This episode introduces two foundational ideas that will recur throughout the podcast: impermanence and interdependence. Together, they explain why the same process can thrive in one team and fail in another, and why mechanical fixes often fall short when applied to human systems.

What We Cover in This Episode

* A youth soccer team as a living system, not a static group

* Why teams behave more like weather systems than machines

* How professional teams change even when structures stay the same

* The limits of linear models like “forming, storming, norming, performing”

* Why teams are never truly “done forming”

* How team changes are often driven by forces outside anyone’s control

* Technical and non-technical examples of cascading dependencies

* The difference between complicated systems and complex systems

* Applying state management thinking to human systems

* Why engineers default to mechanical fixes for organic problems

* The idea of skillful intervention rather than reactive control

* How awareness functions as a professional skill

Key Ideas from the Episode

Teams are always in motion.Even high-performing teams are constantly changing due to shifting priorities, personal stress, new responsibilities, and external pressure.

Stability is an illusion.The idea that a team can be assembled once and remain unchanged is comforting, but inaccurate.

Linear models flatten reality.Frameworks like forming and storming are useful, but they miss the ongoing, non-linear nature of real teams.

Change creates cascading effects.Just like in software systems, one change in a team often ripples outward in ways that are not immediately visible.

Mechanical fixes don’t always work on living systems.Adding process, tooling, or structure can help, but only if applied skillfully and with awareness of the system involved.

Awareness is not passive.Observing before acting allows better questions, better timing, and better decisions.

Influence is larger than it appears.Every interaction, and even silence, adds or removes tension from a team.

Who This Podcast Is For

* Engineers who notice friction in their teams but struggle to explain it

* Technical leaders trying to understand why processes succeed or fail unevenly

* Managers and architects navigating constant organizational change

* Developers interested in applying systems thinking beyond code

* Readers of Beyond the Commit looking for deeper exploration of its themes

* Anyone curious about leadership without control, and clarity without rigidity

If this is you, subscribe below to get updates directly to your email!

A Reflection Invitation

This week, Michael invites listeners to notice:

* One small shift in your team’s energy, pace, or communication

* Something that changed recently, even if it seemed minor at the time

* Where you feel the urge to immediately “fix” instead of observe

* How your presence, or absence, affects the system around you

These observations are often where the real work begins.

Mentioned in This Episode

* Beyond the Commit: The Human Side of Software DevelopmentMichael’s book on engineering culture, leadership, and the patterns beneath technical work

* Beyond the Stack PodcastA reflective companion to the book, focused on the lived reality of teams and systems

Closing Notes

Teams breathe. They expand and contract. They strengthen and weaken.

When we stop treating teams like machines and begin seeing them as living systems, we trade control for understanding and reaction for awareness.

If this episode resonated, you’ll find deeper reflections and essays on the Beyond the Stack Substack.And if you’ve read Beyond the Commit, many of these ideas will feel familiar, just explored more slowly and conversationally.

Episode 3 arrives soon.

Episode 1 — The Human Layer Beneath All Work

In this opening episode of Beyond the Stack, Michael explores a simple but often overlooked truth in engineering: many technical problems aren’t technical at all. They’re human.

Beginning with a relatable story about two senior developers whose unresolved tension quietly breaks a build, Michael shows how misalignment, ego, unspoken expectations, and emotional discomfort can surface as “technical failures.” He examines why engineering teams often misdiagnose these issues, how process layers accumulate as band-aids over human behavior, and why technical people—especially those who thrive in certainty—can find interpersonal dynamics so uncomfortable.

The episode moves through patterns familiar to anyone who has worked in software: pull request stalemates, meetings that spiral, shifting requirements driven by unseen pressures, and the subtle ways identity and ego distort clarity. Michael reflects on his own journey, recognizing how over-identifying with his role and expertise once narrowed his perspective and slowed collaboration.

He then introduces awareness as a genuine professional skill—one that includes noticing internal reactions, reading the emotional temperature of a room, and understanding the human story behind technical decisions. Practical guidance follows: slowing down root-cause analysis, distinguishing events from interpretation, looking for relational patterns instead of isolated incidents, and approaching complex situations with humility.

By the end, listeners are invited to consider a deeper question:Why do so many engineering problems look technical, yet behave human?

This episode sets the foundation for the series by helping engineers, leaders, and teams see the hidden layer that shapes every project—the human one.

Episode 0 — Why This Podcast Exists

In this introductory episode, Michael shares why Beyond the Stack was created and what you can expect from the show. After 25 years in software, he’s learned that most engineering problems are human problems — shaped by trust, tension, leadership, ego, and the quiet patterns inside every team.

Beyond the Stack explores these hidden dynamics with a reflective, mindful approach. This episode introduces the core themes: emergent leadership, team culture, the difference between control and clarity, and why engineers often lack language for the human side of their work.

In This Episode:

Why engineering lessons are rarely about code

Invisible dynamics inside teams

The impact of ego, fear, and unclear authority

Why great teams succeed even with simple systems

The motivation behind the book Beyond the Commit

What this podcast aims to offer engineers and leaders

Reflection Invitation:Notice this week who people turn to when things get uncertain, how tension rises, and where you might loosen your grip.

Find the written companion at the Beyond the Stack Substack.