Skip to content
BSWEN
Blog

How to Reduce Lines of Code When AI Coding Assistants Create Bloated Code

Cowrie
Cowrie
Dev @ Bswen

The Problem: AI Writes Too Much Code

Last month, I asked Claude Code to add a simple feature to my project. When I checked the diff, it had added 180 lines across 4 files for what should have been a 20-line change.

Looking closer, I found the classic AI code bloat pattern:

  • Helper functions used only once
  • Excessive error handling with fallbacks everywhere
  • Duplicate logic that already existed elsewhere
  • Abstracted interfaces for things that didn’t need abstraction

Here’s what I mean. I asked for “add validation to user input”:

userInput.ts
// Helper function - only used once
function validateUserInput(input: string): boolean {
  if (input === null || input === undefined) {
    return false;
  }
  if (typeof input !== 'string') {
    return false;
  }
  if (input.trim().length === 0) {
    return false;
  }
  return true;
}


// Helper function - only used once
function sanitizeInput(input: string): string {
  return input.trim().toLowerCase();
}


// Helper function - only used once
function formatErrorMessage(error: unknown): string {
  if (error instanceof Error) {
    return error.message;
  }
  return 'An unknown error occurred';
}


async function processUserInput(input: string | null): Promise<string> {
  if (!validateUserInput(input as string)) {
    throw new Error('Invalid input provided');
  }
  try {
    const sanitized = sanitizeInput(input as string);
    return await processData(sanitized);
  } catch (error) {
    throw new Error(formatErrorMessage(error));
  }
}

35 lines. All I needed was this:

userInput.ts
async function processUserInput(input: string | null): Promise<string> {
  if (!input?.trim()) throw new Error('Invalid input');
  return processData(input.trim().toLowerCase());
}

12 lines. Same functionality. The AI version is nearly 3x longer.

Why Does AI Produce Bloated Code?

After seeing this pattern repeatedly, I dug into why AI coding assistants default to verbosity.

1. Safety Bias

AI models are trained to be helpful and defensive. When asked to “add error handling,” they interpret it as “add comprehensive error handling.” They create multiple fallbacks, type checks, and recovery paths that might never be needed.

User says: "Add error handling"
AI hears: "Add comprehensive error handling with all edge cases,
          multiple fallbacks, retry logic, and graceful degradation"

This is helpful for beginners but frustrating for experienced developers who know exactly what they want.

2. Template-Based Generation

AI models have seen millions of code examples. When generating code, they default to common patterns, even when simpler patterns exist.

Common pattern:    Validate -> Sanitize -> Process -> Handle Errors
Simple pattern:    Check and process

The template approach produces correct code, but not concise code.

3. Context Window Limitations

AI doesn’t always see your entire codebase. It might create a helper function that already exists elsewhere, or implement logic that’s already in your utilities.

4. The Abstraction Reflex

AI loves creating abstractions. Every piece of logic becomes a named function, even if it’s used once and is clearer inline.

Abstraction reflex pattern:
- validateUserInput() → used in 1 place
- sanitizeInput() → used in 1 place
- formatErrorMessage() → used in 1 place
- createResponseObject() → used in 1 place
- processAndValidate() → used in 1 place

Each abstraction adds cognitive overhead. Now you need to understand 5 functions instead of 1 coherent piece of logic.

The Solution: Post-Generation Refactoring

After trying different approaches, I found that refactoring after AI generates code is more effective than trying to prevent bloat upfront.

The Magic Prompt

Once AI gives you working code, use this prompt:

Refactor this code to be as concise as possible. Rules:
1. Inline all functions used only once
2. Remove redundant error handlers (keep only essential try/catch)
3. Consolidate similar logic patterns
4. Eliminate unnecessary intermediate variables
5. Do NOT sacrifice readability or type safety


Current LOC: [X]
Target: Reduce by 40%

This prompt works because:

  1. Working code exists - You can verify behavior doesn’t change
  2. Clear metrics - “Reduce by 40%” gives AI a specific target
  3. Constraints are explicit - No readability sacrifice
  4. Rules are actionable - AI knows exactly what to do

Before and After Example

I used this prompt on a Claude-generated file handler:

Before (68 lines):

fileHandler.ts
interface FileHandlerConfig {
  basePath: string;
  maxFileSize: number;
  allowedExtensions: string[];
}


interface FileHandlerResult {
  success: boolean;
  data?: string;
  error?: string;
}


function createFileHandler(config: FileHandlerConfig) {
  function validatePath(path: string): boolean {
    if (!path) return false;
    if (path.includes('..')) return false;
    if (path.startsWith('/')) return false;
    return true;
  }


  function validateExtension(path: string): boolean {
    const ext = path.split('.').pop()?.toLowerCase();
    return config.allowedExtensions.includes(ext || '');
  }


  function validateSize(size: number): boolean {
    return size <= config.maxFileSize;
  }


  function formatError(message: string): FileHandlerResult {
    return { success: false, error: message };
  }


  function formatSuccess(data: string): FileHandlerResult {
    return { success: true, data };
  }


  return {
    async readFile(path: string): Promise<FileHandlerResult> {
      if (!validatePath(path)) {
        return formatError('Invalid path');
      }
      if (!validateExtension(path)) {
        return formatError('Extension not allowed');
      }


      try {
        const fullPath = `${config.basePath}/${path}`;
        const stats = await fs.stat(fullPath);


        if (!validateSize(stats.size)) {
          return formatError('File too large');
        }


        const content = await fs.readFile(fullPath, 'utf-8');
        return formatSuccess(content);
      } catch (error) {
        return formatError(error instanceof Error ? error.message : 'Unknown error');
      }
    }
  };
}

