Why AI Codegen Can't Build Your Data Pipeline

Ask an AI to build you a dashboard and it will. In one prompt you'll get a clean React component, a nice color palette, a responsive grid, maybe even a sensible chart type for your data. It looks done.

It is not done. It's the visible 10%. The other 90% — the part that makes the chart true tomorrow, at scale, for the right user — is the data pipeline. And that's the part AI codegen can't hand you.

What AI codegen is genuinely great at

Let's be fair, because the ceiling here is high and rising:

• Chart components — bar, line, area, the layout, the theming.
• Glue code — a fetch, a useEffect, wiring state to controls.
• One-shot transforms — "group these rows by month and sum revenue" on data you paste in.

If the data already exists, is already correct, and already fits in memory, AI codegen is a superpower. That's a real and useful envelope.

What it can't build (and why)

A "data pipeline" isn't one thing an AI forgot to generate. It's a set of stateful, long-lived, correctness-critical systems that can't be one-shot into existence. Here's the gap, concretely.

Connectors that survive reality

Pulling from Stripe, Postgres, a warehouse, a SaaS API — the naive version is a day of work. The real version handles auth refresh, rate limits, pagination, schema drift when a source adds a column, and the source being down at 3am. An AI can scaffold a connector; it can't operate one. Connectors are maintenance, not code.

Incremental ETL

The toy version reprocesses everything on every run. That works until you have real data volume, and then it's slow and expensive. Real ETL is incremental — it knows what changed since the last run, processes only that, and stays correct when a run fails halfway and retries. That's watermarks, idempotency, and state. There is no state for an AI to generate in a stateless prompt.

A query engine, not a SELECT

Writing SQL is easy; serving it isn't. A query engine joins across managed datasets, plans the execution, enforces limits so one query can't take down the box, and returns typed, columnar results. It's a running system with a lifecycle, not a string an AI emits.

Freshness and caching

Two questions every dashboard has to answer: is this current? and why did it take four seconds? Freshness means tracking when each dataset was last built and invalidating downstream when a source changes. Caching means repeat queries return instantly without re-running — and knowing exactly when a cached result is stale. These are runtime concerns with no source-code representation to generate.

Row-level security

The one that ends careers. Dashboard shows tenant A's revenue — fine. Now make sure tenant B, hitting the same dashboard, cannot see it, ever, even with a crafted request. That's row-level filtering enforced server-side, on every query, with fail-closed defaults. An AI writing a WHERE tenant_id = ... in a browser is not security — it's a filter the browser can rewrite. Real RLS has to live where the client can't reach it.

The tell: it's all state and runtime, not code

Notice the pattern. Everything AI codegen nails is stateless and static — a component, a transform, a snippet. Everything it can't do is stateful and runtime — connectors that run, ETL that remembers, caches that expire, security that's enforced on every request.

Codegen produces artifacts. Pipelines are systems that run. You can't generate a system into existence with a prompt any more than you can generate a database's uptime. The chart is an artifact; the freshness of the number in it is a system.

So: rent the system, generate the artifact

This is exactly the Vibedasher split, and it's why the split exists.

• Let AI generate the artifacts. Your dashboard's charts, layout, and filter logic are code — so let your AI (Claude Code, Cursor) build and eject them into your app. You own that code. It's the part codegen is great at.
• Rent the running system. The connectors, incremental ETL, query engine, freshness, caching, and row-level security are what Vibedasher operates. The whole thing surfaces through one call:

const { columns, rows } = await client.query({
  sql,      // alias-only SQL, composed from your controls
  params,   // { column: value } filters, bound server-side
});
// Managed datasets are inferred from the SQL's aliases — or pinned
// explicitly with `datasetIds: [...]`.

Every hard thing above happens behind that call. The table aliases resolve to managed datasets and filtered subqueries under row-level security. The result comes from cache when it can. Freshness is tracked upstream. Your ejected code never reasons about any of it — it asks for rows and gets typed rows.

That's the point of renting an engine: not because you couldn't build a query planner and an incremental ETL layer and a caching tier, but because building and operating them is a team and a roadmap, not a prompt — and it's not what makes your product yours.

The takeaway

AI codegen collapsed the cost of the frontend to near zero. It did not collapse the cost of the pipeline underneath — because that cost was never code. It was systems, state, and operations.

Generate the chart. Rent the engine that makes it true.

See how the engine surfaces to your code at docs.vibedasher.com, or describe your first dashboard at cloud.vibedasher.com.