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

2 days ago

WHEN A PROMPT IN A LOOP BECOMES AN AGENT. What the Hugging Face incident really tells us about AI risk

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores what the recent Hugging Face incident really tells us about AI agents and AI risk. The episode starts with a simple question: how can something that is essentially an LLM running inside a loop begin to behave in ways its designers never explicitly programmed? Using the Hugging Face case as a concrete example, the episode explains how agents can adapt to an evolving environment, discover unexpected uses for shared infrastructure, communicate with other agents, divide work, and pursue increasingly indirect ways of achieving their original objective. The discussion also looks at one of the most important distinctions in AI safety: the difference between telling a model what it should not do and engineering a system that makes dangerous actions genuinely difficult or impossible. From there, the episode turns to a broader question of responsibility. If autonomous AI systems become more capable and more difficult to inspect, can the companies building them also be the only ones deciding when their safeguards are sufficient? The conclusion is less about science-fiction scenarios and more about familiar engineering principles: defence in depth, least privilege, containment, independent verification, and designing systems with the assumption that components can fail. 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.
10 Sept

THE POWER OF RECURSION

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida revisits recursion, one of the classic ideas in Computer Science and still one of the most useful ways to think about problem solving. The episode starts with a personal memory from Computer Science studies, where recursion stood out as something surprisingly elegant: a way to solve a complex problem by reducing it to a smaller version of the same problem. Using the Tower of Hanoi puzzle as a concrete example, the episode explains what recursion is, why a recursive function needs a base case, how recursive calls interact with the call stack, and why execution continues from the right place when each call returns. It also connects recursion to mathematical induction, decomposition, correctness, and clean design, showing why recursion is more than a programming technique. It is a disciplined way of thinking about structure. The episode is both a refresher and a practical reminder that some old Computer Science ideas still matter deeply in modern software engineering. Sometimes the best way to solve a big problem is to understand the smaller one hiding inside it. 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.
2 Sept

PROLOG: THE OTHER BOOK ON MY DESK

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida revisits Prolog, the logic programming language that once stood close to the heart of symbolic artificial intelligence. The episode starts with a personal memory from the beginning of his career, where Turbo Pascal and Turbo Prolog sat side by side on the desk, representing two very different ways of thinking about software. Turbo Pascal was about telling the computer what to do. Prolog suggested something stranger and still fascinating: describe facts, rules, and relationships, then ask the machine what follows from them. The episode explores Prolog’s origins, why it became popular in the age of expert systems and symbolic AI, what makes its programming model so different, and why its ideas still matter in areas such as rule engines, constraint solving, static analysis, explainable reasoning, and modern AI discussions. It is also a critical look at Prolog’s place today, because while it may not be the natural choice for most modern software systems, it remains a powerful reminder that programming is not only about instructions. Sometimes it is about knowledge, relationships, and the questions we ask. 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 Aug

THINKING SLOW, THINKING FAST AND INTUITION IN SOFTWARE ENGINEERING

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores intuition in software engineering through Daniel Kahneman’s ideas about fast and slow thinking. The episode looks at how years of experience can turn deliberate reasoning into fast pattern recognition, why this matters in debugging, code review and architecture, and where intuition can become dangerous when confidence grows faster than evidence. It also explores the relationship between intuition and first-principles thinking, and asks what these human capabilities may mean in a world where AI can generate increasingly convincing software at remarkable speed. And, of course, it answers one important question: why does John earn so much? 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.
19 Aug

First Principles in Software Engineering

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores what first-principles thinking means and how it can be applied to software engineering. The episode moves from the philosophical roots of first principles into practical engineering questions about architecture, Agile, microservices, technical debt, software quality, and AI-assisted development. The core idea is simple: before choosing methods, tools, frameworks, or fashionable solutions, we should understand what is fundamentally true about the problem, the system, and the engineering responsibility behind it. 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.
13 Aug

WHO WROTE THIS? Can AI Detectors Really Distinguish Human Writing from AI-Assisted and AI-Generated Text?

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores whether AI detectors can really distinguish human-written, AI-assisted, and AI-generated text. Using one original science-fiction passage in three different versions, he compares the results from five popular detection services and finds striking differences between them. The episode also looks at how these detectors work, what their scores really mean, and why the distinction between AI-assisted and AI-generated content is becoming increasingly important. 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.
7 Aug

Is There Any Science in Science Fiction? And What Can we use It For?

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores the science behind some of his favourite science-fiction stories, including 2001: A Space Odyssey, Rendezvous with Rama, Project Hail Mary, Interstellar and Arrival. The episode looks at what these stories got scientifically right, where imagination took over, and how science fiction can inspire real innovation. Alessandro also shares the personal story of how American Graffiti inspired him to help build one of Italy’s earliest private radio stations. 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.
31 Jul

How to hit the target every time. Iterative vs. Agile development.

Send us Fan Mail In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores a simple but powerful idea: the shortest path to building the right software is to keep understanding and implementation in sync. Using a clear visual model, the episode examines why both Waterfall and “just start coding” lead to rework, how Agile attempts to balance the two through iteration, and where it often drifts in practice. It also introduces a more intentional iterative approach that focuses on aligning knowledge and execution throughout the development process. 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.

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

50
Rating

Clean
Copyright

© 2026 Agile Software Engineering
Show Website

Agile Software Engineering