The Whole-Stack EngineerLibrary

Field note

Will it survive production?

A readiness checklist for AI systems

Most AI projects demo well and break in production. The demo proves the model can do it once. Production is where it has to do it reliably, at a cost you can afford, under real data and real users. Here is the checklist I run when I go into a build or a rescue. If you cannot check most of these, the system is not production-ready, no matter how good the demo looked.

Reliability

  • Every model call has a timeout and a real fallback (a cheaper model, a cached answer, or a graceful failure), not just a retry.
  • Circuit breakers, so one provider outage does not take the whole system down.
  • Capped backoff on interactive paths, exponential only for async work. One blanket retry policy is a tell that nobody thought about latency.
  • The system degrades gracefully. A failure returns something useful, not a stack trace.

Grounding and accuracy

  • Answers are grounded in retrieved sources, not the model's memory, wherever facts matter.
  • No source, no answer. The system can say “I do not know” instead of inventing one.
  • Retrieval is tested for relevance, not just similarity. Semantically similar is not the same as actually correct.

Evaluation (the part most teams skip)

  • A golden set of real inputs with known-good outputs, run in CI, that blocks a bad change before it reaches production.
  • If you use an LLM to grade outputs, you have a way to validate the grader itself. Who grounds the judge?
  • You measure quality on your real traffic, not on the demo prompt.
  • “Has tests” is not the bar. Tests that actually exercise the system are. Existence is the weakest evidence there is.

Human in the loop

  • The AI proposes, and a person approves anything consequential: money, data changes, customer-facing actions.
  • A clear escalation path when the system is unsure, with enough context for the human to act.

Cost and performance

  • You know your cost per request and your latency distribution. The tail, not just the average.
  • Caching at the levels that matter (exact, semantic, precomputed), so you are not paying the model twice for the same work.
  • A plan for what happens under load, not only the happy path.

Security and privacy

  • Untrusted input cannot hijack the model, and the model cannot take actions beyond its scope.
  • PII is redacted before it is embedded or stored. Once it is inside a vector, you cannot cleanly pull it back out.
  • Sensitive data is filtered by who is allowed to see it, at retrieval time.

Observability

  • Per request, you can see cost, latency, which model ran, whether it was grounded, and whether it escalated.
  • You are alerted when quality or grounding drops, before a customer tells you.

The judgment layer (the real differentiator)

  • Someone owns the end-to-end outcome, not just their own piece. The hardest failures live in the gaps between components.
  • The team can explain why each design choice was made and what it trades off. If they can only tell you that it works, that is the risk.

A checklist tells you what to check. The harder problem is making sure it is actually enforced and does not quietly get switched off when a deadline hits. That is a system, not a document, and building it is the work I do. If you have a build that needs to clear this bar, or one that is already stuck, let us talk.