After (28 lines):

fileHandler.ts
function createFileHandler(config: { basePath: string; maxFileSize: number; allowedExtensions: string[] }) {
  return {
    async readFile(path: string) {
      if (!path || path.includes('..') || path.startsWith('/')) {
        return { success: false, error: 'Invalid path' };
      }


      const ext = path.split('.').pop()?.toLowerCase();
      if (!config.allowedExtensions.includes(ext || '')) {
        return { success: false, error: 'Extension not allowed' };
      }


      try {
        const fullPath = `${config.basePath}/${path}`;
        const stats = await fs.stat(fullPath);
        if (stats.size > config.maxFileSize) {
          return { success: false, error: 'File too large' };
        }
        return { success: true, data: await fs.readFile(fullPath, 'utf-8') };
      } catch (error) {
        return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
      }
    }
  };
}

Same functionality. 59% reduction in lines. Easier to read because everything is in one place.

Pre-Generation Strategies

While post-generation refactoring is most effective, you can also prevent some bloat upfront.

Specify Constraints Upfront

Bad prompt:

Add error handling to this function

Good prompt:

Add essential error handling to this function. Only catch specific,
recoverable errors. No fallbacks, no retry logic. Keep under 10 additional lines.

The key phrases:

  • “essential” - Not comprehensive
  • “specific, recoverable” - Not all errors
  • “No fallbacks, no retry logic” - Explicit exclusions
  • “Keep under 10 additional lines” - Hard constraint

Provide Pattern Examples

Show AI the style you want:

Here's my coding style for error handling:


async function fetchUser(id: string) {
  const res = await fetch(`/users/${id}`);
  if (!res.ok) throw new Error(`Failed: ${res.status}`);
  return res.json();
}


Apply this style to the following code...

AI will match the pattern you provide, producing code that fits your codebase.

Comparison Technique

Another effective strategy: compare AI output against what you’d write manually.

The 5-Minute Test

Write the feature yourself (or sketch it) in 5 minutes. Then compare:

My manual version: 25 lines
AI first draft: 80 lines
After refactor prompt: 30 lines

If the gap between your version and AI’s first draft is large, you’re seeing AI bloat. Apply the refactor prompt.

The Bloat Detection Checklist

When reviewing AI-generated code, check for:

[ ] Functions used only once
[ ] Excessive type definitions for simple objects
[ ] Multiple error handlers doing the same thing
[ ] Intermediate variables that add no clarity
[ ] Abstracted interfaces that are never implemented differently
[ ] Comments explaining obvious code
[ ] Fallback chains that are never triggered

Each check mark is an opportunity to reduce LOC.

Tool-Specific Tips

Claude Code

Use CLAUDE.md to set code quality rules:

CLAUDE.md
## Code Quality
- Prefer inline logic for single-use helpers
- Keep functions under 30 lines
- Avoid intermediate variables that don't add clarity
- No defensive coding unless explicitly requested

Claude Code reads these rules before generating code.

GitHub Copilot

Use comment-driven development:

// Simple validation, throw on invalid, no fallbacks
function validateUser(input) {

Copilot will match the comment’s conciseness.

Cursor

Use chat-based refactoring:

/chat Make this file 40% shorter while keeping the same behavior

Cursor excels at targeted refactoring.

Prompt Templates for LOC Reduction

Here are copy-paste templates for common scenarios.

Template 1: New Feature

Implement [feature]. Requirements:
- Working code first, then optimize for conciseness
- Maximum [N] lines total
- No abstractions unless used in 3+ places


After implementation, refactor to reduce LOC by 30%.

Template 2: Bug Fix

Fix [bug]. Rules:
- Minimal changes to fix the issue
- No refactoring unrelated code
- If adding error handling, be specific about which errors
- Keep the diff as small as possible

Template 3: Refactoring

Refactor [file] for conciseness. Current: [X] lines. Target: [Y] lines.
Rules:
1. Inline single-use functions
2. Remove redundant error handlers
3. Consolidate duplicate patterns
4. Keep behavior identical
5. Maintain type safety

What NOT to Do

From my mistakes:

Don’t Accept First Drafts

AI first drafts are almost always verbose. Build a workflow where you:

  1. Get working code from AI
  2. Apply refactor prompt
  3. Review the diff
  4. Test behavior

Don’t Use Vague “Make It Better” Prompts

Bad: "Make this code cleaner"
Good: "Reduce this from 50 to 30 lines by inlining single-use functions"

Vague prompts produce unpredictable results. Specific constraints produce predictable outcomes.

Don’t Let AI Create New Files Without Review

AI might create utils.ts, helpers.ts, types.ts for code that belongs in one file. Review file structure before accepting.

Summary

In this post, I showed why AI coding assistants produce bloated code and practical strategies to reduce lines of code:

Why AI creates bloat:

  1. Safety bias - AI defaults to defensive coding
  2. Template-based generation - Uses common patterns even when simpler patterns exist
  3. Context limitations - Doesn’t see your existing utilities
  4. Abstraction reflex - Creates functions for everything

How to fix it:

  1. Post-generation refactoring - Use the “reduce LOC by X%” prompt after getting working code
  2. Specify constraints upfront - Give AI hard limits and explicit exclusions
  3. Compare against manual implementation - Spot bloat by comparing with what you’d write
  4. Use tool-specific features - CLAUDE.md rules, comment-driven development, chat refactoring

The most effective approach is: get working code first, then refactor for conciseness. Don’t try to prevent bloat upfront - AI generates better code when you let it work, then optimize.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: