ai-code-blindspots

ai-code-blindspots

AI writes the code the prompt literally asked for and stops. The controls a senior adds from unstated context — authorization, tenant scope, validation, transactions, encryption, rate limiting, output encoding, error handling, edge cases, package existence — are invisible to a single-file prompt, so they are the first thing dropped. They are also the classes pattern-linters miss. This skill is the pre-ship checklist: for the surface you just wrote, assert the matching control is present, run the backstop grep, and route to the deep skill when it needs more than a check.

This is a routing + verification layer — it does not re-teach what the deep skills own. It is the "did I supply the invisible controls?" gate that senior-engineering-discipline points at.

When to use

• You have written (or are about to finish) an endpoint, query, migration, UI render, file/network op, infra resource, dependency change, or test — before you call it done.
• Reviewing an AI-authored diff and asking "what did it silently omit?".
• The senior-engineering-discipline rule fired and routed you here.

Do NOT use when: the change is prose/docs/config-only, or a one-line rename — there is no code surface to check.

The Iron Law

FOR EVERY SURFACE YOU TOUCHED, NAME THE INVISIBLE CONTROL AND CONFIRM IT IS PRESENT.
"NOT MENTIONED IN THE PROMPT" IS EXACTLY WHY IT IS MISSING — CHECK IT ANYWAY.
A CONTROL DEFINED BUT NOT WIRED IS ABSENT. A grep IS CHEAPER THAN A BREACH.

Procedure

1. Inspect the change and list the surfaces it touched (endpoint, query, migration, render, file/fetch, infra, dependency, test) — analyze what you actually wrote before checking it.
2. For each surface, take its row below: assert every listed invisible control is present (with file:line), and run the matching backstop grep.
3. For anything a grep flags or a check can't confirm, open the routed deep skill.
4. Emit the per-surface confirmation (Output format); surface any unresolved gap to the user — never silently omit.

Surface → invisible controls → backstop

Run the row(s) for what you touched. The grep is a fast authoring-time backstop (not a substitute for reading the code); zero results is the pass, a hit is a prompt to look.

Backstop greps (authoring-time, cross-stack)

# Frontend insecure render / client secrets (React + Vue + vanilla)
rg -n 'dangerouslySetInnerHTML|v-html|\.innerHTML\s*=|\beval\(|new Function\('
rg -n 'NEXT_PUBLIC_.*(SECRET|KEY|TOKEN)|VITE_.*(SECRET|KEY)|localStorage\.setItem\([^)]*[Tt]oken'
# String-built SQL (concatenation / interpolation into a query)
rg -n 'query\(.*(\+|\$\{|`).*\)|(SELECT|INSERT|UPDATE|DELETE).*(\+|\$\{)'
# Hardcoded secrets / weak hashing
rg -n 'AKIA[0-9A-Z]{16}|sk_live_|AIza[0-9A-Za-z_\-]{35}|password\s*=\s*["\x27]|md5\(|sha1\(' .
# Infra: wildcard IAM / open ingress / disabled TLS
rg -n '"Action"\s*:\s*"\*"|"Resource"\s*:\s*"\*"|0\.0\.0\.0/0|InsecureSkipVerify|verify=false|curl.*\| *bash' .
# Raw secret in an agent/MCP/CI config (should be an env-var reference, not a literal)
rg -n '(sk_live_|sk-[A-Za-z0-9]{20}|AKIA[0-9A-Z]{16}|ghp_[0-9A-Za-z]{36}|AIza[0-9A-Za-z_\-]{35})' --glob '*.mcp.json' --glob '.mcp.json' --glob '*.env' --glob '**/agent*config*' --glob '.github/workflows/*'
# Swallowed error (empty catch) / unbounded external call (no timeout arg)
rg -n 'catch\s*\([^)]*\)\s*\{\s*\}|except[^:]*:\s*pass' .

Stack-specific patterns (the greps name several ecosystems side by side on purpose): keep the ones for the stack in front of you; a hit means read that line, not auto-fix.

Output format

1. A one-line per-surface confirmation for the change, e.g. endpoint: authz ✓ tenant-scope ✓ rate-limit wired ✓ validation ✓, naming the file:line where each control lives (or n/a — <reason>).
2. The backstop grep(s) run for the touched surface(s), with their result (zero hits, or the hit + how it was resolved).
3. For any control that is genuinely out of scope, an explicit note saying so — never a silent omission.

Gotcha

• Defined-but-not-wired is the signature AI failure: the rate-limit middleware or CSRF guard is written but never attached to the route. The check is "is it wired on THIS path?", not "does the code exist somewhere?".
• Semantically-valid-but-ignored: an IaC attribute that the provider silently ignores (a made-up encrypted = true on a resource that doesn't support it) reads as a present control but does nothing — a scanner catches it, a code read does not.
• A green grep is necessary, not sufficient — it proves the obvious anti-pattern is absent, not that the control is correct. Read the seam for anything security-sensitive.
• This checklist routes; it does not replace the deep skill. For an auth/billing/tenant/secret path, security-sensitive-stop still requires a threat pass before editing.
• Run it per surface, not once at the end. In a multi-file / agentic change the omission compounds — each new endpoint, query, or fetch is its own blind spot. Re-run the matching row when each surface lands, not as a single sweep after the whole feature is "done" (by then the missing control is buried under later diffs).

Do NOT

• Do NOT treat "the prompt didn't ask for it" as a reason to omit a control — that is the exact blind spot.
• Do NOT mark a change done on a green happy-path test alone.
• Do NOT auto-rewrite a grep hit without reading it — some are intentional and belong in an allow-list with a reason.
• Do NOT duplicate the deep skills here — route to them.

Auto-trigger keywords

• invisible controls
• ai code blindspots
• pre-ship checklist
• what did the AI omit
• cross-cutting controls

See also

• senior-engineering-discipline — the anchor rule that routes here.
• frontend-render-security, supply-chain-intake, testing-anti-patterns.
• authz-review, threat-modeling, defense-in-depth, source-discovery, secrets-management.