Preamble

We are uncovering better ways of building software with AI at breakneck speed, but at the same time, we must acknowledge that in the modern enterprise, no application is an island. Every piece of logic exists within a complex web of dependencies, latency, and state. We also recognize that AI is not a replacement for engineering, but a powerful engine for realizing intent.

Through this work with AI, we have come to:

Core Values

Verifiable Intent over Syntactic Correctness: We value code that provably matches the system’s objective via automated policy and testing, not just code that compiles without error.

System Resilience over Local Optimization: We value the stability and survival of the entire network over the raw execution speed of a single node or function.

Deterministic Execution over Probabilistic Agents: We value AI as a builder of rigid, predictable automation scripts, rather than as a real-time, probabilistic decision-maker for critical processes.

Architectural Guardrails over Manual Review: We value automated, platform-level constraints that physically prevent anti-patterns over relying on human vigilance to catch them during code review.

Managed Metadata over Generative Novelty: We value strict, pre-defined structures and contracts (schemas/templates) over loosely coupled or "reimagined" AI-generated logic.

Human Augmentation over Human Replacement: We value AI as a tool to increase the capacity, velocity, and insight of the engineer, not as a means to reduce the engineering workforce.

That is, while there is value in the items on the right, we value the items on the left more.

The Principles of AI-Native Engineering

1. The Logic is Ephemeral; The State is Permanent

We treat AI-generated components as stateless workers. The AI writes the logic, but the Platform manages the persistence. This ensures that when the logic fails or scales, no data is lost in the wreckage of a hallucinatory variable.

2. The Transition to Determinism

AI is a tool for discovery and construction, not permanent execution. Once a process is fully understood and automated, the AI steps aside, leaving behind rigid, deterministic code to perform the task. We do not ask AI to "think" about a solved problem twice.

3. Contracts are King

The "Handshake" between services (APIs, Data Models, Event Schemas, etc.) must be defined by humans before generation begins. The AI may write the code that fulfills the contract, but it is never permitted to alter the contract alone.

4. Context is Global

We reject the illusion of the "local environment." AI must be prompted and constrained to generate code that assumes the network will fail, the database will be locked, and the service will be unavailable.

The Human Responsibility

We are the Context Bearers

AI cannot see the world outside the prompt. We are responsible for identifying and injecting the external conditions - legal, ethical, physical, and business - that the code must survive in.

We are the Governors of Semantics Code is math, but Systems are meaning. The AI can ensure a string is 10 characters long, but only a Human can decide if that string should be a Customer ID or a Product Code.

We are the Architects of "Done" An AI can iterate indefinitely. Only a human can declare that a system satisfies the business need and is safe for deployment.

What do you think of this manifesto? It is the first document (of hopefully many), which I’ll make public while building the m8a platform (working on alpha). I’ve made this manifesto public, because it is the rules and the perspective I’m working with and I’d love to hear thoughts about this from others.