AI-generated code without specifications, tests, or traceability is technical debt with a chatbot on top. Here’s how three open-source frameworks turn agent-assisted development into actual engineering — across ERP, BI, and conversational UI.

The Problem Nobody Talks About

Every demo looks the same: someone types a prompt, code appears, the audience applauds. What happens six months later — when the extension breaks after an upgrade, the Power BI model drifts from the ERP schema, or the Copilot Studio bot hallucinates an order status — is a different story.

The industry coined «vibe coding» to describe AI-generated code that works once and decays forever. The fix isn’t less AI. It’s more engineering around the AI. That’s the thesis behind three frameworks — ALDC, CIRCE, and DELFOS — designed to cover the full Microsoft Business Applications stack with a shared architecture: agent squads, human-in-the-loop gates, skills-based modularity, and cross-session memory.

ALDC: Specification-Driven AL Development for Business Central

ALDC (AL Development Collection) replaces ad-hoc prompting with a structured pipeline for Dynamics 365 Business Central extensions. Three roles orchestrate every task: the Architect (@al-architect), which designs the solution, selects patterns, and defines the scope (its output is an architecture document, not code); the Spec Creator (al-spec.create), which translates the architecture into a formal specification with test requirements, file structure, and acceptance criteria; and the Conductor (@al-conductor), which executes the spec through three sub-agents (implement, review, finalize), enforcing TDD and HITL validation at every phase boundary.

The flow adapts to complexity: MEDIUM/HIGH tasks follow the full Architect → Spec → Conductor pipeline. LOW tasks skip the architect and go directly from Spec to Developer. Every agent declares which skills it loaded and which patterns it applied — a mechanism called Skills Evidencing that enforces validation gates, assigns clear accountability for every decision, and enables principled auditing of everything the AI generates.

CIRCE: Production-Grade Agents for Copilot Studio

CIRCE brings enterprise development practices to Microsoft Copilot Studio bots. Built on top of the «Skills for Copilot Studio» plugin by Giorgio Ughini and the Microsoft Power CAT team, CIRCE adds eight layers that the base platform doesn’t provide out of the box: an orchestrator agent that routes conversations across domain-specific skills, decision records that log why the bot chose one path over another, HITL gates before any action that pushes data to production systems, skills evidencing, cross-session memory, full agent scaffolding, test coverage metrics, and always-on instructions that persist across topic boundaries.

The BC Extension Pack gives CIRCE bots domain expertise in Business Central — receivables management, sales, and customer support workflows — connected through the standard BC MCP connector to live ERP data.

DELFOS: An Agentic Squad for Power BI

DELFOS coordinates six agents to apply Microsoft’s official best practices directly on live semantic models: Delfos Architect (strategic layer, analyzes the model, plans improvements, and assigns tasks), Delfos Lead Squad (orchestration layer, sequences agent work, resolves conflicts, enforces quality), and four domain experts (Data Modeling, DAX, Performance, and Visualization), each with scoped MCP access. The Architect gets both Remote and Modeling MCPs; Data Modeling gets Modeling only; DAX and Performance get Remote only; Lead Squad and Visualization get none.

This isn’t a chatbot that answers DAX questions. It’s a coordinated squad that reads your actual model, identifies issues against official guidelines, and proposes concrete changes — with human approval required before anything is applied.

The Bridges: The Manifest as Lingua Franca

Each framework lives in its own workspace. They share no session, no context, no runtime. That means communication between them is always asynchronous and file-based: one framework generates an output artifact, and the other consumes it as input.

The concrete mechanism that makes this work is the Extension Manifest — a document that ALDC generates automatically when the Conductor pipeline completes. Once a BC extension compiles and passes its tests, a dedicated skill (extension-manifest.skill) asks the user: who will consume this? CIRCE, DELFOS, or both? Then it generates a manifest tailored to the destination.

ALDC → CIRCE: The CIRCE section of the manifest is deliberately lightweight. The standard Business Central MCP connector («Dynamics 365 Business Central MCP Server») already exposes API pages as tools, with their fields, actions, and permissions. CIRCE doesn’t need the manifest to describe the API — it needs to know where to connect and which tools to look for. Three values: BC environment, company, and MCP configuration code (Page 8351). Plus a table of relevant entityNames (custom ones from the extension and standard ones for the domain). With that, a skill on the CIRCE side (bc-mcp-connector.skill) reads the manifest, walks the user through BC prerequisites, and configures the connection. If the agent needs to inspect business logic beyond what the MCP exposes, it has a repository reference for navigation via GitHub MCP.

ALDC → DELFOS: The DELFOS section is detailed because semantic model design requires understanding fields, types, and relationships before touching anything. The manifest includes API pages with full field tables (AL field name, API field name, type, description), API queries with their purpose and columns, data structure with every field classified as a Dimension or Measure candidate following Power BI conventions, and Star Schema Hints (suggested fact and dimension tables, relationships with cardinalities, and known gaps). All compatible with DELFOS’s bc-data-source-mapping skill.

DELFOS → ALDC: The reverse bridge also exists. When DELFOS designs a Power BI schema that pulls from Business Central and detects a missing field in the standard API, it generates a specification file compatible with al-spec.create. ALDC picks it up and implements the custom API page in AL — no manual translation between BI and ERP teams needed.

The result is a natural linear flow: build the extension with ALDC, generate the manifest, and from that single document spin up the conversational agent with CIRCE and the dashboard with DELFOS in parallel. You are the HITL who decides when to carry the manifest from one workspace to another — the meta-architect of the ecosystem.

What Holds It All Together

Five architectural patterns appear in every framework, regardless of the technology underneath:

Agent squads over monolithic assistants: specialized roles with scoped permissions beat a single omniscient prompt. HITL gates at phase boundaries: no agent pushes to production without human validation. Skills and Instructions as composable modules: loaded on demand, scoped to context, never global. Cross-session memory via structured files: memory.md, decision records, and architecture documents keep agents aligned across sessions. Skills Evidencing: every agent declares what it loaded and what patterns it applied, reinforcing validation gates, assigning clear accountability for every output, and enabling principled auditing — knowing not just what the AI generated, but why and on what basis.

📚 References

ALDC on VS Code Marketplace — Core + Extension Packs (v3.2.1)

DELFOS Power BI Agentic Squad — Open-source repository

Skills for Copilot Studio — Giorgio Ughini & Microsoft Power CAT team

BC MCP Server Configuration

🟦 AI-assisted development isn’t about typing fewer lines. It’s about building systems where every line has a specification, a test, and a human who said «go.» That’s the difference between vibe coding and engineering.