Missing Error Handling in AI-Generated Code: Silent Failures Everywhere

The Silent Failure Problem in AI-Generated Code

A silent failure is when your code encounters an error, discards it, and continues as if nothing happened. The user sees a blank list instead of their data. A payment is attempted but not recorded. A file upload succeeds on the client but never reaches the server. No exception is thrown, no error is logged, and no alert fires.

Silent failures are the most dangerous class of bug in production applications because they are invisible by definition. You will not find them in your error tracking tool. You will not see them in your server logs. You will discover them when a customer reports that their account looks wrong, or when you run a data integrity audit and find thousands of orphaned records.

According to the DORA 2024 State of DevOps report, teams with robust error handling and observability resolve incidents 4x faster than teams without it. The bottleneck is detection time - and silent failures maximize detection time by producing no signal at all.

Veracode's State of Software Security report found that improper error handling is present in 70% of all applications scanned, making it one of the most pervasive code quality issues across the industry. In AI-generated codebases, the prevalence is higher because AI models optimize for the happy path.

What AI Tools Actually Generate

Here are three concrete examples of missing error handling, each representing a different pattern Cursor, Bolt, and Lovable generate regularly:

// ❌ BAD - Pattern 1: .then() with no .catch()
function loadUserProfile(userId) {
  fetch(`/api/users/${userId}`)
    .then(res => res.json())
    .then(data => {
      setUser(data);
    });
  // If the fetch fails, the promise rejects silently.
  // setUser is never called. The UI freezes on empty state.
}

// ❌ BAD - Pattern 2: try/catch that swallows the error
async function saveOrder(orderData) {
  try {
    const order = await db.orders.create({ data: orderData });
    return order;
  } catch (err) {
    console.log(err); // Logged but nothing is returned
    // Caller receives undefined, proceeds as if save succeeded
  }
}

// ❌ BAD - Pattern 3: async function with no error handling at all
async function sendWelcomeEmail(user) {
  const response = await fetch('/api/send-email', {
    method: 'POST',
    body: JSON.stringify({ to: user.email, template: 'welcome' }),
  });
  const result = await response.json();
  return result;
  // If the email service is down, this throws an unhandled rejection
  // Node.js process may crash, or the error surfaces in a confusing place
}

Each pattern fails differently. Pattern 1 causes a UI freeze. Pattern 2 creates phantom success - the caller thinks the save worked. Pattern 3 causes an unhandled promise rejection that, in Node.js 15+, terminates the process.

What Meaningful Error Handling Looks Like

// ✅ GOOD - Explicit error handling at every async boundary

// Pattern 1 fixed: .catch() on every .then() chain
function loadUserProfile(userId) {
  fetch(`/api/users/${userId}`)
    .then(res => {
      if (!res.ok) throw new Error(`HTTP ${res.status} fetching user ${userId}`);
      return res.json();
    })
    .then(data => setUser(data))
    .catch(err => {
      console.error('loadUserProfile failed:', err.message);
      setUserError('Could not load profile. Please try again.');
    });
}

// Pattern 2 fixed: re-throw so callers know about failures
async function saveOrder(orderData) {
  try {
    const order = await db.orders.create({ data: orderData });
    return order;
  } catch (err) {
    console.error('saveOrder failed:', { orderData, err: err.message });
    throw new Error(`Order save failed: ${err.message}`);
    // Caller receives a thrown error, not undefined
  }
}

// Pattern 3 fixed: check response status, handle failure cases
async function sendWelcomeEmail(user) {
  try {
    const response = await fetch('/api/send-email', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ to: user.email, template: 'welcome' }),
    });
    if (!response.ok) {
      const body = await response.text();
      throw new Error(`Email API error ${response.status}: ${body}`);
    }
    return await response.json();
  } catch (err) {
    // Log for observability, but do not crash the caller
    console.error('sendWelcomeEmail failed:', err.message);
    // Return a typed failure result instead of throwing
    return { success: false, reason: err.message };
  }
}

The Four Rules of Meaningful Error Handling

A catch block is not meaningful just because it exists. An empty catch block, or one that only calls console.log and returns nothing, is almost as bad as no catch block. Apply these four rules to every error handler in your codebase:

Special Case: Supabase and Prisma Error Patterns

Vibe-coded apps built on Supabase or using Prisma with Next.js have specific error patterns AI tools consistently mishandle.

Supabase client methods return { data, error } tuples. They do not throw. AI tools often check data without checking error, or check neither:

// ❌ BAD - Supabase error ignored
const { data } = await supabase.from('orders').select('*').eq('user_id', userId);
setOrders(data); // data is null on error, error object is discarded

// ✅ GOOD - Supabase error handled
const { data, error } = await supabase.from('orders').select('*').eq('user_id', userId);
if (error) {
  console.error('Failed to fetch orders:', error.message);
  setOrdersError(error.message);
  return;
}
setOrders(data);

Prisma throws exceptions on constraint violations, connection failures, and invalid queries. These need try/catch in every calling function - not just at the route handler level.

How to Find Missing Error Handling in Your Codebase

Manual review is unreliable for this class of bug. The patterns are subtle and spread across every async call in the project. Automated approaches:

• TypeScript's no-floating-promises rule: Catches unawaited async calls - the source of most unhandled rejections
• ESLint no-empty and no-empty-catch: Flags empty catch blocks that swallow errors silently
• Search for .then( without adjacent .catch(: A quick grep reveals uncaught chains
• Search for catch blocks containing only console.log: These are pseudo-handlers that do nothing useful

Tools like VibeDoctor (vibedoctor.io) automatically scan your codebase for missing error handling and flag specific file paths and line numbers. Free to sign up.

FAQ