Anti-Bloat Checklist

Overview

Checklist สำหรับตรวจสอบว่า context/prompt/response มี "bloat" หรือไม่ - ข้อมูลที่ไม่จำเป็น ซ้ำซ้อน หรือกิน token โดยไม่เพิ่ม value

Why This Matters

•Token cost: ทุก token มีค่าใช้จ่าย
•Context limit: Window มีจำกัด ใช้ให้คุ้ม
•Signal-to-noise: Bloat ทำให้ AI หลุด focus
•Speed: น้อย token = response เร็วขึ้น

Common Bloat Types

1. Filler Words

code

❌ Bloat:
"Basically, I think we should essentially try to implement this feature"

✅ Clean:
"Implement this feature"

Common fillers:
- basically, essentially, actually
- just, simply, really
- kind of, sort of
- very, quite, rather

2. Redundancy

code

❌ Bloat:
"The API endpoint returns a JSON response in JSON format"

✅ Clean:
"The API returns JSON"

Redundant patterns:
- "JSON response in JSON format"
- "database DB"
- "API endpoint API"
- Repeating same info in multiple places

3. Unnecessary Context

code

❌ Bloat:
Including entire file when only need 10 lines

✅ Clean:
Include only relevant snippet with line numbers

Example:
"See lines 45-55 in auth.ts for implementation"

Prompt Bloat Detection

Verbose Instructions

code

❌ Bloat (87 tokens):
"I would like you to please help me write a function that can calculate 
the sum of two numbers. Could you please make sure to include proper 
error handling and also add some comments explaining what the code does? 
Thank you very much for your assistance."

✅ Clean (15 tokens):
"Write a function to sum two numbers. Include error handling and comments."

Savings: 72 tokens (83%)

Over-Explanation

code

❌ Bloat:
"I need this because we're building a calculator app and users need to 
add numbers together. This is a critical feature for our MVP..."

✅ Clean:
"Write a sum function for calculator app"

Rule: Don't explain WHY unless it affects HOW

Repeated Instructions

code

❌ Bloat:
"Use TypeScript. Make it type-safe. Add TypeScript types. Ensure type safety."

✅ Clean:
"Use TypeScript with strict types"

Rule: Say it once, clearly

Context Bloat Detection

Irrelevant Files

code

❌ Bloat:
Including package.json, tsconfig.json, README.md for simple bug fix

✅ Clean:
Include only the file with the bug

Question to ask:
"Will AI need this to complete the task?"
If no → exclude

Stale Information

code

❌ Bloat:
Including old implementation that was replaced

✅ Clean:
Include only current implementation

Check:
- Is this code still used?
- Is this doc still accurate?
- Is this comment still relevant?

Full Files vs Snippets

code

❌ Bloat:
Entire 500-line file when only need 1 function

✅ Clean:
Extract relevant function + imports

Example:
```typescript
// From auth.ts lines 45-60
export function validateToken(token: string): boolean {
  // implementation
}

code


---

## Response Bloat Prevention

### Concise Instructions

Add to prompt: "Be concise. No preambles. Direct answers only."

Example: ❌ "Here's what I did: First, I analyzed your code and then..." ✅ "Fixed by adding null check at line 45"

code


### Output Limits

Specify constraints: "Max 100 words" "Code only, no explanation" "Summary in 3 bullet points"

Example: "Explain in ≤50 words"

code


### Format Specification

❌ Bloat: "Explain the changes you made and why, then show the code, then explain how to test it..."

✅ Clean: "Output format:

•Changed: [one line]
•Code: [code block]
•Test: [command]"

code


---

## Documentation Bloat

### Obvious Statements

❌ Bloat: "This document describes the API documentation for our API" "The database stores data in a database"

✅ Clean: "API Documentation" "Database Schema"

Rule: No meta-documentation

code


### Filler Paragraphs

❌ Bloat: "In this section, we will discuss the various aspects of authentication and authorization, including but not limited to..."

✅ Clean: "## Authentication

•JWT tokens
•OAuth 2.0
•Session management"

Rule: Tables and lists > prose

code


### Excessive Examples

❌ Bloat: 10 examples showing same pattern

✅ Clean: 1-2 examples covering edge cases

Rule: Examples should teach, not repeat

code


---

## Code Comment Bloat

### Obvious Comments
```typescript
❌ Bloat:
// Increment counter by 1
counter++;

// Return the result
return result;

✅ Clean:
counter++;
return result;

Rule: Comment WHY, not WHAT

Dead Code

typescript

❌ Bloat:
// Old implementation (deprecated)
// function oldCalculate() { ... }

// TODO: Remove this later
// const unused = 123;

✅ Clean:
[Delete it]

Rule: Delete, don't comment out

Verbose Variable Names

typescript

❌ Bloat:
const userAuthenticationTokenExpirationTimeInMilliseconds = 3600000;

✅ Clean:
const tokenExpiryMs = 3600000;

Rule: Clear but concise

Configuration Bloat

Unused Configs

json

❌ Bloat:
{
  "feature_a": true,
  "feature_b": false,  // Never used
  "feature_c": null,   // Deprecated
  "debug_mode": false  // Default value
}

✅ Clean:
{
  "feature_a": true
}

Rule: Only non-default, actively used configs

Default Values

code

❌ Bloat:
Explicitly setting every default

✅ Clean:
Only override non-defaults

Example:
// Don't include if it's the default
timeout: 30000  // ← This is default, skip it

Measurement & Tracking

Token Budgets

typescript

// Define budgets
const TOKEN_BUDGETS = {
  systemPrompt: 200,
  userPrompt: 150,
  contextPerFile: 500,
  totalContext: 4000,
  maxResponse: 1000
};

// Track usage
function trackTokens(content: string, type: string) {
  const tokens = countTokens(content);
  const budget = TOKEN_BUDGETS[type];
  
  if (tokens > budget) {
    console.warn(`${type} exceeds budget: ${tokens}/${budget}`);
  }
  
  return tokens;
}

Bloat Metrics

typescript

interface BloatMetrics {
  avgPromptTokens: number;
  avgContextTokens: number;
  avgResponseTokens: number;
  bloatPercentage: number;  // Estimated waste
  costPerRequest: number;
}

// Calculate bloat
function calculateBloat(before: number, after: number): number {
  return ((before - after) / before) * 100;
}

// Example:
// Before optimization: 2000 tokens
// After optimization: 800 tokens
// Bloat removed: 60%