20 AI Slop Code Examples (With Fixes): Real Slop Code, Named

Twenty common AI slop patterns in code, each with a cleaner version and what it costs in review. Naming the pattern gives a contributor something to fix, which “this looks like AI slop” does not. The snippets are TypeScript and Python; the patterns appear in any language.

New to the term? Start with what AI slop is. For generated images and filler pages, see AI slop website examples.

Errors hidden behind fallbacks

async function loadInvoices(userId: string): Promise<Invoice[]> {
try {
  return await api.listInvoices(userId);
} catch (error) {
  console.error(error);
  return [];
}
}

async function loadInvoices(userId: string): Promise<Invoice[]> {
try {
  return await api.listInvoices(userId);
} catch (error) {
  throw new Error("loadInvoices failed for user " + userId, { cause: error });
}
}

def read_config(path):
  try:
      with open(path) as f:
          return json.load(f)
  except Exception as e:
      raise e

def read_config(path: Path) -> dict:
  with path.open() as f:
      return json.load(f)

async function getPrices(): Promise<Price[]> {
try {
  return await fetchPrices();
} catch {
  return cache.get("prices") ?? DEFAULT_PRICES;
}
}

async function getPrices(): Promise<{ prices: Price[]; stale: boolean }> {
try {
  return { prices: await fetchPrices(), stale: false };
} catch (error) {
  const cached = cache.get("prices");
  if (!(error instanceof NetworkError) || !cached) throw error;
  return { prices: cached, stale: true };
}
}

def send_webhook(payload):
  while True:
      try:
          return requests.post(WEBHOOK_URL, json=payload)
      except Exception:
          time.sleep(1)

def send_webhook(payload: dict, attempts: int = 4) -> requests.Response:
  for attempt in range(attempts):
      try:
          return requests.post(WEBHOOK_URL, json=payload, timeout=5)
      except (requests.ConnectionError, requests.Timeout):
          if attempt == attempts - 1:
              raise
          time.sleep(2 ** attempt + random.random())

Types and validation

const res = await fetch("/api/user");
const user = (await res.json()) as User;
sendEmail(user.email.toLowerCase());

const UserSchema = z.object({ id: z.string(), email: z.string().email() });

const res = await fetch("/api/user");
const user = UserSchema.parse(await res.json());
sendEmail(user.email.toLowerCase());

def create_order(req):
  if not req.get("email") or "@" not in req["email"]:
      raise ValueError("invalid email")
  return service.create(req)

def create(self, req):
  if not req.get("email") or "@" not in req["email"]:
      raise ValueError("invalid email")
  return self.repo.insert(req)

@dataclass(frozen=True)
class OrderRequest:
  email: str

  def __post_init__(self):
      if "@" not in self.email:
          raise ValueError("invalid email")

def create_order(raw: dict) -> Order:
  return service.create(OrderRequest(email=raw.get("email", "")))

type Status = "active" | "paused";

function label(status: Status): string {
if (!status) return "Unknown";
if (status === "active") return "Active";
if (status === "paused") return "Paused";
return "Unknown";
}

const STATUS_LABELS: Record<Status, string> = {
active: "Active",
paused: "Paused",
};

const label = (status: Status) => STATUS_LABELS[status];

function exportReport(r: Report, pdf: boolean, email: boolean, draft: boolean) {
// ...
}

exportReport(report, true, false, true);

type ExportOptions = {
format: "pdf" | "csv";
delivery: "download" | "email";
draft: boolean;
};

exportReport(report, { format: "pdf", delivery: "download", draft: true });

Code that is hard to follow

# Initialize the counter
count = 0
# Loop through the users
for user in users:
  # Check if the user is active
  if user.active:
      # Increment the counter
      count += 1

active_users = sum(1 for user in users if user.active)

const data = await getData(id);
const result = data.filter((item) => item.flag);
return handler(result);

const invoices = await fetchInvoices(customerId);
const overdue = invoices.filter((invoice) => invoice.isOverdue);
return sendReminders(overdue);

import { formatDate } from "./dates";

export function formatDateHelper(date: Date, locale: string): string {
return formatDate(date, locale);
}

import { formatDate } from "./dates";

formatDate(order.createdAt, user.locale);

@app.post("/signup")
def signup(request):
  body = json.loads(request.body)
  if not body.get("email"):
      return error(400, "email required")
  if db.users.find(email=body["email"]):
      return error(409, "exists")
  user = db.users.insert(email=body["email"], plan=body.get("plan", "free"))
  stripe.Customer.create(email=user.email)
  mailer.send(user.email, "Welcome!")
  return {"id": user.id, "email": user.email, "plan": user.plan}

