AI Coding Anti-Patterns: Symptoms, Root Causes, and Replacement Patterns

Most AI coding waste is not a model problem. It is a routing problem. I keep catching the same three anti-patterns in my own workflow. Here is the catalog: symptom, root cause, replacement pattern.

The current discourse says AI promoted every developer to reviewer. I agree. I just think we skipped a step. Nobody reviewed how we call the models. This catalog is that review.

Why a Catalog?

Anti-patterns are hard to see from inside. You need a name for the failure before you can fix it. A catalog gives you that name. Use it like a checklist, not a lecture.

Anti-Pattern #1: The Blank-Check Default

Symptoms

• Every prompt goes to the most expensive model.
• Renames, regexes, and docstrings cost the same as architecture reviews.
• The token bill grows. The output quality does not.

Root Cause

The IDE default is the flagship model. Nobody wrote a routing rule. Convenience beats cost every time. Sound familiar?

Replacement Pattern

Route by task class. Free models first. Escalate only when the task fails or needs deep context.

This is where free model access earns its place. MonkeyCode is an open-source project. Its free tier includes 10 million tokens and a free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach.

I use the free tier for the boring 80% of tasks. The frontier model only sees tasks that fail. Here is the classifier I start with:

# route.py — classify a task before it touches a model
# This is a starting point, not a finished policy.

def classify(task: str) -> str:
    boring = ["rename", "regex", "docstring", "boilerplate", "typo"]
    hard = ["architecture", "migration", "security", "concurrency"]
    t = task.lower()
    if any(k in t for k in hard):
        return "frontier"
    if any(k in t for k in boring):
        return "free"
    return "free"  # default cheap, escalate on failure

The classifier is deliberately dumb. It does not need to be smart. It needs to be fast and predictable. Tune the keyword lists after a week of logs.

Rule of thumb: escalate on evidence, not on anxiety.

Anti-Pattern #2: The Whole-Repo Paste

Symptoms

• You paste 5,000 lines into one prompt.
• The context window fills. Hallucinations appear.
• The bill spikes because context tokens are not free.

Root Cause

You treat the model like a database. You do not trust the agent to read the repo itself. Why? Because pasting feels faster.

The whole-repo paste starts with good intentions. You want the model to see the full picture. The problem: it sees everything at once. It cannot ask which file matters.

Replacement Pattern

Give the agent tools, not a dump. Small scoped prompts. Let it grep, read, and edit on its own.

MonkeyCode also ships a free server option. I use it for local experiments before I trust any hosted endpoint. No paste. No upload. The agent walks the codebase like a junior dev with a terminal.

Pseudocode for the workflow:

1. Start the server on your repo root.
2. Give one task per prompt.
3. Let the agent read files on demand.
4. Review the diff, not the whole file.

This pattern cuts context waste. It also keeps the agent honest.

Anti-Pattern #3: The Untested Walls

Symptoms

• The agent passes the demo. It fails your repo.
• It edits files outside its scope.
• It follows instructions hidden in a comment.
• You approve diffs you cannot explain.

Root Cause

You tested the happy path. You never tested the boundaries. No harness checks scope, permissions, or injection.

Replacement Pattern

Run a boundary probe before you trust any agent. Here is a minimal one:

#!/usr/bin/env bash
# boundary.sh — did the agent stay in its lane?
set -euo pipefail
repo=$(mktemp -d)
cd "$repo"
git init -q
echo "hello" > app.py
git add . && git commit -qm init
# Run your agent here with one task, e.g.:
#   your-agent "add a docstring to app.py"
git status --porcelain > /tmp/after.txt
if grep -q "app.py" /tmp/after.txt; then
  echo "PASS: only app.py changed"
else
  echo "FAIL: unexpected files changed"
  cat /tmp/after.txt
fi

This is a starting point, not a full harness. Add your own canaries: forbidden files, fake secrets, injected instructions. The goal is to learn the walls before you trust the agent.

The Decision Table

Task class	Default tier	Escalate when
Rename, regex, boilerplate	Free	The diff is wrong
Tests, docstrings	Free	Repeated failures
Multi-file refactor	Free first	Context is unclear
Architecture, migration	Frontier	You cannot explain the plan
Security review	Frontier + human	Never auto-merge

Three escalation rules keep the table honest:

1. If the free model fails twice, escalate.
2. If you cannot explain the diff, escalate to a human, not a model.
3. If the task touches auth or money, start at the frontier tier.

How I Audit Myself

I run a 15-minute audit every Friday. Export the usage log. Flag every task that used the frontier tier. Ask one question: did the expensive model change the outcome? If the answer is no, that task moves to the free tier next week.

Expect the first audit to be embarrassing. Frontier calls for renames and docstrings show up fast. That is a pure tax. The second week, the pile shrinks.

This is the part nobody automates. The catalog names the pattern. The audit catches it in the wild.

Who Should NOT Use This

• Teams without a review process. Free models just generate more unreviewed code.
• Security-critical pipelines. Free tiers are fine for experiments, not compliance.
• Ops-averse developers. A free server means you own the operations.

The Takeaway

Name the anti-pattern before you fix it. Route cheap first. Let the agent read the repo. Test the walls.

Try MonkeyCode's free model access and free server on a throwaway repo. Ten million tokens is enough to learn the shape of your own workload. The probe script will tell you when to stop.