🎁 Perplexity PRO offert

30 jours gratuits

Téléchargez Comet, connectez votre compte et posez votre première question.

Activer l'offre →

For any developer navigating an ecosystem as rich and complex as PrestaShop, module creation is a balancing act. The challenge involves juggling between the Legacy subsystem, inherited from previous versions and built around ObjectModel and Smarty, and the PrestaShop Bundle, the modern ecosystem based on Symfony and Twig. This mixed architecture demands absolute rigor to ensure stability, transforming an innovation process into an often tedious and repetitive task.

It is in this context that methodologies like BMAD (Breakthrough Method for Agile AI Driven Development) emerge. At first glance, one might perceive it as just another code generation tool, promising to accelerate tedious tasks. However, a deeper analysis reveals it is much more than that. BMAD is not an assistant; it is a true framework that forces us to rethink how we design and build software. This article explores five unexpected lessons this method teaches us about the future of module development.

1. Beyond a Simple Assistant, AI Becomes a Complete Project Team

The first surprise of the BMAD method is that it doesn’t behave like a simple code assistant, but simulates a complete project organization. It is structured as a “specialized agent system” that reproduces the dynamics of a real team, with a clear separation of responsibilities. Each agent takes on a specific role, including key roles such as analyst (to clarify the brief), pm (product manager, to guide the PRD), architect (for technical design), dev (to produce code), and qa (for quality review), even simulating a product owner (po) and scrum master (sm) for story breakdown.

This approach humanizes interaction and, more importantly, imposes project discipline. Unlike a completion tool that intervenes at the moment of code writing, BMAD forces the implementation of structuring steps upstream. Before generating a single line of code, the method requires validation of a Product Requirements Document (PRD) and an architecture document. AI no longer simply writes code; it drives strategy and design, bringing unprecedented rigor and a formal framework to module development.

2. The Real Value Isn’t Speed, But Sometimes Tedious Rigor

While we expect artificial intelligence to provide immediate acceleration, BMAD reveals a paradox: its greatest strength lies in an upstream phase described as “long” and “tedious.” The method deliberately slows down the initial process to better accelerate it afterward. Juggling between agents, validating the PRD section by section, defining architecture in detail—all this constitutes a heavy initial investment. The goal is to specify requirements with such precision that implementation can then “unfold automatically.”

However, this approach has its limits. The process is demanding, token consumption is high, and the system proves “fragile” if a constraint is forgotten at the start, making any backtracking “laborious.” This initial heaviness creates an expectation of near-perfect downstream execution. Yet reality is more nuanced: “you still need to go back over the agents to correct, adjust,” which generates disappointment and diminishes the value of the system for “high velocity” projects.

This duality defines the ideal application scope for BMAD. The method is perfectly suited for complex projects that require a “clear, documented, and rigorous” vision. However, its advantage diminishes for projects where constant adjustments are needed, as the rigidity of its initial process doesn’t accommodate frequent changes well.

3. BMAD Is the Gateway to “Agentic” Development

The BMAD method is not an isolated innovation; it is a concrete manifestation of a fundamental trend: “agentic coding.” An AI agent is not a simple assistant. It is an autonomous entity capable of interpreting natural language instructions, executing a series of actions, navigating through a project’s file structure, and even testing and validating its own work.

This approach differs radically from traditional tools like GitHub Copilot, which are primarily limited to code suggestion. The difference is fundamental: it’s the one “between an assistant who guides you and a competent colleague who accomplishes work independently.” With traditional assistants, the developer remains in control and validates each line. With agentic development, the developer becomes a conductor who delegates complex tasks to specialized agents. BMAD, with its project team simulation, materializes this paradigm shift where our role evolves from simple coder to pilot of intelligent systems.

4. We No Longer Code Just for Humans, But for an Agent Economy

The usefulness of modules created with tools like BMAD extends far beyond human interfaces. We are entering an era where software must be designed to interact with other intelligent systems. Protocols like Google’s UCP (Universal Commerce Protocol) are preparing a future where “AI Agents” can dialogue directly with online stores on behalf of users. The idea is to create a standardized language allowing an AI to discover products, check inventory, and make purchases without going through the traditional web interface, marking the transition from SEO (Search Engine Optimization) to AIO (Artificial Intelligence Optimization).

This is precisely where BMAD’s rigor makes complete sense. This future “agentic” economy requires modules that are not only functional, but also standardized, predictable, and “API-first.” BMAD’s “document-first” approach, with its validated PRDs and architecture schemas, is not just a methodological choice; it is the ideal condition for producing the reliable software components these agents will need. Tools like BMAD no longer serve only to produce code faster; they become factories for manufacturing the software building blocks that will allow businesses to participate in this new automated market.

5. AI Acceleration Reveals a New Blind Spot: Supply Chain Security

If artificial intelligence can automate code creation, it must imperatively automate its security. The acceleration of production risks amplifying an often underestimated danger: threats to the software supply chain. The “Shai-Hulud” attack on the npm ecosystem is a striking example, where trusted open-source packages were replaced by malicious versions designed to steal credentials. The danger is all the greater because, as researchers report, “when developers or continuous integration systems installed these versions, the malware executed automatically.”

The speed offered by AI agents could exacerbate this risk. The role of the human orchestrator then becomes ensuring that agents are configured to systematically check for vulnerabilities, choose dependencies from trusted sources, and generate an SBOM (Software Bill of Materials) to ensure traceability. The only viable countermeasure at scale is to respond to agentic development with agentic security. The power of BMAD and future similar tools must be coupled with automated and rigorous security practices, otherwise the promised productivity gain will turn into a major security breach.

Conclusion

The BMAD method is much more than a simple productivity tool; it is a glimpse into a profound transformation of the developer profession. It shows us a future where development is more structured, more autonomous thanks to agents, and more strategic. But this future also carries new responsibilities, particularly in terms of architectural design and software supply chain security.

AI does not replace developers; it forcibly promotes them to an architect role. The question is no longer “how to code?” but “how to build the system that codes?” Are you ready for this promotion?