@app.post("/signup")
def signup(request):
  command = SignupCommand.parse(request.body)
  user = register_user(command, users=user_repo, billing=billing)
  return UserResponse.from_user(user).to_json()

// src/components/InvoiceRow.tsx
function formatMoney(cents: number): string {
return "$" + (cents / 100).toFixed(2);
}

// src/components/InvoiceRow.tsx
import { formatCurrency } from "@/lib/money";

formatCurrency(invoice.totalCents, invoice.currency);

import { parseLegacyId } from "./legacy";

function normalizeIdV2(raw: string) {
return raw.trim().toLowerCase();
}

export function lookup(id: string) {
console.log("lookup called", id);
return store.get(id.trim());
}

export function lookup(id: string) {
return store.get(id.trim());
}

Tests that stop testing

it.skip("rejects expired coupons", () => {
expect(() => applyCoupon(cart, expiredCoupon)).toThrow(CouponExpiredError);
});

it("rejects expired coupons", () => {
expect(() => applyCoupon(cart, expiredCoupon)).toThrow(CouponExpiredError);
});

// src/coupons.ts: fix the implementation, not the test
if (coupon.expiresAt <= now) throw new CouponExpiredError(coupon.code);

def test_order_total():
  items = [Item(price=10, qty=2), Item(price=5, qty=1)]
  expected = sum(i.price * i.qty for i in items) * (1 + TAX_RATE)
  assert order_total(items) == expected

def test_order_total_includes_tax():
  items = [Item(price=10, qty=2), Item(price=5, qty=1)]
  assert order_total(items, tax_rate=0.2) == pytest.approx(30.0)

it("renders checkout", () => {
const { container } = render(<Checkout cart={cart} />);
expect(container).toMatchSnapshot();
});

it("shows the discounted total", () => {
render(<Checkout cart={cartWithCoupon} />);
expect(screen.getByRole("status")).toHaveTextContent("Total: $18.00");
});

Dependencies, configuration and scope

// src/db/pool.ts, written by the agent
import { createPool } from "pg-promise-x";

export const pool = createPool(process.env.DATABASE_URL);

// Check before adding: does it exist, who publishes it, is it needed?
// npm view <name> repository.url maintainers time.created license
import { Pool } from "pg"; // already in package.json

export const pool = new Pool({ connectionString: process.env.DATABASE_URL });

export const cacheConfig = {
ttl: Number(process.env.CACHE_TTL ?? 300),
strategy: process.env.CACHE_STRATEGY ?? "lru",
enableSharding: process.env.ENABLE_SHARDING === "true",
maxShards: Number(process.env.MAX_SHARDS ?? 16),
retryMode: process.env.CACHE_RETRY_MODE ?? "exponential",
};

export const CACHE_TTL_SECONDS = 300;

-export function dueDate(invoice: Invoice) {
-  return addDays(invoice.issuedAt, invoice.terms);
-}
+export const computeInvoiceDueDate = (inv: InvoiceRecord): Date => {
+  const { issuedAt, terms } = inv;
+  return addBusinessDays(issuedAt, terms ?? DEFAULT_TERMS);
+};

 export function dueDate(invoice: Invoice) {
-  return addDays(invoice.issuedAt, invoice.terms);
+  return addDays(invoice.issuedAt, invoice.terms ?? DEFAULT_TERMS);
}

Who should check each example

Patterns with a fixed shape or a metric can be automated. Contextual ones suit an AI reviewer, as questions to verify. Intent, risk and scope stay with a person.

• Automate: swallowed exceptions (1), unsafe casts (5), narrative comments (9), generic names (10), thin wrappers (11), oversized functions (12), dead imports and debug leftovers (14).
• Ask an AI reviewer, then verify: universal fallbacks (3), unbounded retries (4), duplicated validation (6), impossible-state checks (7), duplicate implementations (13), tautological tests (16).
• Keep with a human owner: skipped tests (15), snapshot updates (17), new dependencies (18), new configuration (19), and scope (20).

aislop detects many of the fixed-shape ones, including swallowed errors, unsafe type assertions, narrative comments, dead code, empty functions, debug leftovers, unresolved stubs, generic naming and complexity thresholds, with the same rule ID whoever wrote the code.

Run it in your repository to see which of these 20 are already there; it needs no install and no account. Each pattern is documented in the pattern library, and for a public GitHub repository you can try aislop in the browser.

Sources and further reading

• TRIM: Reducing AI-Generated CodeSlop via Agent Trajectory Minimization
• GitHub: Review AI-generated code
• OWASP: Secure Coding with AI Cheat Sheet
• AI slop detection: complete guide