AI failure modes: four lenses

When an AI feature fails, teams often blame the model. In practice, most failures come from the system around the model. I like to debug with four lenses. It keeps the conversation concrete and makes it easier to fix the right thing.

Lens 1 — Idea / problem: you don’t understand the user

Many failures happen before the first token. You are building “an AI assistant” but you cannot say what job it must do, for whom, and what “good” looks like.

Rule of thumb: get brutally clear on:

• Who the user is (and in which workflow).
• What they are trying to get done (one sentence).
• Which lagging metric proves it was worth it (time saved, resolution rate, revenue, churn).

If you cannot name the outcome, the rest becomes guessing: prompts, tools, retrieval, even evals.

Lens 2 — Data / context: retrieval and grounding failures

Most “AI is dumb” moments are context failures. The model is missing the right facts at runtime, so it fills gaps.

A good retrieval system is a product in itself. It needs:

• Good corpora: clean docs, deduped, with structure (titles, headings).
• Good metadata: type, owner, language, timestamps, authority, source.
• Good indexing: chunking by meaning, normalization, filters.
• Good ranking: often hybrid retrieval (keywords + vectors) + reranking.

If your application is time-sensitive, “recent” is a feature. Add time-aware ranking or filters so stale docs do not win.

Lens 3 — LLM / token factory: wrong model, wrong tradeoffs

Model choice matters after the problem and context are clear. My default sequence:

1. Start strong. Use a frontier model to learn if the idea and context are viable.
2. Fix the system. Tighten prompts, add validation, improve retrieval, improve UX.
3. Then optimize. Step down to cheaper models until you hit the cost/latency/capability balance you can live with.

Fine-tuning is useful for some narrow problems. Failures caused by missing facts, weak tools, or unclear outcomes require fixes elsewhere in the system.

Lens 4 — Agentic tool use: overcomplicated, under-specified

Agents fail when the tooling layer is messy: too many tools, overlapping responsibilities, unclear parameters, and no safety constraints.

Better patterns that ship:

• Simple tools. Narrow responsibilities. Small inputs and outputs.
• Make tools distinct. One tool for search, one for writing state, one for calculations.
• Scaffolding. Use deterministic routing/heuristics to reduce tool-choice chaos.
• Guardrails. Validate arguments, retry with bounded changes, and fail safely (“I don’t know” / “I need clarification”).

Closing thought: when something breaks, resist the reflex to swap models first. Step back and ask which lens is failing: the job-to-be-done, the context, the model tradeoffs, or the tools. Clearer outcomes, better evidence, tighter contracts, and safer defaults usually provide the fix.