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

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

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

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

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

In this episode of the Agile Software Engineering Deep Dive, Alessandro Guida explores what happens when AI enters the Agile software lifecycle.AI is rapidly being adopted across discovery, design, development, testing, and operations. But while it can accelerate execution, it also introduces new risks - from shallow understanding to over-reliance on generated solutions.This episode examines how AI interacts with core Agile principles.Where it strengthens engineering practices. Where it can quietly weaken them. And why real value comes from augmentation - not replacement.Because Agile is not just about moving fast. It is about learning and making better decisions over time.And that is exactly what we need to protect.If you are working with AI in your teams - or considering how to introduce it - this episode offers a grounded perspective on how to do it thoughtfully.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 showThis 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.

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores how modern hiring has evolved - and why that evolution may not be entirely positive.What used to be a deliberate process of evaluating a small number of candidates has gradually become a high-volume pipeline, driven by platforms, metrics, and automation. Applicant Tracking Systems and AI tools help manage scale, but they also shape how decisions are made.This episode examines the consequences of that shift.Why hiring is increasingly optimized for quantity rather than quality.Why generic job descriptions attract large volumes of candidates - but not necessarily the right ones.And why systems designed to filter applications often struggle to recognize real talent.The conversation also introduces a critical distinction between hiring for specialization and hiring for talent. While specialist roles require precision and clarity, identifying talent requires judgment, curiosity, and direct human interaction.Beyond processes and tools, this episode reflects on the broader responsibility of engineering leadership. Hiring is not only about filling positions. It is about shaping teams, culture, and long-term capability.And in the pursuit of efficiency, organizations may be unintentionally damaging their reputation with the very people they hope to attract.If you are a manager involved in hiring - whether early in your career or with years of experience - this episode offers a perspective on how to approach it more consciously.Because hiring is not a pipeline to optimize.It is a judgment to take seriously.If you enjoy thoughtful discussions about engineering leadership, decision-making, and the evolution of software engineering practices, this conversation is for you.Please subscribe to this podcast - it’s the best way to support it.If you are interested in the original article behind this episode, you can also subscribe to the Agile Software Engineering newsletter.Support the showThis 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.

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores the role of curiosity and inspiration in engineering growth.Software engineering is often treated as a purely technical discipline — focused on frameworks, programming languages, architectures, and tools. Yet many of the ideas that shape engineering innovation originate far outside the software field.Throughout history, engineers and scientists have drawn inspiration from mathematics, physics, philosophy, literature, and even science fiction. These disciplines expand how we think about problems, systems, and possibilities.This episode reflects on why curiosity should be considered a professional capability — not just a personal trait. Engineers who explore widely often develop stronger problem-solving skills, more creative thinking, and a broader understanding of the systems they build.The conversation also touches on the role of engineering leadership. Creating high-performing teams is not only about processes and tools, but also about cultivating environments where curiosity, learning, and intellectual exploration are encouraged.Because innovation rarely comes from repeating what we already know.It comes from exploring what we don’t.If curiosity gives you the energy to push the limits of what others believe can be done, you are probably already on the right path.If you enjoy thoughtful discussions about how engineering ideas evolve — beyond frameworks and buzzwords — this conversation is for you.Please subscribe to this podcast — it’s the best way to support it.If you are interested in the original article behind this episode, you can also subscribe to the Agile Software Engineering newsletter.Support the showThis 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.

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores why professional software engineering requires professional career structures.Career ladders are often perceived as rigid or bureaucratic. In reality, they provide clarity about expectations, scope of impact, and sustained behavior at each stage of an engineering career. Without that clarity, progression becomes ambiguous and growth conversations lose focus.Alessandro discusses how to define meaningful levels based on responsibility and influence rather than seniority alone, why roles such as Technical Lead should not automatically imply promotion, and how Individual Contributor and Management paths must remain structurally distinct yet equally senior.The episode also examines two unhealthy leadership extremes - the purely administrative manager who loses technical depth, and the over-involved “super engineer manager” who never truly transitions into leadership. Healthy engineering management requires technical credibility, product awareness, and organizational responsibility in balance.Finally, the conversation connects career ladders to salary transparency. When expectations are explicit and levels are well defined, compensation discussions move from negotiation to structural alignment.If you care about clarity, fairness, and long-term engineering professionalism, this episode is for you.Please subscribe to the podcast - it is the best way to support it.If you are interested in the full written article behind this episode, you can find it in the Agile Software Engineering newsletter on LinkedIn.Support the showThis 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.

