The Wizard of Oz Doesn't Do Magic, But His Audience Doesn't Know It!

Introduction

🚀 The Wizard of Oz doesn't do magic, however, his audience doesn't know it!

Last week, within one of the teams I'm part of, I was asked:

• M: "Do we have to migrate from Java 11 to Java 21, will it be complicated?"

My automatic response was: “Very much so!” I recognize there was confirmation bias in responding immediately: 2 years ago I had the same challenge, but back then we had to migrate from Java 11 to Java 17. That migration took 120 hours from a Senior Software Engineer, that is, three full weeks of a resource dedicated full-time to that migration, for the app to be ready to move to the UAT (user acceptance test) environment.

🤔 The Traditional Approach: 120 Hours of Manual Work

Without going into technical details, migrating from Java 11 involves many changes, not only in Java packages but also in functionality and implementation changes of different packages. Additionally, you have to consider all the frameworks involved, since they also have to be migrated to their most recent versions.

This was the reason, and due to the previous experience I had, for the immediacy of my response. The traditional migration approach was:

• Manual code analysis and dependency mapping
• Framework version updates across the entire project
• Package compatibility checks and resolution
• Testing and debugging of breaking changes
• Documentation updates and team handover

🤖 The AI Agent Revolution: 2 Hours Instead of 120

The conversation I mentioned at the beginning continued like this:

• Me: "But what if I ask Cursor to do it?"
• M: "I don't know, surely it will do something, and then we continue from there"

And that's how it was. I asked Cursor, using "cloud-4-sonnet" as the Agent's brain, to do the Java 11 to Java 21 migration of the project, considering that Spring Boot is used as the main framework (and some others that don't come to mind now).

The result: In 1 hour and 40 minutes, after the initial prompt and a second prompt to correct some dependencies, the migration was done and the project compiled. Not only that, but the Agent also made some refactors appropriate to the new Java version. Then, it took about 20 additional minutes to correct a single runtime error, resulting from how the new version of one of the packages handles some data types.

⚡️ In total, only 2 hours were needed for the application to be ready to move to the UAT environment. A 98.33% reduction in time compared to my experience a few years ago!

🎩 The Magic Behind the Curtain

While, like in the book, I know it's not magic and I understand what's behind it, sometimes it seems like it and in those moments I feel like an Oz spectator, amazed and marveled by what the wizard (Cursor, Windsurf, Cloud Copilot, etc.) and his assistants (Sonnet, GPT, Gemini, etc.) can do.

The incredible thing, from my humble point of view, is that there are still software developers who don't use Agents in their daily work (except for those who, due to bureaucratic issues of the companies they work for, cannot do so). Fear, ignorance, bias, I don't know. AI Agents for coding have raised the entry barriers, but at the same time, they have lowered the exit barriers.

Code is very close (if it isn't already) to being a commodity, since AI Agents generate it and will continue to do so.

🚧 The New Reality: AI Agents Are Essential

It's interesting to note that doing Vibe Coding is very different from coding with Agents, but it's precisely in this difference where the Software Engineer's criteria prevails and is what differentiates us.

Just as it's essential for companies to incorporate Agents in their products to avoid being left behind, using Agents for coding is a matter of survival as professionals, not of having an advantage.

🧑🏻💻 Key Takeaways for Developers

Time Efficiency

• Traditional approach: 120 hours (3 weeks full-time)
• AI Agent approach: 2 hours (98.33% reduction)
• ROI: Massive time savings that can be invested in other critical tasks

Quality Improvements

• Automated refactoring to modern Java patterns
• Dependency management handled intelligently
• Breaking change detection and resolution

Risk Mitigation

• Consistent migration patterns across the codebase
• Automated testing and validation
• Reduced human error in repetitive tasks

🚀 Getting Started with AI Agents for Development

For developers looking to embrace this new paradigm:

1. Start with familiar tools: Cursor, GitHub Copilot, or similar
2. Begin with simple tasks: Code reviews, documentation, or small refactors
3. Gradually increase complexity: Move to larger migrations or architectural changes
4. Learn prompt engineering: Understand how to communicate effectively with AI agents
5. Validate outputs: Always review and test AI-generated code

🎯 Final Thoughts

The Java migration story perfectly illustrates how AI agents are transforming software development. What once took weeks of manual work can now be accomplished in hours with the right tools and approach.

The magic isn't in the AI itself—it's in how we learn to work with it effectively. Just like the Wizard of Oz, the real power comes from understanding the tools at our disposal and using them strategically.

AI agents aren't replacing developers; they're amplifying our capabilities and allowing us to focus on what truly matters: solving complex problems, designing better architectures, and creating innovative solutions.

📚 Resources

Original LinkedIn Post 👉 El mago de Oz no hace magia, sin embargo, sus espectadores no lo saben!