Agentic AI is changing how we build software. AI is no longer just a helper that writes small code snippets. It can reason about requirements, generate larger parts of a system, validate behavior, and keep code consistent over time.
This only works in business application development if architecture, process, and technology are aligned. Otherwise, AI just produces more code faster, without improving quality or sustainability.
An AI-ready architecture for business applications is built on three pillars:
Self-Contained Systems, Spec-Driven Development, and a simple, explicit technology stack.
Why architecture matters for agentic AI
Many modern systems are hard for AI to work with. Business logic is scattered across frontend code, backend services, configuration, and infrastructure. Responsibilities are unclear and boundaries are weak.
For agentic AI, this is a problem. AI needs clear scope and owne1rship. It must know where a rule belongs, which data it owns, and which behavior it is allowed to change.
Business applications are long-lived systems. They evolve over years and decades. AI must support this evolution instead of making it riskier.
Self-Contained Systems as the architectural foundation
Self-Contained Systems follow the idea of Domain-Driven Design bounded contexts. Each system owns its data, business rules, and behavior. Dependencies to other systems are explicit and minimized.
This creates a clear boundary for agentic AI. Each Self-Contained System defines a closed world in which AI can reason safely. Requirements, use cases, entities, code, and tests all belong to the same context.
Instead of applying AI to a large, tangled codebase, we give it a well-defined problem space. This reduces unintended side effects and makes change predictable.
Spec-Driven Development as the source of truth
Most software development today is code-first. Code becomes the source of truth. Requirements exist as tickets, comments, or outdated documents, while real behavior lives only in the implementation. This approach does not work well with agentic AI. Spec-Driven Development starts from a different assumption. Specifications come first.
With the AI Unified Process, the system is described through a small set of stable artifacts: a requirements catalog that captures intent, system use cases that describe observable behavior, and an entity model that defines the domain vocabulary and structure.
These specifications are written for humans and AI. They are stored as docs-as-code and diagrams-as-code, versioned in Git, and linked through stable identifiers. In a Self-Contained Systems architecture, each system has its own specification set. This gives AI a clear boundary and a stable source of truth.
The Simon Martinelli Stack inside each system
Inside each Self-Contained System, the Simon Martinelli Stack provides the technical foundation.
It combines Java and Spring Boot for explicit business logic, Vaadin for server-driven user interfaces, jOOQ for type-safe and explicit SQL, and a relational database as the backbone of the domain.
This stack is especially suitable for agentic AI.
Business rules are explicit and readable. Data models and queries describe the domain precisely. There is little hidden behavior and little framework magic. This makes it much easier for AI to understand the system, generate code, and change it safely.
The stack also keeps UI and backend close together. For business applications, this reduces complexity and keeps behavior in one place.
Why the combination works
Self-Contained Systems provide clear architectural boundaries.
Spec-Driven Development provides stable, shared specifications.
The Simon Martinelli Stack provides a simple and explicit implementation model.
Together, they create an environment where agentic AI can reason about business domains, generate and evolve real systems, and support long-term maintenance and modernization.
This is not only about faster coding. It is about building business applications that remain understandable, adaptable, and correct, even as AI becomes an active part of the development process.
That is what an AI-ready architecture for business applications looks like.
