God Functions: Why AI Generates 200-Line Monsters (And How to Split Them)

The God Function Problem in AI-Generated Code

A god function is a function that knows too much and does too much. It handles input validation, database calls, business logic, error formatting, and response shaping - all in sequence, all in the same function body. When you read through vibe-coded apps built with Cursor or Lovable, these functions appear constantly.

The reason is structural. AI models generate code to satisfy the full prompt in one pass. "Handle user registration" becomes a single function that checks if the email exists, hashes the password, creates the user, sends a welcome email, logs the event, and returns a formatted response - 180 lines of sequential, deeply-nested code. It works. It ships. It becomes unmaintainable in months.

According to SonarSource's analysis of over 500,000 open-source projects, functions exceeding 80 lines account for 62% of all critical bugs found in JavaScript codebases. The correlation between function length and defect density is not coincidental - it is structural. Longer functions have more execution paths, more shared state, and more places where an assumption can quietly break.

How AI Generates Complexity: A Real Example

Ask Bolt or Cursor to "create a checkout handler" and you are likely to get something like this:

// ❌ BAD - God function: 1 function, 7 responsibilities
async function handleCheckout(req, res) {
  try {
    const { userId, cartItems, couponCode, shippingAddress } = req.body;

    // Validate inputs (responsibility 1)
    if (!userId || !cartItems || cartItems.length === 0) {
      return res.status(400).json({ error: 'Invalid input' });
    }
    if (!shippingAddress || !shippingAddress.zip) {
      return res.status(400).json({ error: 'Missing address' });
    }

    // Calculate price (responsibility 2)
    let total = 0;
    for (const item of cartItems) {
      const product = await db.products.findUnique({ where: { id: item.productId } });
      if (!product) return res.status(404).json({ error: `Product ${item.productId} not found` });
      total += product.price * item.quantity;
      if (product.stock < item.quantity) {
        return res.status(400).json({ error: `${product.name} out of stock` });
      }
    }

    // Apply coupon (responsibility 3)
    if (couponCode) {
      const coupon = await db.coupons.findUnique({ where: { code: couponCode } });
      if (coupon && coupon.active && new Date() < new Date(coupon.expiresAt)) {
        total = total * (1 - coupon.discount);
      }
    }

    // Charge Stripe (responsibility 4)
    const paymentIntent = await stripe.paymentIntents.create({
      amount: Math.round(total * 100),
      currency: 'usd',
      customer: userId,
      metadata: { cartItems: JSON.stringify(cartItems) },
    });

    // Create order (responsibility 5)
    const order = await db.orders.create({
      data: {
        userId,
        total,
        status: 'pending',
        stripePaymentIntentId: paymentIntent.id,
        items: { create: cartItems.map(i => ({ productId: i.productId, quantity: i.quantity })) },
        shippingAddress: JSON.stringify(shippingAddress),
      },
    });

    // Update stock (responsibility 6)
    for (const item of cartItems) {
      await db.products.update({
        where: { id: item.productId },
        data: { stock: { decrement: item.quantity } },
      });
    }

    // Send confirmation email (responsibility 7)
    await sendEmail({
      to: req.user.email,
      subject: 'Order confirmed',
      body: `Your order #${order.id} has been placed.`,
    });

    return res.json({ orderId: order.id, clientSecret: paymentIntent.client_secret });

  } catch (err) {
    console.error(err);
    return res.status(500).json({ error: 'Checkout failed' });
  }
}

This function has 7 distinct responsibilities, 3 levels of nesting, and is impossible to unit-test in isolation. Testing the coupon logic requires setting up a Stripe mock, a database mock, and a mail server mock simultaneously.

Why Deep Nesting Is the Most Dangerous Symptom

Function length is a proxy metric. The root issue is cognitive complexity - how hard it is to hold the function's logic in your head. SonarSource's cognitive complexity metric penalizes nesting harder than length. A function with 5 levels of nesting scores as complex as a 200-line flat function.

Deep nesting in AI code typically takes one of two forms. The first is the validation pyramid: each validation check adds another level of indentation, pushing the happy path to column 40+. The second is the callback/promise staircase: nested async calls, each dependent on the last, forming a diagonal line of code that moves rightward.

The DORA 2024 State of DevOps report found that teams with high code complexity scores had 4.5x more deployment failures than teams with low complexity. Complexity is not an aesthetic concern - it directly predicts production incidents.

The Refactored Version: One Function, One Job

// ✅ GOOD - Each function has one responsibility

async function validateCartItems(cartItems) {
  const products = [];
  for (const item of cartItems) {
    const product = await db.products.findUnique({ where: { id: item.productId } });
    if (!product) throw new Error(`Product ${item.productId} not found`);
    if (product.stock < item.quantity) throw new Error(`${product.name} out of stock`);
    products.push({ ...product, requestedQty: item.quantity });
  }
  return products;
}

async function calculateTotal(products, couponCode) {
  let total = products.reduce((sum, p) => sum + p.price * p.requestedQty, 0);
  if (couponCode) {
    const coupon = await db.coupons.findUnique({ where: { code: couponCode } });
    if (coupon?.active && new Date() < new Date(coupon.expiresAt)) {
      total = total * (1 - coupon.discount);
    }
  }
  return total;
}

async function chargeAndCreateOrder(userId, total, cartItems, shippingAddress) {
  const paymentIntent = await stripe.paymentIntents.create({
    amount: Math.round(total * 100),
    currency: 'usd',
    customer: userId,
  });
  return db.orders.create({
    data: {
      userId, total,
      status: 'pending',
      stripePaymentIntentId: paymentIntent.id,
      items: { create: cartItems.map(i => ({ productId: i.productId, quantity: i.quantity })) },
      shippingAddress: JSON.stringify(shippingAddress),
    },
  });
}

// Orchestrator - thin, readable, testable
async function handleCheckout(req, res) {
  const { userId, cartItems, couponCode, shippingAddress } = req.body;
  if (!userId || !cartItems?.length || !shippingAddress?.zip) {
    return res.status(400).json({ error: 'Invalid input' });
  }
  try {
    const products  = await validateCartItems(cartItems);
    const total     = await calculateTotal(products, couponCode);
    const order     = await chargeAndCreateOrder(userId, total, cartItems, shippingAddress);
    await decrementStock(cartItems);
    await sendOrderConfirmation(req.user.email, order.id);
    return res.json({ orderId: order.id });
  } catch (err) {
    return res.status(400).json({ error: err.message });
  }
}

Each extracted function can now be tested independently. calculateTotal can be tested with no database and no Stripe. validateCartItems can be tested against a mock database. The orchestrator reads like a specification of the checkout process.

Three Metrics That Flag God Functions

When reviewing AI-generated code, apply these three checks to every function:

How to Fix God Functions in Your Codebase

Refactoring god functions is not a single-session task. Apply this approach iteratively:

1. Write characterization tests first. Before touching a god function, write tests that document its current behavior. This gives you a safety net for refactoring.
2. Extract by responsibility, not by line count. Do not split at arbitrary line numbers. Find coherent groups of lines that represent a single responsibility and extract those into named functions.
3. Name functions after their intention. A function named calculateDiscountedTotal is self-documenting. A function named processData is not.
4. Replace parameter lists with objects. If a function takes more than 4 parameters, group them into a typed object. This makes call sites readable and reduces the number of arguments to track.

Tools like VibeDoctor (vibedoctor.io) automatically scan your codebase for overly complex functions and flag specific file paths and line numbers where god functions exist. Free to sign up.

FAQ