Send us Fan Mail

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida reflects on a question many of us quietly experience as users:

What happened to quality?

In the race to release faster, ship AI features, and stay ahead of competitors, software increasingly “almost works.” Small usability irritations, fragile integrations, and premature releases are becoming normalized.

This episode is not about blaming a specific product or technology. It is about examining a broader cultural shift in engineering priorities.

Alessandro revisits the discipline of “dogfooding” - the practice of using your own software before releasing it - and reflects on why reliability, usability, and professional testing rigor are not nostalgic ideals, but foundational responsibilities.

The conversation also expands beyond apps and web platforms. As software moves into appliances, vehicles, and physical systems, quality becomes more than convenience. It becomes trust.

This episode sets the stage for a deeper exploration of what Alessandro defines as the four pillars of software quality: Security, Reliability, Usability, and Performance.

If you care about building systems people can truly depend on, this conversation is for you.

Please subscribe to this podcast - it’s the best way to support it.

If you’re interested in the original article behind this episode, make sure to subscribe to the Agile Software Engineering newsletter.

Support the show

This Podcast is an audio version of the written Agile Software Engineering newsletter.  If you want to go deeper, don't forget to subscribe the newsletter too.

Send us Fan Mail

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida reflects on one of the most fundamental - and increasingly overlooked - pillars of professional software engineering: mastering algorithms.

Modern software development makes it possible to assemble complex systems quickly through frameworks, libraries, integrations, and AI-assisted tooling. While this represents real progress, it can also blur an important distinction. There is a difference between building systems by combining existing components and understanding the principles that make those systems work.

This episode explores why algorithmic thinking remains essential for long-term engineering maturity. Through a personal story from early in his career - where a geometric clipping algorithm resolved a real performance bottleneck - Alessandro illustrates how first-principles reasoning becomes decisive when abstractions break down.

These reflections are not presented as an academic lecture or a rejection of modern tools, but as experience-based insights shaped by years of working with performance-critical and safety-conscious systems across different domains.

The goal is not to romanticize the past, but to highlight a simple and durable truth: technologies evolve rapidly, but the underlying ideas endure. Engineers who understand algorithms and complexity are better equipped to design, evaluate, and adapt systems when ready-made solutions fall short.

If you are a student, an engineer early in your career, or a manager responsible for growing technical depth within your team, this episode offers perspective on why mastering algorithms is not an academic luxury - but a professional foundation.

Please subscribe to this podcast. It’s the best way to support it.
 If you’re interested in the original article behind this episode, make sure to subscribe to the Agile Software Engineering newsletter.

Support the show

This Podcast is an audio version of the written Agile Software Engineering newsletter.  If you want to go deeper, don't forget to subscribe the newsletter too.

Send us Fan Mail

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida reflects on the transition from engineer to engineering manager - and the mistakes he had to learn the hard way.

When engineers step into management roles, they often bring with them the very strengths that made them successful: problem-solving speed, technical clarity, and the ability to see solutions quickly. While these qualities are valuable, they can quietly create unintended consequences. Discussions become shorter. Decisions become centralized. Teams grow dependent rather than autonomous.

This episode explores several of the most impactful early-career management mistakes - including believing it was still his job to be the smartest person in the room, confusing speed with progress, and becoming “too central” in the system.

These reflections are not presented as a leadership framework or a management theory, but as experience-based lessons shaped by years of building and leading engineering teams across different domains and levels of complexity.

The goal is not to discourage engineers from moving into leadership, but to highlight a simple and often uncomfortable truth: leadership is less about brilliance and more about restraint.

If you are a young engineering manager - or considering the transition - this episode may help you avoid strengthening your team’s dependence when you actually intend to build their autonomy.

Please subscribe to this podcast. It’s the best way to support it.
 If you’re interested in the original article behind this episode, make sure to subscribe to the Agile Software Engineering newsletter.

Support the show

This Podcast is an audio version of the written Agile Software Engineering newsletter.  If you want to go deeper, don't forget to subscribe the newsletter too.