In this episode of The Agile Software Engineering Deep Dive, Alessandro Guida explores the growing excitement around Agentic AI - and tries to separate engineering reality from marketing language.Across podcasts, conference talks, and LinkedIn posts, AI agents are increasingly presented as systems that can plan, reason, and autonomously execute complex workflows. The promise is compelling: software that not only generates text, but actively interacts with other systems and performs useful tasks on our behalf.But what actually happens under the hood?This episode takes a calm engineering look at what “agentic” systems really are. In many cases, they consist of language models connected to tools and services through APIs, operating inside orchestration loops that interpret goals, call tools, and iterate toward a result.Powerful? Absolutely.Magical? Not really.Alessandro walks through a simple practical example of how an AI agent might coordinate actions across email and calendar systems, and reflects on the engineering implications that appear once AI systems start interacting with real infrastructure.Because once an AI system can act - not just generate - questions about reliability, control, observability, and governance quickly emerge.The episode also reflects on a familiar pattern in the technology industry: new ideas often arrive surrounded by enthusiasm and bold claims before eventually settling into more realistic engineering practices.Agentic AI may well become an important part of future software systems. But as with many technologies before it, the real value will likely emerge when the hype slows down, and engineering discipline takes the lead.If you enjoy thoughtful discussions about how modern software engineering evolves - beyond the buzzwords - this conversation is for you.Please subscribe to this podcast - it’s the best way to support it.If you are interested in the original article behind this episode, you can also subscribe to the Agile Software Engineering newsletter.Support the showThis 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.

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

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

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

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

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

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

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

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 innovationNot 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 showThis 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.

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 capabilityNot 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 showThis 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.

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 enoughHow storyboards help validate understanding before code is writtenThe role of UX and interaction design in reducing rework and uncertaintyHow to involve users in shaping experiences, not just approving backlog itemsNot 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 showThis 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.

New podcast episode:“Clean Code, Clean Planet – How Software Design and Coding Practices Shape Our Digital Carbon Footprint”In it, I explore a simple idea that often goes unnoticed: software may be virtual, but its impact is physical.Everyday engineering decisions — from algorithms and design choices to architecture, usability, and team culture — quietly consume real energy and scale globally.The episode looks at this through six familiar engineering lenses:🔹 Clean Code🔹 Clean Design🔹 Clean Architecture🔹 Clean Usability🔹 Clean Responsibility🔹 Clean ThinkingThis is not about green rules or guilt. It’s about awareness — and seeing good engineering not only as a quality practice, but as a contributor to a more sustainable digital world.💡 Clean engineering isn’t about doing more. It’s about doing only what truly matters — clearly, efficiently, and consciously.👉 Read the full article here: “Clean Code, Clean Planet”Support the showThis 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.

I just published an improved version of my article: “From Toyota to Agile: Using Lean Tools in Engineering”In it, I share how a few Lean tools I first learned from “The Toyota way” have followed me throughout my career - and how they fit beautifully into Agile engineering to make it more powerful and effective.Some of my favorites include: 🔹 Value Stream Mapping 🔹 Visual Management 🔹 Kanban 🔹 Kaizen 🔹 5 WhysThey may sound simple, but when applied consistently they can transform how teams collaborate, focus, and deliver.💡 Agile brings adaptability. Lean brings clarity and discipline. Together, they make engineering teams unstoppable.👉 Read the full article here: “From Toyota to Agile: Using Lean Tools in Engineering”Support the showThis 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.

Throughout my career, the most meaningful achievements were not technologies, architectures, or deliveries - they were the people who grew around me. Many of them went on to become leaders, architects, innovators, and trusted voices in their organisations. For me, that has always been the real success measure of leadership.In this new podcast, I reflect on what it truly means to be surrounded by talents - how to recognise potential early, how to support people without micromanaging, and why mentorship is not an optional activity, but a core responsibility for anyone in a leadership position.I also connect these experiences to research on psychological safety, stretch learning, and mentoring - and even to the Danish ATU initiative, which shows that talent development can begin much earlier than we often think.If you are a leader, an aspiring leader, or someone who simply cares about people and growth, I hope this reflection resonates.👉 Read the full article here: Surrounded by TalentsSupport the showThis 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.

The Secrets of Efficient Stand-Ups - Why They Fail, and How to Make Them WorkMost stand-ups feel like this:“Yesterday I did X, today I’ll do Y, no blockers.”A round of micro-monologues… and very little actual coordination.In my new article, I explore why stand-ups so easily drift into status reporting-and how small changes can transform them into the most valuable 15 minutes of your day.Here’s what you’ll take away: • Why focusing on individuals destroys team flow • How walking the board unlocks real collaboration • The one question that instantly elevates any stand-up👉Read the full article hereSupport the showThis 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.

