Two Ways to Build with AI: A Clear Divide
The question is no longer whether AI accelerates development — that's settled. The real question is: will what you build hold up under load, facing security constraints, compliance audits, and unexpected regressions? An infographic circulating in the AI builder community captures this tension with a clear metaphor: two trees, two growth trajectories, two radically different destinies.
Vibe Coding: The Illusion of Speed
The tree on the left in this representation grew fast — too fast. Its only visible roots in cracked soil bear two labels: Prompt and Prayer. The caricature is harsh, but it describes a very real practice: chaining prompts without structure, generating code or workflows by feel, and hoping the whole thing stays coherent.
This approach produces stunning prototypes in minutes. That's precisely what makes it attractive — and dangerous. As soon as the project encounters real constraints, the outcome is clear:
- Scaling up: unstructured flows collapse.
- Security and compliance: impossible to audit what hasn't been specified.
- Maintenance: every change risks breaking everything, due to lack of clear structure.
- Regressions: without tests or verification loops, drifts go unnoticed.
The cracked soil is not an exaggerated metaphor. It's the technical debt accumulated with each undocumented prompt.
Watch Out for Attractive Prototypes
An agent that works in a demo doesn't validate the architecture. The controlled conditions of a demonstration mask precisely the edge cases that will cause the solution to fail in production.
Agent Engineering: Thirteen Roots for Long-Term Success
The tree on the right, by contrast, is watered methodically by a small robot. Its roots descend deeply and are structured in thirteen layers of foundations. These elements define what the LLMOps community now calls agent engineering:
- Framing files:
CLAUDE.md,AGENTS.md— the system instructions that define the agent's behavior in a versioned, auditable way. - Specification first: write what the agent should do before writing a single prompt.
- Decomposition into sub-agents, skills and hooks.
- Task planning and breakdown: each task is bounded, testable, reversible.
- Exit criteria and milestones: the agent knows when to stop.
- Context management: controlled context window, no silent overflow.
- Sandboxing and isolation: executions cannot affect unintended resources.
- Trajectory review: audit of decisions made by the agent over time.
- Guardrails: explicit rules about what the agent cannot do.
- Verification loops: automatic validation of outputs at each step.
- Retrieval stack: structured and observable RAG (Retrieval-Augmented Generation) pipelines.
- Agent CI/CD: continuous integration and deployment adapted to agent workflows.
- Feedback and iteration loop: continuous improvement based on real metrics.
Each of these roots addresses a concrete risk: behavioral drift in the agent, undetected hallucinations, uncontrolled actions on sensitive resources, technical debt accumulating silently.
Concrete Starting Point
If you're starting an agent project on Azure AI Foundry or with Microsoft Copilot Studio, start by writing an AGENTS.md file that explicitly describes the scope of action, authorized data sources, and stopping criteria. That's the first root to plant.
What This Means in Practice in the Microsoft Ecosystem
For an administrator or architect working on Microsoft 365, Azure OpenAI Service or Copilot Studio, these principles are not abstract. They translate into daily architecture decisions:
| Practice | Vibe Coding | Agent Engineering |
|---|---|---|
| System instructions | Improvised prompt in session | AGENTS.md versioned in Git |
| Deployment | Manual, ad hoc | Dedicated CI/CD pipeline |
| Execution isolation | Uncontrolled shared environment | Dedicated sandbox with minimal permissions |
| Context management | Unmonitored window | Explicit breakdown and logging |
| Output verification | Occasional manual review | Automatic validation loops |
| Governance | Absent or implicit | Configured guardrails, auditable |
Integrating agent CI/CD into your Azure DevOps or GitHub Actions pipelines is not a luxury — it's what allows you to detect behavioral regression before it reaches production. Similarly, trajectory review naturally aligns with audit requirements imposed by compliance frameworks like ISO 27001 or internal data governance policies.
Reference Resource
The Azure AI Foundry documentation covers best practices for evaluating and monitoring agents. The Evaluation of generative AI applications section details the metrics to instrument from the start of a project.
Investing in Roots Is Not a Brake on Speed
One objection keeps coming back: documenting, specifying, isolating — all that "slows things down." That's a short-term illusion. Time spent planting the thirteen roots prevents having to rebuild the project after each incident.
In practice, an agent deployed without guardrails on SharePoint Online or Microsoft Teams can trigger hard-to-undo cascading actions. An agent with sandboxing and explicit exit criteria, by contrast, stops cleanly and leaves an auditable trail.
Durability is not the opposite of speed. It's what allows you to maintain speed over time, without silent debt accumulation.
Key Takeaways
- Vibe Coding produces quick results but unmaintainable ones as soon as real conditions kick in.
- Agent engineering rests on thirteen layers of foundations: framing, specification, decomposition, sandboxing, CI/CD, guardrails, verification loops and feedback.
- The
CLAUDE.mdandAGENTS.mdfiles are the most accessible entry point for structuring an agent's instructions. - In the Azure and Microsoft 365 ecosystem, these practices align directly with governance, compliance and auditability requirements.
- The question to ask before any new agent project: what proportion of effort goes into the visible foliage, and what proportion goes into the roots?
