Article
How Axelor integrates AI into its business processes: the revolution of assisted development
Artificial intelligence continues to transform the way we work, and software development is no exception to this profound shift. At Axelor, innovation has always been at the core of our strategy. We firmly believe that the tools we build for our customers should first help us improve our own internal processes. It is in this spirit that we designed and deployed the /develop command, a feature that represents a decisive turning point in our approach to enterprise application development.
This innovation is far more than just another technological gadget. It reflects a fundamental rethinking of how we design and produce code, placing artificial intelligence at the service of efficiency while preserving human expertise where it truly matters. After several months of real-world usage, the results have exceeded our initial expectations and confirm that we have found the right balance between automation and human control.
• Productivity gains that change the game
The numbers speak for themselves and highlight a radical transformation in our development capabilities. On real-world projects, we are seeing dramatic accelerations that would have seemed impossible just a few years ago.
Take the Guardian module, a core component of our ecosystem. Using traditional development methods, our teams estimated one full month to deliver a production-ready version. With /develop, the same module is now completed in just three days, representing a tenfold productivity gain. This is not a prototype or a proof of concept: the generated code meets our quality standards and goes through all the usual validation steps.
The Tenant Manager module, which is more complex and was initially planned for three months, was delivered in two weeks. This sixfold acceleration frees up significant resources for other strategic initiatives. As for the Collaboration Connector, development time dropped from two months to five days, a twelvefold time saving that clearly illustrates the potential of this approach for modules with a strong repetitive component.
These results are not the product of luck or isolated cases. They stem from a carefully designed methodology based on a deep understanding of what AI does best, and what must remain firmly in the hands of human intelligence.
• A structured development architecture
At the heart of /develop lies a structured workflow that organizes module creation in a progressive and controlled manner. This approach turns potentially complex work into a sequence of clear, understandable, and manageable steps.
From the very beginning, developers have a detailed view of the module’s architecture, the main design choices, and the key validation points. Before any code is generated, this overview allows them to anticipate requirements, project themselves forward, and ensure that the chosen direction fully aligns with functional and business expectations.
Throughout the workflow, developers remain fully involved. They do not passively watch code being generated automatically. Instead, they regularly validate, adjust, or correct the proposed outputs. They can confirm continuity, request targeted adjustments, rerun a step with a different approach, or ignore elements that are not relevant to the project context.
This level of control is essential. It ensures that the generated code remains aligned with business needs, prevents drift, and gives developers a clear and continuous understanding of what is being created. Human validation plays a central role, keeping artificial intelligence in an assisting position rather than an autonomous decision-maker.
At the end of the workflow, the generated code is directly usable in production. Unlike approaches limited to prototyping, /develop aims to produce code that complies with Axelor standards and can be integrated into the existing codebase without rework. This is what distinguishes simple automation from a true AI-assisted development solution designed for real, long-term enterprise projects.
• Automatic safeguards to ensure quality
One of the major challenges of automatically generated code is guaranteeing its quality and compliance with existing standards. At Axelor, we have built a strong ecosystem with precise conventions, established patterns, and non-negotiable quality rules. Introducing AI was never an excuse to accept lower-quality code in exchange for productivity gains.
This is why we integrated numerous automatic validations that systematically run on generated code. These safeguards form a multi-layered safety net that catches potential issues before they even reach the developer.
The first validation layer checks XML structure against the official Axelor schema (XSD). All configuration files must comply with a strict schema defining allowed elements, hierarchy, and attributes. The system ensures that generated XML is not only well-formed but fully compliant with Axelor standards, guaranteeing correct interpretation by the platform.
Naming conventions are also strictly enforced. Generated code follows PascalCase for classes, camelCase for methods and variables, and snake_case where appropriate. These conventions are not merely aesthetic choices; they significantly improve code readability, maintainability, and team-wide understanding.
Semantic validation goes further by checking the consistency of entity relationships, the relevance of created indexes, and the logic of defined attributes. The system verifies, for example, that bidirectional relationships are properly declared on both sides, that composite indexes reference existing fields, and that attributes use data types consistent with their intended usage.
Java style receives particular attention. Code must follow Axelor conventions, avoid the use of emojis in source files, and be written in English. Using English consistently, even for projects targeting francophone markets, improves interoperability and facilitates collaboration with international developers.
Finally, generated commits follow the Conventional Commits standard, a widely adopted approach that structures commit messages, simplifies changelog generation, and improves project history readability.
• A smart distribution of responsibilities
The true innovation of /develop lies less in the use of AI itself than in how responsibilities are shared between artificial intelligence and human intelligence. Our approach is based on a simple principle: give each actor what it does best.
AI excels at generating repetitive and structured code. It therefore handles boilerplate creation, the dozens or hundreds of necessary but low-value lines such as domain models with standard attributes, classic CRUD views, and basic services with common methods. It also generates project structure and skeletons, creating the module backbone with all required files, properly organized and interconnected. Repetitive code patterns, loops, checks, and standard processing logic are delegated to AI, as are basic unit tests that validate nominal behavior.
Freed from these time-consuming but necessary tasks, developers can focus their energy and expertise on what truly creates value. Complex business logic, which requires a deep understanding of enterprise processes and specific use cases, remains entirely in human hands. Architectural validation at each phase ensures that the chosen direction is sound and that the module integrates seamlessly into the existing ecosystem. Edge cases and integrations, often the difference between a theoretical solution and a robust production-ready module, receive the attention they deserve.
This distribution is not fixed. At any stage, developers can take back control of certain aspects, refine what AI has produced, or delegate additional tasks. The system’s flexibility allows it to adapt to the specific context of each project and the preferences of each developer.
• Total control that reassures and empowers
One of the most common concerns about automation is the loss of control. Many tools promise efficiency but end up locking users into rigid workflows. With /develop, we made the opposite choice: maximizing developer control while delivering the benefits of AI.
Control operates at multiple levels. Automatic validations ensure that non-compliant code never goes unnoticed. Structure, naming, semantics, style, and commits are all systematically checked, creating a solid and non-negotiable quality baseline.
Human validation at every step turns developers into conductors of the process. They are not passive approvers clicking “OK,” but active decision-makers who assess, compare, and choose. This engagement ensures that the resulting code truly meets business needs.
The ability to approve, iterate, or reject AI output at each phase offers a level of control rarely seen in automation tools. If a result is not quite right, there is no need to start over; a simple iteration refines the outcome. This flexibility reduces frustration and keeps productivity high.
Clear role separation between intelligent assistance and human expertise creates a reassuring framework. Everyone knows what is handled by AI and what remains the developer’s responsibility, eliminating gray areas and constant uncertainty.
• Concrete benefits for your organization
Beyond technical considerations, /develop delivers tangible benefits that directly impact organizational performance.
Significant productivity gains allow faster delivery without compromising quality. In environments where time-to-market is critical, this acceleration can make the difference between success and missed opportunities.
Maintaining human validation and control reassures teams and technical leadership. AI is seen not as a threat to developers, but as a force multiplier. This positive perception eases adoption and maximizes value.
Code quality, guaranteed by extensive automated checks, reduces technical debt. Generated code adheres to standards, simplifying long-term maintenance and lowering future costs. The common fear of fast code becoming costly later is largely mitigated.
Finally, the focus on business value transforms developers’ daily work. Freed from repetitive tasks, they can concentrate on intellectually stimulating challenges, complex problem-solving, and innovation. This evolution improves job satisfaction and supports talent retention.
• A human-centric vision of AI
The /develop command embodies our vision of how artificial intelligence should be integrated into software development: a smart collaboration where each party contributes its strengths without encroaching on the other’s domain.
AI is not here to replace developers, but to free them from constraints that limit their potential. It does not make strategic decisions; it executes repetitive tasks efficiently. It does not design global architecture; it rapidly materializes developer choices.
This balanced approach allows us to offer customers, partners, and internal teams a solution that combines the best of both worlds: the speed and rigor of automation with the creativity and judgment of human intelligence.
At Axelor, we will continue exploring the possibilities of AI while remaining true to our values: putting people first, guaranteeing quality, and adopting new technologies only when they deliver real value. The /develop command is just the first step on this journey, and we look forward to sharing what comes next.