I like straight talk. The hype is real. Investors are searching for the next unicorn. Money flows, demos look great, and some platforms can produce working apps faster than any human team ever will. But if the goal is reliable software that survives contact with real users, real data, auth, policies, and deployment, the road today has a Cliff-Of-Death on it. You don’t fall right away. You sprint, you proceed, you smile, and then — in one final iteration — game over.

I name the pain.

Cliff-Of-Death is not drama; it’s a pattern. It’s the moment when your project, running fast and looking good, takes one more “small” change and collapses into a state you cannot safely recover from. Tests turn soft, UX drifts, migrations fight back, and you sit there with that empty feeling: I lost the project. I’ve seen it often enough to give it a name and design against it.

I’ve spent a few decades between business and IT, in boards, standards work, and more integrations than I want to count. Now with Gadlet I’m all-in on AI for building software. I want this revolution to work, not just trend on social. So let’s map the problems we see every day, why they happen, and what has to change.

Where AI coding shines (and why it feels magical) The speed, just the prompt that turns into real code, blazing fast. It is easy — if you can write text, you can code. Just tell what you want, AI delivers. Quality code and some serious heavy lifting. No hesitation, no excuses — just fast produced code. And best of all, all this happens in real time in front of your own eyes.

For prototyping it’s excellent:

Quick UX mockups.

Recipe-like apps with local storage.

Simple CRUD without complex auth.

One-page POCs and MVPs to test a market story.

If you stay in this lane, almost anyone can “vibe code.” It’s fun and very productive. You get speed, creativity, even surprisingly intuitive, working patterns.

But the second you add multiple features, shared state, databases, authentication, row-level security, policies, third-party APIs, migrations, or environments, the physics change. That’s where the Cliff-Of-Death waits.

The symptoms before you reach the edge

You don’t crash at the first turn. You see hairline cracks:

UX drift across iterations — components change behaviour or look after each “improve this” loop.

Forgotten decisions — that login flow you confirmed two days ago quietly becomes something else.

Unasked features appear while tested features vanish.

“One last change” corrupts a stable path — build succeeds, tests pass (sometimes made up), deployment fails in production.

If you miss these signals, the next merge or refactor pushes you over the Cliff-Of-Death. Your project isn’t just buggy — it’s beyond repair without a ground-up reset.

Hard truth: this is not “for dummies”

Today’s AI code generators still need senior-level control to reach production. You must think in architecture, boundaries, data contracts, security, deployment — not only in prompts.

We need control but at the same time, we don’t want to kill the intuitive spark the models bring. A huge paradox. Control vs. creativity is a balance: human holds the steering wheel, AI explores the road, but the driver is responsible for not letting it drive us off the road — and fall into that terrifying Cliff-Of-Death.

The elephant in the room: Context

Why does AI “lose the plot” on tasks that are not so complicated one by one? Because the system can’t see the whole project at once. Not really.

Two parts to this:

Technical context limits. Even with big windows, an app’s full reality (all files, decisions, logs, migrations, API specs, policies, test data, user stories) doesn’t fit comfortably. What the AI cannot see does not exist. Missing context breeds drift and hallucination — and sets up the Cliff-Of-Death.

Business model limits. Many platforms must offer “maximum results for minimum monthly price.” If you pay $20, the platform has to conserve tokens. That means the system intentionally narrows context: fewer files, shorter histories, lighter validation. It’s not evil; it’s economics. But when the budget wins over context, quality loses. The user thinks “I’m bad at prompting.” No — you’re under-contexted.

Prompt training helps, for sure. Good structure helps. But no prompt can carry a system’s missing memory.

The “learning curve” myth

It’s frustrating that support replies are often: “Be patient, this is the learning curve. You’re just learning to prompt.” Yes, in time you will get better. Prompt after prompt, project after project. But the Cliff-Of-Death doesn’t disappear. The real fix is more relevant context, held consistently, not more adjectives. Until the platform keeps and uses a richer, durable project memory, your best prompts will still hit the wall.

This brings us to my previous blog text: https://gadlet.com/posts/should-you-version-control-your-prompts/ — or even, should you version control the context? I will get back to this in my next article.

The cost reality

