Over the last two years, I have been working heavily with AI-assisted and agent-based development. One observation keeps coming back: the choice of technology stack matters far more than most people think.

AI agents do not struggle with syntax. They struggle with fragmentation, hidden behavior, and unnecessary abstraction layers. When the architecture is explicit and coherent, it performs extremely well. When it is opaque and distributed across multiple conceptual models, productivity drops quickly.

This is one reason why I increasingly see Vaadin and jOOQ as a particularly strong combination for AI-driven development.

Full-stack coherence matters

Modern enterprise applications are often split across multiple stacks. One language for the frontend, another for the backend, data contracts in between, and glue code everywhere. This fragmentation forces both humans and AI agents to translate context constantly.

Vaadin takes a different approach. It provides full-stack development in Java, allowing UI, navigation, validation, and business logic to live within one consistent programming model.

For an AI agent, this has several advantages:

  • Behavior is observable end-to-end in one codebase
  • Refactorings span UI and backend without crossing technology boundaries
  • There is no duplication of domain models across layers
  • State and flow are easier to reason about

Instead of coordinating changes across frameworks and APIs, the agent operates on a coherent system. That reduces cognitive load and improves the reliability of generated changes.

SQL transparency beats ORM opacity

Data access is another area where abstraction can hurt agent effectiveness. Object relational mappers were designed to shield developers from SQL and relational thinking. While useful in some contexts, they introduce layers of implicit behavior that are difficult to inspect and reason about.

AI models already understand SQL extremely well. It is one of the most represented programming languages in training data and is structurally simple to analyze and modify.

jOOQ embraces this strength. It keeps SQL explicit while providing generated types and compile-time safety. Instead of hiding queries behind mapping frameworks, it exposes them in a form that is both readable and verifiable.

This leads to several practical benefits:

  • Queries remain transparent and modifiable
  • The database structure is directly visible in the generated code
  • Type safety prevents many runtime issues
  • Result mapping stays explicit and predictable

From an agent’s perspective, this removes impedance mismatch. The agent can read queries, adjust them, and construct domain objects directly. There is no lifecycle magic to reverse engineer.

Reducing indirection improves evolvability

A common theme in AI-assisted development is that clarity beats cleverness. Every additional layer that hides behavior increases the effort required to safely modify the system.

Combining Vaadin and jOOQ reduces several traditional sources of indirection:

  • No frontend backend translation gap
  • No ORM behavioral surprises
  • Fewer duplicated representations of the same concept
  • Less glue code to maintain

This simplicity does not just improve agent productivity. It improves human understanding as well. Architecture that is transparent scales better over time than architecture optimized for abstraction purity.

Connection to spec-driven workflows

In the AI Unified Process and spec-driven development, system use cases are the central artifact describing observable behavior. The goal is to evolve code and tests from these specifications incrementally and safely.

Stacks that maximize transparency make this process smoother:

  • Behavior described in system use cases maps directly to UI flows in Vaadin
  • Data interactions described in specs map directly to SQL expressed via jOOQ
  • Agents can trace intent from specification to implementation with fewer interpretation gaps

The tighter this mapping is, the easier it becomes to keep specs, code, and tests aligned.

Final thoughts

This is not about claiming one stack is universally superior. Every architectural decision has trade-offs. But when optimizing for AI-assisted evolution of business applications, certain characteristics become highly valuable:

  • Coherence
  • Transparency
  • Explicit behavior
  • Type safety
  • Minimal indirection

Vaadin and jOOQ happen to align strongly with these properties. The result is a system that is easier for humans to reason about and easier for AI agents to evolve.

Sometimes progress is not about adding new tools.
It is about removing layers that no longer serve us.