Senior Software Engineer · XP advocate · Technical coach — based in Milan 🇮🇹

I build software the Extreme Programming way: small steps, tests first, continuous integration, frequent releases, and a team that keeps getting better. My priority is business success, and I don't think there's a sustainable way to get there without technical excellence: a team that can release constantly, daily, several times a day, without fear.

I've worked in product companies across proptech, food-tech, travel and AI, sometimes as a developer, sometimes as a tech lead, always as the person who pushes for TDD, trunk-based development and shorter feedback loops. Outside the day job, I write and teach about these practices with Learn Agile Practices.

Agile for me means working software, short feedback loops and real collaboration, not a calendar full of ceremonies. Small batches, continuous discovery, MVPs and MLPs that you actually learn from, and teams that own the outcome, not just the ticket.

XP is the core of how I work and what I teach.

• TDD (Red → Green → Refactor) and ATDD to grow behavior from examples
• Refactoring in baby steps, with Simple Design and Object Calisthenics as compass (object-calisthenics-rules)
• Pair and ensemble programming as the default way of sharing knowledge
• Continuous Integration done for real: trunk-based development, commit to main, no long-lived branches
• Legacy code handled the Feathers way: seams, characterization tests, then change

Stop starting, start finishing. Limit WIP, make the flow visible, cut waste, and forecast with data instead of estimates. Lean thinking is the lens I use to understand why a team is slow, and it's rarely because people aren't working hard enough.

If deploying is scary, you should do it more often. Automated pipelines, fast and trustworthy test suites, feature flags, observability, and small changes going to production many times a day. You build it, you run it.

What happens when you take Extreme Programming seriously in the age of AI?

xp-developer-skills is my open-source framework, AMPD (Amplified XP & Product Development): a set of skills and subagents that make AI coding agents (Claude Code, Cursor, Codex, OpenCode…) work inside the same engineering discipline great teams already follow.

The story. It started with small, disconnected experiments: an automatic AI review on every pull request, an n8n workflow that went looking for the cause of a bug as soon as it was opened as an issue, then Cursor's automations on the same issues. Useful, but nothing that came together as a system. Then I tried an existing agentic framework with an instinct close to mine. It was interesting, but it didn't click, so I decided to build my own, from the ground up, tuned to how I actually work.

What made that possible was an archive I'd been keeping since 2012: years of notes on XP, TDD, continuous integration, Lean, DevOps and technical excellence. I started with one skill per action of a normal working day: a bugfix skill that enforces red before green and a minimal diff, a legacy-testing skill built on Michael Feathers' seams and characterization tests, a time-boxed spike skill, refactoring, and TDD and ATDD underneath everything.

At that point it was still a toolbox. The breakthrough came with new-feature and new-increment, when both skills agreed on what an increment is: a slice that can be released to production, tested and deployable, even if no user sees it yet. Once the planner and the implementer shared that unit, the skills started handing work to each other, and the toolbox became an operating model.

How it works today

• 🗺️ new-feature plans only: it slices a capability into an ordered backlog of increments, confirms the plan with you, then hands off one increment at a time
• 🧪 new-increment delivers exactly one slice with strict TDD (ATDD only where a real outer seam exists), keeps every project verification step green, squashes to one commit, and stops
• 🔍 increment-review gives a verdict in about a minute: approved, changes requested (routed to refactoring) or bug found (routed to bugfix)
• 🧹 refactoring, legacy-refactor, bugfix, spike and tweak each have a clear, bounded role in the loop
• 🚪 pr-reviewer is the slower, more skeptical gate at merge time: hat discipline, increment scope, test strategy, Object Calisthenics

The principles behind it: amplify, don't bypass · skills over prompts · verify every change · simplicity first · product judgment stays human.

👉 Explore the repo · Manifesto · Install guide

Learn Agile Practices is my home for continuous improvement and learning for software developers. It's for anyone who wants to become a real agile developer: XP, TDD, pair programming, OOP, CI/CD, Lean and DevOps, explained from practice, not theory.

• 🌐 Website: articles, podcast and resources
• 📬 Newsletter 🇬🇧: essays on agile technical practices
• 🎙️ Podcast 🇮🇹
• 📺 YouTube 🇮🇹
• 🎓 Courses & premium content

• Just commit to master, please: what Continuous Integration actually is, and how to really do it · slides
• Start finishing, stop starting: limit work in progress to maximize outcomes · slides
• Object Calisthenics: take advantage of OOP essence to improve your TDD feedback loop · slides