Serious capability costs money. Multi-agent runs, bigger context windows, repo-wide indexing, precise tests, ephemeral environments — these burn tokens and compute. Some services price light usage low and heavy usage high. On a small scale, cheap is fine. At production scale it will cost, and the cost can be eye-watering. Still, for the right use cases, cost efficiency vs. human teams can be strongly in AI’s favour. The point is: $20/month unlimited product-grade software is a nice dream, not a plan. Refusing this reality is how you earn a fast ticket to the Cliff-Of-Death.

What “good” looks like, a blueprint for reliable AI builds

Here’s the operational checklist we follow and advocate. This is how you tame the Cliff-Of-Death.

Spec-first, then code

Lock a living blueprint: domain glossary, user stories, non-functionals, data model, auth & RLS rules, third-party contracts, success metrics.

Convert blueprint into machine-readable artifacts the agents must obey (YAML/JSON schemas, OpenAPI, policy files).

Project memory is a first-class feature

Maintain a project graph of files, decisions, migrations, and APIs.

Use embedding + indexes for repo-level retrieval, not only “copy a few files into the prompt.”

Keep decision logs and rationales that agents must consult before changing behaviour.

Deterministic scaffolding, then bounded creativity

Generate a deterministic skeleton (folders, build system, lint, types, test harness, CI job).

Allow AI creativity inside modules, not across boundaries. Guardrails prevent silent rewrites of contracts.

Contracts everywhere

Types & schemas for every interface (front-end ↔ back-end ↔ DB ↔ external APIs).

Policy as code for auth and RLS; test these policies with fixtures, not by hand.

Tests that matter (and are enforced)

Seed unit + contract + e2e tests from the spec, not from a vague “add tests.”

Require tests to pass in a fresh ephemeral environment before merging.

Reproducible environments

One-click sandbox: clean DB, seed data, fake integrations.

Every agent run happens in the same shape of world your users will touch.

Migrations with rollback

Auto-generated DB migrations + rollback plans.

Agents must prove forward and backward compatibility before shipping.

Traceability and diffs

Every change carries a why and what it touched.

Humans review small, coherent diffs. No giant “trust me” patch bombs.

Time-boxed “creative bursts”

Give the model short windows for ideation (n variants), then freeze and evaluate.

Pick the best, merge, and move. This preserves good intuition without endless churn.

Cost is visible

Show the context budget and run cost to the user. Make trade-offs explicit: “We can include 5 more modules in context for X cost” rather than hiding it.

This is the opposite of “hope it works.” It is engineering discipline applied to AI code generation.

Why most platforms struggle today

If your product caps compute per user to keep the price low, you must reduce context, tests, environments, and iteration depth. That means:

The system forgets past decisions.

RLS, auth, and policy work become fragile.

Integration correctness decays over time.

UI and state drift because no global picture is enforced.

It’s not bad intentions; it’s a business constraint expressed as technical behaviour — and a straight path to the Cliff-Of-Death.

What we’re building at Gadlet

Our stance is simple: context budget is a product feature, not a hidden cost center. We design for repo-level reasoning, durable project memory, and deterministic pipelines. In practice:

Spec-bound multi-agents: planner, architect, coder, tester, integrator, each forced to read and respect the blueprint.

Repository-wide retrieval with a project graph, not just prompt paste.

Policy-as-code and RLS tested by generated fixtures before any deployment.

Ephemeral envs per change so “it works on my machine” stops being a joke.

Human-in-the-loop checkpoints with small diffs and clear rationales.

Transparent cost controls so you decide when to pay for wider context.

Our goal is to keep the intuitive AI design moments — the ones that make you smile — but put them inside a safe operating envelope. Democratizing coding doesn’t mean accepting chaos. It means packaging senior-level practice so everyone can use it — and never drive off the Cliff-Of-Death.

So… can AI build complex, production apps? Yes — with the right setup and enough context. No — if you expect it for $20 with unlimited everything.

Today you can ship easy apps and prototypes quickly. For complex systems, you still need to think like a senior, or use a platform that thinks that way on your behalf and lets you stay in control. Respect physics. Bigger promises need bigger context, disciplined pipelines, and honest pricing. That is how we remove the Cliff-Of-Death from the road.

Tell us your story Have you met the Cliff-Of-Death — or beaten it? What worked, what failed, where did the AI surprise you? Share your case: the stack, the scope, the point where things drifted (or didn’t). We’ll keep building Gadlet around real lessons, not wishful thinking.

Good. Less talk, more shipping.