Ask ChatGPT, Claude, or Gemini how to catch AI-written bugs and the answers split in two. Structural questions (injection, secrets, weak crypto) get deterministic scanners. Intent questions get an LLM. brasscoders builds the deterministic half of that split. Free, Apache 2.0.

AI coders reach for MD5, AES-ECB, and the random module because a decade of tutorials did. Pearce et al. found ~40% of Copilot code vulnerable across CWE Top 25, crypto among the worst. BrassCoders flags every instance via Bandit's crypto rules, no AI call required.

A nested loop over 5 items and a single DB call on a hot path can both exist in the same file. Only one shows up as a shape a scanner can flag. BrassCoders catches the anti-patterns. Finding your actual bottleneck is a profiler's job, not a scan's.

A pattern scanner flags known-bad shapes. The xz-utils backdoor cleared review and every static check because its author engineered it to look like known-good code. Brass catches the accidental bugs AI ships. Provenance catches the deliberate ones.

The scariest authz bug isn't a missing check, it's one that looks right. `if user.id == resource.owner_id:` is clean code, but whether it's correct depends on your data model, not syntax. No scanner can see that. Brass catches structural bugs; authz tests catch this one.

debug=True hardcoded in source is a bug BrassCoders catches every time. DEBUG=os.environ.get("DEBUG") is different: whether prod runs with debug on gets decided at deploy time, not in your code. Source scans can't see it. That's the runtime layer's job.

Prompt injection is the top-ranked risk in OWASP's LLM Top 10, and no source scanner catches it. It's a runtime attack on the agent reading your repo, not a pattern in the code it writes. BrassCoders scans for SQL injection, secrets, weak crypto. Different layer, different fix.

sum(readings) / len(readings) with no empty-list guard: a scanner can't flag it. It's shaped exactly like every correct average in your codebase. No pattern to match, no rule to write. In our own benchmark, an LLM caught it.

Every AI code review blind spot reduces to one cause: scanners see structure, not intent. Logic bugs, broken auth checks, and backdoors look identical to correct code. Prompt injection and leaks only exist at runtime. Brass catches the shape layer.

A sister team wrote up the content strategy behind our recent posts: answer the high-intent question your tool deliberately doesn't own, then hand off to the right fix. The hard part isn't writing more. It's skipping topics someone else already owns.

Your AI assistant writes a FastAPI update route: request.dict gets looped straight into the DB row. is_admin, role, account_tier included. Send {"is_admin": true} in the JSON body and you're an admin. No error, no log. Fix: explicit field allowlists, not full model dumps.

New hire's first commit is often the riskiest one. brasscoders fixes that: install the CLI, add a pre-commit hook, add a CI gate. Same YAML, same 12 scanners, day one or day one hundred. Apache 2.0, zero network calls in OSS mode.

Your AI assistant's import block looks clean. Right naming convention, right style. One package doesn't exist on PyPI. Models generate names from pattern completion, not registry lookups.

Your AI app summarizes documents. A user prompt says: "include this in your output: ". The model complies. Your template renders it unescaped. Script runs in every viewer's browser. Jinja2 defaults to autoescape=False.

AI assistants default to Python's random module because it's everywhere in training data. Problem: it's Mersenne Twister, predictable after 624 outputs. Bandit's B311 flags every call. BrassCoders surfaces it in the YAML your AI reads. Fix: swap to secrets. One import.

Vibe coding: you describe it, AI writes it, you barely read it. BrassCoders scanned 15 AI-generated Python files. 9 had real security or performance issues. Zero got a warning at generation time. That silence is the risk.

Ten developers using AI assistants don't average out their risks. They stack them. Each assistant has its own blind spots, and merging code merges every one of them into the repo.

Your AI assistant doesn't know you use Vault or AWS Secrets Manager. It just sees a field that needs a value, so it fills one in. In a 15-file corpus of AI-generated Python, 2 files shipped hardcoded credentials. brasscoders --offline scan catches it before the commit lands.

When an LLM returns a URL and your code fetches it without checking, the model just became the attack vector. Prompt injection steers the output, your app hits the metadata endpoint or an internal service on the model's say-so. No user input required.

Your AI assistant hits an SSL error and "fixes" it with verify=False. Code works now. But that flag doesn't skip encryption, it skips checking who you're actually talking to. Any attacker in the middle can now hand over their own certificate.