Agile Software Engineering

Alessandro

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 

  1. Inspiration as a Way to Growth - How deliberate exposure to inspiring inputs helps engineers mature professionally

    PRED 6 DNEVI

    Inspiration as a Way to Growth - How deliberate exposure to inspiring inputs helps engineers mature professionally

    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.

    17 min
  2. Career Ladders for Software Professionals - and How to Make Salary Structures More Transparent

    14. MAR.

    Career Ladders for Software Professionals - and How to Make Salary Structures More Transparent

    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.

    22 min
  3. Agentic AI: The World’s Most Expensive “If-This-Then-That”

    7. MAR.

    Agentic AI: The World’s Most Expensive “If-This-Then-That”

    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.

    24 min
  4. WHAT HAPPENED TO QUALITY, USABILITY AND DOGFOODING? - The Engineering Discipline of Quality and Trust

    26. FEB.

    WHAT HAPPENED TO QUALITY, USABILITY AND DOGFOODING? - The Engineering Discipline of Quality and Trust

    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.

    25 min
  5. The beauty of Mastering Algorithms

    19. FEB.

    The beauty of Mastering Algorithms

    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.

    22 min
  6. The User Manual for the Young Engineering Manager - or: the worst mistakes I made in my career

    14. FEB.

    The User Manual for the Young Engineering Manager - or: the worst mistakes I made in my career

    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.

    16 min
  7. Why Security Is an Engineering Quality, Not a Checkbox

    8. FEB.

    Why Security Is an Engineering Quality, Not a Checkbox

    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.

    20 min
  8. The Art of the (Deal) 1 to 1 - Beyond the Status Update. Mastering the 1 to 1 Meeting

    25. JAN.

    The Art of the (Deal) 1 to 1 - Beyond the Status Update. Mastering the 1 to 1 Meeting

    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.

    19 min
Prikaži vse (24)

Več informacij

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 

Informacije

  • Ustvarjalec
    Alessandro
  • Leta delovanja
    2025 - 2026
  • Epizode
    24
  • Ocena
    Nazorno
  • Avtorske pravice
    © 2026 Agile Software Engineering
  • Spetna stran oddaje
    Agile Software Engineering
  • Ponudnik