Send us Fan Mail

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores why security is not a feature that can be added late in the process, but an engineering quality that emerges from how software systems are designed, built, and maintained.

While security is widely acknowledged as important, it is often treated as a separate activity — handled through checklists, audits, or tools — rather than as an integral part of everyday engineering work. This may feel reassuring, but it frequently leaves architectural assumptions, trust boundaries, and systemic risks unexamined.

This episode reflects on security from three complementary perspectives: secure coding practices, system-level security through architecture and threat modeling, and security as an engineering habit embedded in daily work. Not as a security framework or compliance model, but as a set of experience-based reflections shaped by years of working with security- and safety-critical systems.

The goal is not to turn engineers into security specialists, but to show how clarity, architecture, reviews, and disciplined engineering practices form the foundation for meaningful security outcomes. The episode also touches on how AI is already being used today to support security work — from code analysis and reviews to system-level monitoring — as a practical supplement to human judgment.

Please subscribe to this podcast. It’s the best way to support it.
If you’re interested in the original article behind this episode, make sure to subscribe to the Agile Software Engineering newsletter.

Support the show

This Podcast is an audio version of the written Agile Software Engineering newsletter.  If you want to go deeper, don't forget to subscribe the newsletter too.

Send us Fan Mail

In this episode of The Agile Engineering Deep Dive, Alessandro Guida explores why recurring 1 to 1s are one of the most important - and most misunderstood - practices in engineering leadership.

While most managers agree that 1 to 1s matter, they often drift into polite status meetings focused on tasks, tickets, and delivery details. This may feel efficient, but it frequently leaves motivation, growth, and trust unspoken.

This episode reflects on a simple, experience-based way of structuring 1 to 1s around four human dimensions to  motivation, achievement, power, and belonging. Not as an HR model or framework, but as a practical approach shaped by years of leadership and thousands of conversations.

The goal is not to turn 1 to 1s into performance reviews or therapy sessions, but to show how consistent, well-structured conversations help small issues surface early, build trust over time, and support long-term team health.

Please subscribe to this podcast. It’s the best way to support it.
If you’re interested in the original article behind this episode, make sure to subscribe to the Agile Software Engineering newsletter. 

Support the show

This Podcast is an audio version of the written Agile Software Engineering newsletter.  If you want to go deeper, don't forget to subscribe the newsletter too.

Send us Fan Mail

In this episode of The Agile Engineering Deep Dive, Alessandro Guida revisits the SOLID principles and explores why they still matter in modern software engineering.

In a world of microservices, cloud platforms, and AI-assisted development, SOLID is sometimes seen as outdated or overly focused on code-level concerns. Yet the underlying challenges of software engineering have not changed: managing complexity, reducing coupling, and enabling systems to evolve safely over time.

This episode reflects on how principles like Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion extend far beyond classes and objects - shaping APIs, services, architecture, and organizational resilience.

The goal is not to promote dogma or rigid rules, but to show how timeless design principles help teams build software that remains understandable, testable, and adaptable long after tools, frameworks, and original developers have changed.

Please subscribe to this podcast. It’s the best way to support it.
 If you’re interested in the original article behind this episode, make sure to subscribe to the Agile Software Engineering newsletter.

Support the show

This Podcast is an audio version of the written Agile Software Engineering newsletter.  If you want to go deeper, don't forget to subscribe the newsletter too.

Send us Fan Mail

In this episode of The Agile Engineering Deep Dive, Alessandro Guida explores why hiring should be treated as a long-term leadership investment rather than a short-term operational task.

Many organizations focus on speed, cost, and visible output when hiring engineers. But these signals often hide the real risks: poor role definition, mismatched expectations, underinvestment in onboarding, and decisions that optimize for the next quarter rather than the next decade.

This episode reflects on how different problems require different hiring strategies, why the number of applicants is a misleading success metric, and how leadership choices during hiring quietly shape culture, capability, and resilience over time.

The goal is not to slow organizations down, but to make hiring decisions more deliberate, responsible, and sustainable - especially in engineering environments where long-term value depends on people, not just processes or tools.

