POSTED ON 12 NOV 2026
READING TIME: 5 MINUTES
AI is changing how software gets built. That's hardly news. What's perhaps more interesting is how it's changing the role of the software engineer.
That was one of the recurring themes at Codemotion Milan, where five of our Java engineers explored not just the latest tools and technologies, but some more fundamental questions: how do we maintain ownership of the software we produce, ensure AI-generated solutions solve the right problems, and adapt the way we work as implementation becomes increasingly automated?
On their return, we asked them to share their takeaways from the conference. Here's what stood out to them.
Attending tech conferences every once in a while is a great reality check. The old narrative that AI is going to take our jobs still pops up a lot. Meanwhile, in Milan, the message was clear: AI is great, but we can’t do anything without people. In fact, there’s a growing trend to slow down and recognise that not every task should be handed over to AI.
A real highlight for me was Alfonso Graziano’s talk, Scaling AI Adoption: The Real Challenges of Transforming 400 Engineers. As someone just starting out with Claude Code, his message really resonated: just buying tools and subscriptions isn’t enough. To avoid everyone doing their own thing, bridge the maturity gap, and dodge the traps of false starts, we need to build solid patterns that scale across the entire organisation. At the end of the day, adopting AI isn’t just about technology - it’s about how we collaborate, learn, and share what actually works.
My favourite talk was a cautionary case study on agentic automation - specifically, an incident where an AI system given too much autonomy got out of control overnight, issuing automatic refunds to thousands of customers. The session dissected why unconstrained agents fail: models prioritise task completion over business rules, cross operational boundaries, and yield unpredictable outputs compared to deterministic APIs.
The issue was solved by shifting from a monolithic agent to a modular pipeline of bounded, single-purpose subprocesses:
- Classify Intent: Route queries to the appropriate model, using smaller, cheaper models for simpler requests
- Fetch User Data: Retrieve context without execution rights
- Check Eligibility: Validate request rules deterministically
- Execute: Trigger actions only when strict criteria are met
The takeaway? Give agents bounded jobs, favour composition over generalised monoliths, and keep business rules and consequential decisions under deterministic control.
The key message that stuck with me is that moving fast and generating tons of AI code doesn’t automatically mean writing good code. Because we produce code so quickly, teams face “comprehension debt,” where we simply don’t understand what was written. This creates huge bottlenecks in PR reviews, tempting people to skim through them. Traditional code validation is becoming one of our biggest hurdles. PR reviews aren’t disappearing, but how we do them must change. My favourite takeaway was spec-driven development, where context becomes the first real deliverable versioned alongside code. Specs explain why something changed, while a git diff only shows what changed.
Codemotion Milan was my first conference ever, and I thoroughly enjoyed it. Here are my main takeaways:
- We need to change our recruitment process to put more focus on ownership, leadership, and soft skills in general. Developers who can only write good code are not what we’re looking for in the AI world.
- AI is changing our industry, but core software problems remain the same. The word “Intent” appeared on almost every slide - we still need humans in the loop to ensure AI does what we actually intend it to do.
The main theme of the event was clear: the massive impact AI has on our daily work. While many talks focused on new tools, my biggest takeaway was the growing importance of ownership and responsibility. With AI helping so much, we need to be conscious architects- developers who deeply understand the project and orchestrate the system, instead of “zombies” who blindly copy and paste AI outputs. Human judgement is more important than ever; fast AI code does not equal good architecture.
A great example was Mattia Minotti’s talk: The product engineering team: own the problem, collaborate on specs, let agents code. He highlighted that since AI can handle implementation, code is no longer the bottleneck. The real challenge is how the team works - specifications are the “new code,” and we must step up as product engineers who truly own the problem from start to finish.
As AI takes on more of the implementation work, understanding the bigger picture, defining what success looks like and taking responsibility for turning ideas into reliable solutions matter more than ever.
For us, that's perhaps the most exciting opportunity AI presents. Not just writing software differently, but rethinking how we approach the work itself, the role of the engineer and what our teams can achieve.
Codemotion Milan certainly gave us plenty to think about, and we're already looking forward to the next one!