The problem
More and more organisations have apps built by prompting instead of designing: vibe coding. Someone describes what the app should do, an AI coding assistant writes the code, and after a few rounds it works. The app talks directly to the API of one provider, say OpenAI or Anthropic, and the prompts are tuned precisely to the behaviour of that one model.
As long as nothing changes, that works. The problem arrives with the first change: a price increase, a model that is retired, a new regulatory requirement about where data may live, or simply a better and cheaper model elsewhere. Then it turns out that switching models breaks the software.
Why switching breaks
- The prompts were written for one model. Another model reads the same instruction differently and answers differently, in a different shape. Everything downstream falls over.
- The provider is everywhere in the code. Not behind one interface, but in dozens of places, each with its own call, its own error handling and its own assumptions about the answer.
- There is no architecture to fall back on. Vibe-coded apps grew, they were not designed. Nobody can say exactly what the app does and why, so nobody dares touch it.
- There are no tests. Whether the new model gives the same result can only be seen by trying it in production.
What it costs
Financially: the provider sets the price, because you cannot leave. Every increase in the token price lands directly in your costs, with no room to negotiate. Technically: every model update by the provider is a risk to your app, even when you change nothing yourself. And strategically: whether your data goes to an American cloud is no longer your choice, because the app cannot do otherwise.
This is the same trap as lock-in with low-code, only built faster and therefore overlooked more often.
Our approach
- The model behind one door. Every call to AI goes through one layer in your own code. Switching provider or model is then one change in one place, not a rebuild.
- Code does what code can. Everything that can be captured in rules lives in ordinary code. The model only gets the questions that really need understanding, in a form that does not depend on one model. See deterministic first.
- A test set per application. A fixed set of questions with approved answers. A new model runs the test set first; only when it passes does it go live.
- Local AI where possible. An open model on your own hardware is yours. Nobody can raise the price or switch the model off, and the data stays inside.
- House rules for AI coding assistants. Building fast is fine, but within an architecture agreed beforehand, so the app belongs to the organisation and not to the prompt.
What to look for
- Ask per app: in how many places does the name of the AI provider appear in the code? More than one is a warning sign.
- Ask: could we try another model tomorrow, and how would we know whether it still works?
- Work out a year of token costs and consider what a doubling would mean. If that answer is uncomfortable, there is lock-in.
- Have new apps built through the one door from day one. Rebuilding afterwards costs many times more.
Would you like advice on AI lock-in? Request a free advice conversation.
Updated on