Please subscribe to this podcast. It’s the best way to support it.

If you’re interested in the original article behind this episode, make sure to subscribe to the Agile Software Engineering newsletter.

Support the show

This Podcast is an audio version of the written Agile Software Engineering newsletter.  If you want to go deeper, don't forget to subscribe the newsletter too.

Send us Fan Mail

Do legacy systems really slow organizations down - or are they quietly holding everything together?

In this episode of The Agile Engineering Deep Dive, Alessandro Guida challenges a belief many organizations take for granted: that legacy software is something to avoid, escape, or replace as quickly as possible.

When legacy systems are neglected or treated as second-class citizens, risk accumulates quietly. Knowledge concentrates, change becomes expensive, and business-critical value is taken for granted - until something breaks and the impact suddenly becomes visible.

This episode explores:
 • The many faces of legacy - from missing documentation to compliance constraints
 • Why legacy systems often represent core business value
 • Lessons from Y2K and other “invisible until critical” moments
 • How incremental modernization reduces risk without stopping the business
 • Why stability is a prerequisite for sustainable innovation

Not an argument against innovation.
Not nostalgia for old technology.
A challenge to how leaders think about responsibility, risk, and long-term value.

If you care about building organizations that can innovate without sacrificing stability - and that treat legacy as a managed asset rather than an unmanaged risk - this episode is for you.

Please subscribe to this podcast. It’s the best way to support it.
If you’re interested in the original article behind this episode, make sure to subscribe to the Agile Software Engineering newsletter.

Support the show

This Podcast is an audio version of the written Agile Software Engineering newsletter.  If you want to go deeper, don't forget to subscribe the newsletter too.

Send us Fan Mail

Do hero cultures really make organizations strong - or do they quietly make them fragile?

In this episode of The Agile Engineering Deep Dive, Alessandro Guida challenges a belief many organizations take for granted:  that relying on heroes is a sign of strength.

When systems depend on exceptional individuals to keep things running, knowledge concentrates, ownership blurs, and resilience suffers. What looks like efficiency in the short term often turns into risk, technical debt, and organizational fragility over time.

This episode explores:
 • Why hero cultures emerge - and why they don’t scale
 • The hidden risks of knowledge silos and low bus factor
 • How professional engineering practices enable shared ownership and resilience
 • Why legacy systems can be growth opportunities, not career dead ends
 • What leaders can do to replace heroics with sustainable capability

Not an attack on talented individuals.
Not a call for more process.

A challenge to the systems and incentives that turn professionalism into heroics.

If you care about building organizations that scale beyond individuals - and remain resilient when people change - this episode is for you.

Please subscribe to this podcast. It’s the best way to support it.
If you’re interested in the original article behind this episode, make sure to subscribe to the Agile Engineering newsletter.

Support the show

This Podcast is an audio version of the written Agile Software Engineering newsletter.  If you want to go deeper, don't forget to subscribe the newsletter too.

Send us Fan Mail

Do we really put users first in Agile - or do we just ask them to debug our assumptions?

In this episode of The Agile Engineering Deep Dive, Alessandro Guida challenges a common Agile belief: that frequent feedback automatically means meaningful user involvement.

When users are shown isolated features instead of full interaction flows, feedback becomes guesswork. User stories describe intent, but without UX context, interaction design, or storyboards, teams often build correct functionality into the wrong experience.

This episode explores:

• Why user stories alone are often not enough
• How storyboards help validate understanding before code is written
• The role of UX and interaction design in reducing rework and uncertainty
• How to involve users in shaping experiences, not just approving backlog items

Not anti-Agile.
Not anti-user stories.
A challenge to how we use them.

If you care about building the right thing - not just building fast - this episode is for you.

Please subscribe to this Podcast. It is the best way to support it.
Also, if you are interested in the original article for this podcast make sure to subscribe the Agile Engineering newsletter 👉 here.

Support the show

This Podcast is an audio version of the written Agile Software Engineering newsletter.  If you want to go deeper, don't forget to subscribe the newsletter too.