Agile Software Engineering

Alessandro

0.0 (0)
Technology

This podcast explores how craftsmanship, architecture, engineering rigor, and organizational practices come together in modern R&D environments. Each edition refines and deepens my earlier reflections, building a coherent and evolving body of knowledge around Agile Software Engineering

May 23

SAFe Light - Part 2: Evolutionary Architecture

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida continues the discussion on SAFe Light and explores why lightweight Agile scaling needs evolutionary architecture. SAFe Light is based on preserving team autonomy while making the essential coordination points visible. But that only works if the architecture supports independent change. Without clear boundaries, explicit dependencies, contract-based integration, fitness functions, and continuous feedback, teams may appear autonomous while remaining blocked by hidden coupling and integration surprises. The episode introduces evolutionary architecture as architecture planned for change: a disciplined way to let systems evolve incrementally without losing coherence. It also explains why strong architecture can reduce the coordination burden in scaled Agile environments. The central idea is simple: when architecture is weak, process expands to compensate. When architecture is strong, process can remain lighter. 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.

25 min
May 15

Self-Learning Machines - What Happens When AI Starts Learning from Itself?

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores one of the most important questions in the next phase of artificial intelligence: what happens when AI starts learning from itself? For years, generative AI has been trained largely on human-created material from the internet. But the internet is changing. More and more text, images, code, summaries, documentation, and online content are now generated or heavily assisted by AI. That raises a difficult question: when future AI systems are trained on the output of earlier AI systems, will they become more capable, or will they slowly lose contact with the richness and diversity of human knowledge? The episode examines both sides of the self-learning machine problem. On one side, poorly controlled recursive training may lead to model collapse, narrowing, and fluent but less grounded outputs. On the other side, well-designed self-learning loops may accelerate progress in areas such as strategic games, reasoning systems, medical treatment optimization, synthetic data generation, and scientific discovery. The central distinction is simple but important: a bad loop says generate, consume, repeat; a good loop says generate, test, filter, learn, repeat. The future of AI may depend less on whether machines learn from machines, and more on whether those learning loops remain connected to reality, evidence, constraints, and human judgment. 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.

21 min
May 8

Please, Stop Saying Generative AI Is “Just” a Statistical Machine

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida challenges one of the most common simplifications about generative AI: that it is “just a statistical machine guessing the next most likely word.” There is a small technical truth in that statement, but it misses the most important part of what happens inside a modern AI model. Before any token is generated, the input is transformed through embeddings, attention mechanisms, neural network layers, contextual representations, and inference. Probability is part of the process, but it is the final step - not the whole explanation. The episode explains, in accessible engineering language, why generative AI is not a human mind, not a truth machine, but also not a simple autocomplete toy. It explores how layered neural processing, context, intent, and representation allow these systems to produce surprisingly coherent and useful outputs - and why reducing all of that to “just guessing the next word” is not an explanation, but an oversimplification. 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.

24 min
May 1

Ethics of Software Engineering

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores the role of ethics in modern software engineering. As software increasingly shapes critical systems and human behavior, and as AI introduces systems whose behavior cannot always be fully predicted, the question is no longer only what we can build, but whether we should build it. The episode reflects on why ethics is often overlooked in software engineering, how responsibility shifts in the presence of complex and adaptive systems, and how the ACM/IEEE Code of Ethics can serve as a practical framework for navigating difficult decisions. If you are building software in today’s increasingly complex and AI-driven landscape, this episode offers a grounded perspective on responsibility, judgment, and the role of ethics in engineering practice. 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.

26 min
Apr 25

What Really Defines High-Quality Software?

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores the gap between engineering quality and customer-perceived quality. While engineers often define quality in terms of architecture, testing, and process, customers evaluate it through experience: whether the software works, whether it is easy to use, whether it is reliable, and whether it performs without friction. The episode reflects on why many essential engineering practices remain invisible when they work well, why elements like security are expected but rarely noticed, and how this disconnect can lead teams to optimize for the wrong signals. If you are building software in complex environments, this episode offers a grounded perspective on how to align engineering discipline with what truly defines quality from the outside. 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.

23 min
Apr 20

SAFe Light - Balancing Agile and Enterprise

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores how organizations can scale Agile without introducing unnecessary coordination overhead. The episode examines the fundamental tension between autonomy and alignment, the limits of both pure Agile and full SAFe, and introduces SAFe Light as a pragmatic, engineering-driven alternative. It highlights how dependency visibility, strong architectural discipline, and lightweight planning can replace heavy coordination structures while maintaining system coherence. Please subscribe to the podcast if you find it useful. And if you want to go deeper, you can also read the full article in 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.

24 min
Apr 12

AI and Predictive Project Management - From Reporting to Steering

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores the shift from hindsight-based project management to AI-supported predictive approaches. The episode examines what predictive analytics actually adds beyond traditional reporting, where it can provide real value, and where it can create a false sense of certainty if misunderstood. It also highlights the importance of integrating predictions into real decision-making and maintaining strong engineering discipline in a data-driven environment. 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.

24 min
Apr 9

Why Do Agile Projects Still Fail? Are We Really Doing Better?

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores a fundamental question: Are we actually getting better at delivering software? Despite widespread adoption of Agile practices, many projects still miss deadlines, exceed budgets, or deliver reduced scope. The visible failure of the past has not disappeared — it has evolved into a more subtle and persistent form. This episode examines how modern Agile environments can mask misalignment instead of exposing it, how structured approaches such as Scaled Agile Framework can reintroduce delivery pressure at scale, and why continuous delivery does not necessarily mean controlled delivery. It also introduces practical ways to detect and address these issues early, including identifying leading indicators of misalignment and using mechanisms such as a risk mitigation buffer to create space for corrective action. Because Agile improves outcomes — but it does not remove the fundamental challenges of software delivery. If you are leading teams, working in complex delivery environments, or trying to make sense of why projects still struggle despite better processes, this episode offers a grounded and practical perspective. Please subscribe to the podcast if you find it useful. And if you want to go deeper, you can also read the full article in 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.

26 min

This podcast explores how craftsmanship, architecture, engineering rigor, and organizational practices come together in modern R&D environments. Each edition refines and deepens my earlier reflections, building a coherent and evolving body of knowledge around Agile Software Engineering

Creator

Alessandro
Years Active

2025 - 2026
Episodes

34
Rating

Explicit
Copyright

© 2026 Agile Software Engineering
Show Website

Agile Software Engineering