Architecture

The AI Versioning Trap: Why We Might Be Stuck, and How the Native Web Can Help

When a framework introduces a necessary, fundamental architectural change, AI agents often struggle to keep up.

TD
Thomas David July 14, 2026 · 8 min read

In my experience building frameworks and tools, I've noticed a recurring friction point that seems to be quietly slowing us down. As we shift toward AI-driven development, where LLMs generate large portions of our code, versioning has become a surprisingly difficult hurdle.

Take Pocketbase, an amazing open source backend. I've found while attempting to use an LLM for help, only for it to confidently generate code using syntax from a year ago, insisting it's the latest version. Until a new update achieves massive, overwhelming adoption, the bulk of the AI's training data remains anchored to older patterns.

We find ourselves a bit stuck, tied to the architectural decisions of the past simply because that is what the models know best.

The Modern Stack vs. The Native Web API

To navigate this, I think we might need to reconsider our reliance on heavy, proprietary abstractions. Currently, if you want a complete, production-ready application, you usually have to stitch together a much larger stack, pairing your UI library with a meta-framework like Next.js or Astro just to handle server-side rendering (SSR) and static site generation (SSG).

This is exactly why I built Coralite. I wanted to step away from proprietary dependencies and build directly on top of the native Web API because it is simply the most stable API we can depend on.

html
Code copied!
  <template id="counter-card">
    <button ref="incrementBtn">+</button>
    <span>{{ count }}</span>
  </template>
  
  <script type="module">
    export const attributes = { step: { type: Number, default: 1 } }
    export function server () { return { count: 0 } }
    export async function client ({ state, refs, signal }) {
      refs('incrementBtn').addEventListener('click', () => {
        state.count += state.step
      }, { signal })
    }
  </script>

A Deliberately Predictable API

One of the primary issues with stitching together a modern stack is the resulting complexity. Deeply nested configurations and proprietary hooks can confuse both developers and AI models alike. When designing Coralite, I intentionally leaned toward simplicity through a "Flat Options" API.

The naming conventions within this API are very deliberate. A component's logic is isolated into four distinct blocks: attributes, server, getters, and client. There is very little room for misinterpretation when the terminology maps so directly to its function.

By using universally understood concepts, the cognitive load drops significantly. The framework manages the reactivity under the hood through a straightforward equation where Attributes + ServerState + Getters = State.

TD

Thomas David

Creator of Coralite. Writing about the intersection of native web APIs, compiler design, and AI-assisted development.