- Development
- AI
Looking back on one year of AI-powered software development efficiency
October 30 — 2025
One year ago, in November 2024, we published this article that announced a strong position for Mirego regarding our software development practices: the widespread adoption of AI development tools in all our projects, for all our clients.
A tremendous amount has changed over the past 12 months.
Cursor, Claude Code, OpenAI Codex, and OpenCode have emerged as the new new generation of tools. Best practices for using them have been refined within Mirego (and throughout the entire development community). We even organized an event for the community dedicated to knowledge sharing and experimentation with these tools.
Let's review the changes that have occurred since November 2024, our learnings, and our perspective for the future.
Similar challenges
The two main challenges we wanted to address in 2024 before diving headfirst into this movement were:
1
Managing and protecting the confidentiality of our clients' data and source code.
2
Managing the risks of diminishing the fundamental quality aspects (long-term maintainability, security, accessibility) of the projects we deliver.
While the first challenge is still present, its importance has remained roughly the same as a year ago and the ways to mitigate it are consistent: use services and tools that have very clear terms and conditions regarding the use of data submitted to them to ensure they are compatible with our clients' requirements.
However, with the rise of vibe coding, we must admit that the second challenge is still as relevant, if not more so, in 2025.
The evolution of these AI tools, transforming them from simple code generators into agents capable of executing complex and complete tasks, combined with the continuous improvement of various LLM models (notably Claude Sonnet 4.5 and GPT-5-Codex) has opened the doors to a new usage paradigm → entrusting a task to an agent and letting it complete it from A to Z.
“The irony is: as AI makes building easier, the value of engineering judgment goes up. […] The faster you can go, the more you need someone to steer.”
These AI models are powerful but remain unpredictable. With an expert developer at the helm, they are truly formidable.
In a context where quality, maintainability, security, accessibility, etc. are still paramount, we believe more than ever that beyond the tools themselves, the most important thing is to have the best team that masters its tools and is capable of getting the most out of them, without compromise.
As we mentioned in 2024, SDLC processes that rely on deterministic tools (e.g. static code analysis, vulnerability scanning, automated testing) are crucial when using AI tools. They are now even more important in the context of agentic feedback loops.
Continuous evolution and learning
One of the lessons we have learned as a team is that, probably for several more years, we must be in a constant mode of learning and refining our practices.
Tools and models evolve. What was good three months ago may not be as effective today. What worked unreliably three months ago may work very well now. We must therefore continue to put ever more effort into knowledge sharing.
Another lesson learned is that we need to be more intentional about measuring the concrete impact of using AI in our processes.
“Without data, you're just another person with an opinion.”
AI often has the unfortunate tendency to give us the impression of being extremely productive in the short term but makes us forget the dozens of subsequent adjustments that must be made to achieve the desired result. These adjustments are of paramount importance; they must be measured and valued.
Concrete results
These learnings have definitely materialized into concrete results in our projects. By emphasizing reflection and writing technical, clear, and precise prompts, our team has achieved numerous efficiency gains across all our projects, without falling into new kind of traps.
We realized that rather than providing lengthy instructions to an AI tool to implement a feature and letting it make dozens of micro-implementation decisions, it was often better to spend long minutes (or even hours) refining an extremely precise and structured technical game plan that it would then execute autonomously.
Interestingly, some results did not always have the desired magnitude. In the specific case of a set of complex features to develop in a project, a member of our team spent 6 hours meticulously writing a detailed technical prompt that allowed them to generate the equivalent of about fifteen days of development; at first glance, a highly impressive productivity multiplier.
But the more the team member delved into the code to make final adjustments, the more they realized that questionable decisions had been made by the AI tool and ended up manually finalizing all the features over an additional ten days of development.
In short, it's easy to be initially impressed by the prowess of these AI tools. But it remains paramount for us to approach them pragmatically and rigorously by measuring their concrete impact against initial work estimates.
Always towards the future
Today in November 2025, we still believe that these tools are the future of software development.
We are convinced that it is possible for development teams to master them to maximize their efficiency and deliver more value without compromising the long-term maintainability of a project. This is what we do every day and will continue to do at Mirego.
Rather than envisioning a future where developers act as “AI agent managers” who coordinate a fleet of agents working in parallel on multiple tasks, our vision is more akin to that of surgeons who spend the majority of their time on extremely complex tasks where their expertise is critial. Repetitive and lower-value tasks can be quickly delegated to AI so that developers can focus on what really matters.
Through all the changes, all the evolutions, and all our learnings, the only element that has not changed between November 2024 and November 2025 is our non-negotiable principle: we build quality products (both at the UI/UX level in terms of product and at the maintainability level in terms of code) that have impact.
One thing is certain for us → AI development tools must never call this principle into question.
