Agile 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.

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.

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.

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.

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.

Send us Fan Mail

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores the difference between generating code and learning software engineering.

Modern coding AI has been trained on enormous quantities of publicly available software. Some of that code is excellent, but much of it is also outdated, inefficient, insecure, poorly tested, difficult to maintain, or disconnected from the realities of commercial software development.

The episode examines several recurring concerns in AI-generated software: black-box code that developers may accept without fully understanding, inefficient implementations, error handling that does not integrate with the surrounding product, inconsistent security, and user interfaces created without user research, workflow analysis, prototyping, or human feedback.

It also considers a more systemic risk: what happens when AI-generated code increasingly becomes part of the training material for future AI models? Weak patterns may be copied, normalised, and amplified until commonly generated code is mistaken for well-engineered code.

More agents do not automatically mean better software. Ten coding agents today and fifty tomorrow may simply produce more code, more complexity, and more work that still requires human review.

AI can be an extraordinarily valuable engineering tool, but it does not assume responsibility for the result. The engineer remains accountable for understanding, testing, securing, maintaining, and operating whatever ultimately enters the product.

The episode concludes with The Old Grumpy Engineer’s Trust Test, a humorous examination of whether engineering trust should ever be granted automatically-and a brief, nostalgic appearance from Clippy.

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 what happens when corporate security is added in layers without enough attention to workflow, usability, recovery, and productivity.

Using the metaphor of painting yourself into a corner, the episode looks at a familiar modern workplace problem: VPNs, tunnels, multi-factor authentication, device compliance, strict password policies, authenticator apps, app PINs, short screen timeouts, and repeated confirmation prompts that may each make sense in isolation, but together can create serious friction for employees.

This is not an episode against security. Quite the opposite.

It is an episode about designing security properly.

The discussion covers why security should be treated as an engineering system with real users, real workflows, measurable performance requirements, failure modes, and recovery paths. It also looks at common traps such as MFA recovery loops, where the system sends the confirmation code to the very phone that has just been lost.

The episode argues that security teams and engineering teams should ask a simple but often forgotten question:

How does the complete workflow actually work for the human being who has to use it?

From use cases and workflow testing to acceptable friction, hardware support, passkeys, biometrics, and better recovery design, this episode is a reminder that good security should not only reduce risk. It should also help people work safely without constantly fighting the system.

Because the most secure system in the world is not very useful if nobody can get their work done.

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 continues the two-part journey into compiler theory.

Part 1 focused on BNF, syntax, and grammar. Part 2 moves into compiler thinking itself: LEX, YACC, compilers, interpreters, syntax trees, the Dragon Book, and the evolution from classic compiler pipelines to modern development ecosystems.

For many software engineers who studied computer science in earlier decades, compiler theory was part of the foundation. It taught us how programming languages are defined, parsed, checked, transformed, optimized, and executed.

Today, most developers are not writing compilers by hand. But the ideas behind compilers are still everywhere: in build systems, query engines, static analyzers, IDEs, code generators, rule engines, security scanners, infrastructure-as-code tools, and AI coding assistants.

This episode explores why compiler thinking still matters when we design APIs, configuration formats, workflow definitions, domain-specific languages, rule systems, and AI-assisted development tools.

It also revisits the classic distinction between compilers and interpreters, explains how modern compilers have evolved, and reflects on the connection between programming languages and AI prompts.

This is not a nostalgic look back at old tools.

It is a reminder that when human intent must become reliable machine action, the old lessons of compiler theory are still surprisingly modern.

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 begins a two-part journey into compiler theory with a look at Backus-Naur Form, or BNF.
For many software engineers who studied computer science in earlier decades, BNF belonged to the world of compilers, formal languages, syntax, parsing, YACC, and the famous Dragon Book. Today, many developers may never encounter it directly.
But the need for it has not disappeared.
Whenever we add formulas, macros, templates, filters, workflow conditions, configuration syntax, rule engines, or domain-specific languages to an application, we are doing language design. Often informally. Often accidentally.
And that is where complexity starts to grow.
This episode explains why syntax is not just documentation, why a small language is still a language, and why grammar matters when applications become programmable.
It is not a call for every developer to become a compiler engineer. It is a reminder that some old computer science disciplines remain deeply relevant, especially when we give users the ability to express logic inside our systems.
Part 1 focuses on BNF, syntax, and grammar.
Part 2 will continue with compiler thinking more broadly: lex, YACC, compilers, interpreters, the Dragon Book, and why the discipline still matters in the age of modern development tools and AI-generated code.

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 takes a historical and slightly playful look at Lisp - one of the strange little languages that helped shape the early world of artificial intelligence.

Long before AI became associated with Python, neural networks, GPUs, and large language models, artificial intelligence was also about symbolic reasoning, rules, lists, logic, search, and knowledge representation. Lisp was built for that world. Its focus on symbolic expressions, recursion, lists, and the close relationship between code and data made it a natural fit for early AI research.

This episode is not a call to abandon modern AI tools and return to 1960s programming. It is an invitation to understand where some of the deeper ideas in AI and software engineering came from - and why an old language full of parentheses can still feel strangely modern.

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.