Edge Cases AI Misses: The Human Intuition Gap

The 80/20 Problem

AI-driven development has transformed how software is built. Large language models generate production-ready code in seconds, optimize common workflows, and dramatically accelerate delivery. For the 80% of predictable system behavior, they perform remarkably well.

The problem lives in the remaining 20%.

Edge cases — rare inputs, legacy quirks, unusual integrations, atypical user behavior — are where systems fail. These scenarios are invisible during demos and early testing. In production, they become outages, data corruption events, or security incidents.

Why LLMs Struggle at the Edges

LLMs learn from statistical patterns in training data. They are, by design, optimizers for the common case. This makes them excellent at generating idiomatic code for well-understood problems — and systematically unreliable when problems diverge from that norm.

Consider this code, which an AI will generate confidently:

async function getUserBalance(
  userId: string,
  currency: string = 'USD'
): Promise<number> {
  const user = await db.findUser(userId);
  return user.balances[currency]; // Works in 99.7% of cases...
}

In testing it works fine. In production at 2am, it silently returns undefined when a new currency code is introduced mid-transaction — and that propagates through downstream calculations until it surfaces as a corrupted financial record three days later.

async function getUserBalance(
  userId: string,
  currency: string = 'USD'
): Promise<number> {
  const user = await db.findUser(userId);
  if (!user) throw new UserNotFoundError(userId);

  const balance = user.balances[currency];
  if (balance === undefined) {
    // Added after March 2024 incident — new currencies lack historical balances.
    // ~2,300 legacy accounts affected. DO NOT remove this guard.
    throw new UnsupportedCurrencyError(currency, Object.keys(user.balances));
  }
  return balance;
}

The difference is not technical capability. It is the accumulated experience of having seen undefined arithmetic corrupt a production database. LLMs are trained on code that exists; they learn its patterns and its omissions equally.

When Edge Cases Become Security Incidents

The risk compounds when edge cases intersect with security. Two cases define the pattern:

Neither vulnerability would have been caught by a tool optimizing for common code patterns. Both required understanding why that specific code path existed and what could go wrong when its assumptions were violated.

The Production Reality

The pattern is consistent across teams and codebases: core logic works, demo environments look stable, production exposes what was never considered.

// AI generates this. Correct 99.7% of the time.
function isWithin24Hours(timestamp: number): boolean {
  return Date.now() - timestamp < 24 * 60 * 60 * 1000;
}
// Breaks at DST transitions in some locales.
// Breaks at leap seconds.
// Breaks when the server clock drifts and is corrected.

The Intuition Gap Defined

When a senior engineer reviews code, they are not only asking: does this work? They are asking:

• Why does this branch exist?

  Is there a defensive check here that hints at a historical failure nobody documented?

• Who depends on this workflow under stress?

  What changes about this path when the system is degraded?

• What historical constraint shaped this implementation?

  Why is this returning a string instead of a number — is there a downstream consumer that breaks on numeric types?

• Which legacy assumption can still break this system?

  That user.id will always be a UUID — until the batch import job that creates synthetic IDs with a different format.

LLMs operate on probability distributions across observed code. Humans operate on institutional memory, lived experience with production failures, and the ability to model consequences rather than just behaviors.

This difference is the intuition gap. It cannot be closed by making models larger. It is not a knowledge problem — it is a context problem. And context, unlike syntax, does not persist in codebases unless someone deliberately captures it.

Bridging the Gap

The solution is not to distrust AI-generated code. It is to preserve the reasoning that AI cannot generate.

When a defensive check is added, it should carry an explanation: Added after the March 2024 incident where a new currency code was introduced without a migration. This path is reachable.

When a legacy behavior is accommodated, the intent should be explicit: Users created before 2019 do not have a type field. This fallback handles the ~2,300 accounts in that cohort.