SPECIAL EDITION!“THE HUMAN AI DETECTORS - And Other Familiar Enemies of Progress”Today’s post is a little different from my usual deep dives into engineering culture, architecture, and leadership.This one is a Special Commentary Edition - because sometimes the funniest (and most revealing) lessons about modern work come from outside the codebase.We’ve all lived through the same old warnings:🧮 “Calculators will make you forget math.” 📱 “SMS will make you forget grammar.” 👥 “Social media will destroy real friendships.”And now the 2025 classic:🤖 “AI will make your brain stop working.”Meanwhile, anyone who has actually used an LLM knows the opposite is true:👉 AI is a productivity multiplier.But here’s where the story gets interesting…There’s a growing group I call THE HUMAN AI DETECTORS - often in recruiting and headhunting - who live in a perfect paradox:“We help you improve your LinkedIn with AI!” …but also… “We reject applications if they used AI!”It’s like telling a finance candidate not to use Excel,an engineer not to use CAD,or a driver not to use power steering because “real drivers use muscle.”In this commentary piece, I explore why this mindset exists, why it’s flawed, and what it reveals about our relationship to technology, truth, and talent.This one is humorous - but with a serious message underneath.👉 Read the full Special Commentary Edition here: THE HUMAN AI DETECTORS - And Other Familiar Enemies of ProgressSupport the showThis 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.

SAFe can bring structure and alignment across large organizations.But applied mechanically, it often feels less agile than Scrum — and resistance follows.In this article, I argue that real success comes from:Anchoring SAFe in mindset over mechanicsAdapting it to context, not copying a frameworkEmpowering Scrum Masters and Release Train Engineers as true change agents🔎 Does SAFe amplify agility in your organisation — or add unnecessary overhead?👉 Read the full article here:   Support the showThis 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.

Vibe Coding is here. And it’s impressive -but also risky.We’re entering a new era where developers describe what they want, and AI generates entire applications: logic, UI, tests… everything.So the big question becomes:Is this the breakthrough we’ve been waiting for -or just the latest silver bullet?To find out, I built a real example using only natural language.It worked -but it also revealed important risks:➡️ Vibe coding jumps directly from prompt to code.➡️ It skips design and architecture completely.➡️ Without those, systems become fragile and impossible to oversee.In the podcast, I cover:• what vibe coding actually is• a hands-on example (user story → code → tests)• the architectural risks nobody talks about• how engineering discipline restores safety• a simple hybrid model for real-world use• platforms worth exploringIf you’re curious about how AI will fit into modern R&D -this podcast hopefully will give you some answers.👉 Read the full article here: https://www.linkedin.com/pulse/vibe-coding-speed-hype-engineering-reality-alessandro-guida-t7jsf/  Support the showThis 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.

Most Agile models assume teams can work fully independently.But in real R&D organisations — especially those with shared platforms, legacy systems, or compliance constraints — inter-team dependencies are everywhere.Ignoring them doesn’t make you more “agile.”It just makes the blockers invisible.In this podcast, I explain how light-weight discipline (not heavy frameworks) can dramatically improve flow, quality, and predictability — even without going full SAFe.You’ll find:The real challenges hidden inside dependenciesPractical, discipline-based techniques that work in any organisationCommon pitfalls most teams fall intoA more pragmatic, engineering-driven view of agilityIf you want to read the full article it is here.Support the showThis 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 edition examines Agile Transformations — not as a process rollout, but as an organizational maturity journey.If Agile is to help us build better software, not just follow rituals, we need to understand how culture, architecture, leadership, and context interact.I hope you’ll enjoy this updated edition — and join the newsletter if you haven’t already.You can read the full article here.Support the showThis 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.

From Moonshot to Sustainable InnovationMost companies celebrate their first big idea — the moonshot that gets them off the ground. But very few manage to repeat it.Why?Because real, continuous innovation isn’t luck.It’s a system — built on people, environment, and structure.In this new article, I share the simple 3-part framework I’ve used across multiple companies to transform “once-in-a-while creativity” into a repeatable innovation engine:🔎  Hire for curiosity 🎬  Feed the creative engine 🔁  Institutionalize the innovation processThese ideas were shaped over many years: from early startup environments to Inspiration Days, innovation sprints, and team cultures obsessed with learning.If your organization wants more than a single breakthrough — if it wants sustainable innovation — this is for you.If you want to read the full article it is here.Support the showThis 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.

It’s time to treat software engineering seriously.For years, Agile has relied on playful metaphors — tribes, squads, trains, sprints, even pigs and chickens.These made the frameworks easier to sell, but they also made our profession look less like engineering and more like a playground.Today our systems run hospitals, railways, satellites, and financial infrastructure.The language, mindset, and expectations must match that responsibility.In this second issue of the Agile Software Engineering newsletter, I argue for a shift toward clarity, engineering discipline, and frameworks rooted in Lean, DevOps, and architecture — without losing creativity or innovation.If you would like to read the full article it is here.Support the showThis 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.