A BC Automations service — brought to you by Breaking Circuits

Is your vibe-coded app safe to share?

You shipped fast with AI. Now find out if you also shipped your API keys, open database, or an unprotected admin route — before a stranger does. Plain-English report + copy-paste fixes for your coding agent.

Run free teaser scan ↓ Get the full scan — $39
No code changesSecrets always redactedReport in minutes, not daysNot a $2,500 audit

Built by Breaking Circuits' security research practice — the team that dissects real malware and supply-chain attacks and publishes the detections in our Intel & detections site. Tested on 8 targets — 6 real apps plus vulnerable & clean fixtures. Well-built apps come back GREEN, planted disasters come back RED. We fixed our false positives in public before selling a single scan.

Free teaser scan

NO SIGN-UP

Paste a public repo or live URL. We run the first checks instantly — full scan covers every category below + fix prompts.

Owner-authorized scans only. We never store full secrets — findings show sk_live_••••4f2a style redactions. Pattern-based scan, not a pentest.

Fetching repo structure & config files…
2 Hunting exposed keys & committed .env files…
3 Checking client-exposed secrets & debug flags…
4 Scoring risk & building your teaser…
AT RISK

2 issues need attention before you share this

Teaser found likely exposures. Full scan checks database rules, auth, and headers too.

HIGH
Possible secret in client bundle
A NEXT_PUBLIC_ variable name suggests a secret — full scan verifies the value.
MED
.gitignore doesn't cover .env
If you create a .env tomorrow, nothing stops it being committed.
HIGH
Supabase / Firebase rule + 4 more findings hidden
Database exposure, missing auth, rate limiting…

Unlock all findings + fix prompts
Every issue explained in plain English with a prompt to paste into Cursor / Lovable / Replit.

Unlock — $39
🛡️

What a clean app looks like: On v0.1.2, 5 of 6 real apps scanned GREEN with 0 findings; the 6th was YELLOW for one preventive .gitignore note — honestly worded, not a scare RED. If yours is clean, we'll tell you — we don't invent risk to sell you.

6 real apps8 targets incl. fixtures
17 findingsCaught in vuln fixture
0 false REDsAfter v0.1.2 fixes
6 categoriesFull v1 checklist
What we check — v1 checklist

Not a vague “security score.” Specific things that actually leak.

Escape scanned 5,600 vibe-coded apps and found 2,000+ vulnerabilities and 400+ exposed secrets. These are the patterns behind almost all of them — and exactly what Vibe Scan hunts for.

🔑

Exposed secrets

OpenAI, Stripe, AWS, GitHub, Supabase keys committed to your repo or shipped to the browser. Values always redacted in your report.

sk-… • sk_live_… • AKIA… • ghp_… • service_role
🗄️

Open data

Supabase / Firebase rules that let anyone read your users table, storage buckets left public, or a service-role key on the client.

RLS off • public bucket • anon vs service_role
👤

Missing protection

Admin routes with no auth, debug mode left on, endpoints anyone can call without logging in.

/admin • DEBUG=true • unprotected API routes
🌐

Client-exposed secrets

The classic vibe-code trap: a “public” env var that isn't public at all. Anything named SECRET / PRIVATE on the client flags hard.

NEXT_PUBLIC_…SECRET_KEY • VITE_…PRIVATE
⚡

Abuse & cost traps

No rate limiting on AI / email / paid API routes — one viral post or bot can drain your credits overnight.

/api/chat • /api/generate • no throttling
🧱

Web hygiene

HTTPS, security headers, committed .env files, and .gitignore gaps that turn a future mistake into a leak.

HSTS • CSP • .env • .gitignore coverage
How it works

Repo in. Fix list out. Your agent does the fixing.

We don't ask you to become a security expert or hire one. We translate findings into the language your builder already speaks: prompts.

STEP 01

Drop your repo or URL

Public GitHub repo, private repo via read-only access, zip, or live URL. Takes 20 seconds. You confirm it's yours to scan.

STEP 02

We scan — separated agents, no chaos

Intake → Scanner → Verifier → Report. Each agent has one job and checks the last one's work. That's why we killed our own false positives before launch.

STEP 03

Get RED / YELLOW / GREEN

Plain-English report: what it is, why it matters, where it is (file + line), and a copy-paste prompt like “Move STRIPE_SECRET_KEY server-side and rotate it…” to give your coding agent.

Sample report — real format

This is what $39 actually buys you.

No 40-page PDF you'll never read. A short, ranked list you can clear in an afternoon — each finding with its fix prompt ready to copy.

my-saas-app
github.com/you/my-saas-app • Full checklist
● RED — FIX BEFORE SHARING

Stripe secret key exposed to the browser

HIGH

In plain English: Anyone who visits your site can view-source and steal this key, then make charges / refunds as you. The value is redacted below — rotate it, don't just move it.

src/lib/pay.ts:4 — NEXT_PUBLIC_STRIPE_SECRET_KEY=sk_live_••••8xK2

Fix prompt for your agent: Move NEXT_PUBLIC_STRIPE_SECRET_KEY to a server-only STRIPE_SECRET_KEY env var. Never expose it with NEXT_PUBLIC_. Create a server API route for all Stripe calls, update the client to call that route, add the new key to .env.local, add .env* to .gitignore, and remind me to rotate the old key in the Stripe dashboard because it was exposed.

Supabase service-role key on the client

HIGH

The service-role key bypasses Row Level Security entirely. On the client, it's effectively “anyone can read/write the whole database.” Your anon key is fine in public — this one isn't.

✓ What we allowlist — and why it matters

NOT FLAGGED

Supabase anon keys and Stripe pk_live_ publishable keys are public by design. Early versions of scanners (including ours, v0.1) flagged them and scared people for no reason. We decode JWTs and check names so we only flag real secrets.

Why builders trust the verdict

We tested on purpose-built vulnerable apps, clean apps, and 6 real production templates — including Vercel's own Next.js + Supabase + Stripe template. When we got it wrong, we published the false positives and fixed them:

  • ✅v0.1 → v0.1.1: .env.example templates, anon/publishable keys, and empty values no longer flag. Vercel template went RED (wrong) → GREEN (correct).
  • ✅v0.1.1 → v0.1.2: Mock passwords in test files suppressed — but a real sk_live_ in a test file still flags HIGH. Surgical, not blind.
  • ✅Honest wording: If there's no .env yet, we say “no protection for future .env files” — we don't pretend a leak already happened.
Honest limits: This is a pattern-based scan, not a pentest. It won't catch obfuscated/split secrets or prove a leaked key is still live — we never use a key to test it, because that would be using your secret. For launch-day confidence on a vibe-coded app, that's the right trade-off.
Scan my app — $39See Watch — $12/mo ↓
Intel & detections — Breaking Circuits research

The intel behind the scanner, published for defenders.

Vibe Scan comes out of Breaking Circuits' threat research. When our watch dissects a live campaign, we turn it into detections — Sigma rules, YARA rules, IOC sets, and hunt notes — and publish them free. The full collection now lives on its own site.

Supply chainOCT 2026

UNC7017 — ephemeral supply-chain tampering (AOMEI)

Attackers rewrote AOMEI's update configs for 5–10 minutes at a time, then reverted them — vendor checks come back clean while endpoints stay compromised. The pack hunts what persists: the scheduled task, the sideloaded DLL, the C2 staging.

4 SIGMA · 1 YARA · FULL IOC SETRead on the intel site ↗
Dev toolchainOCT 2026

GhostAction stage 2 — fake-font VS Code stealer

Stage 2 hides a credential stealer in a fake font file, executed by a VS Code folderOpen task and confirmed across 79 cloned repos. The pack weights behavior over hashes, so it outlasts the rotating samples.

5 SIGMA · 1 YARA · FULL IOC SETRead on the intel site ↗
Explore all 8 packs — intel.bcautomations.online ↗Detections repo on GitHub ↗
Pricing — simple, like the problem

One scan costs less than one leaked key.

A human audit for this starts at $2,500 and takes weeks. Vibe Scan is automated, focused, and priced for indie builders who just need to know if it's safe to share the link.

Most popular

Full Safety Scan

One-time. For “I'm about to share / launch this.”

$39one-time
  • Full v1 checklist — secrets, open data, auth, rate limiting, headers, hygiene
  • RED / YELLOW / GREEN verdict with ranked findings (file + line)
  • Copy-paste fix prompt for every finding — for Cursor, Lovable, Replit, Claude Code
  • Secrets redacted end-to-end — full values never appear in your report
  • Delivered as a clean web report you can re-open and share with a co-founder
Get my full scan — $39 →

Owner-authorized only • No code changes made to your app • Not a pentest

Vibe Scan Watch

For apps you keep shipping. We re-scan so a new key doesn't slip in next week.

$12/ month
  • Weekly automatic re-scan of your repo / URL
  • Instant alert if a new HIGH finding appears
  • Diff view: what changed since last scan
  • All fix prompts included, every time
  • Cancel anytime — keep all past reports

Starts with a full $39 scan included in month one.

Human security audit

$2,500+ • 2–4 weeks • 40-page PDF • Built for funded startups with compliance needs.

Do nothing & share the link

$0 today • One leaked Stripe / OpenAI key can mean $$$$ in abuse, a drained account, and user data exposed.

Vibe Scan — $39

Minutes • Ranked, plain-English • Fix prompts your agent can execute today. The launch-day check.

New — Agent Rules & Safety Kit

Stop the next one before it ships.

The scan finds problems in the app you already built. The kit stops your coding agent from introducing them in the next one: security-hardened rules files for AGENTS.md, Claude Code, and Cursor, plus the pre-launch checklist, the secrets guide, and the fix-prompt library. Plain text and Markdown — delivered to your checkout email as a small ZIP, seconds after checkout.

What's in the kit

  • AGENTS.mdMaster agent rules, security-hardened — secrets, data access, safe building habits, and a self-check your agent runs before it calls anything “done.”
  • CLAUDE.mdThe Claude Code variant of the same rules, including permission hygiene and “never paste a live secret into chat.”
  • .cursor/rules/00-security-baseline.mdcCursor baseline: safe defaults for auth, data access, and dependencies.
  • .cursor/rules/01-secrets.mdcSecrets handling for Cursor: env-only, never commit, never expose to the client bundle.
  • .cursor/rules/02-prelaunch.mdcThe agent's self-check before it calls anything “done.”
  • PRELAUNCH-CHECKLIST.mdThe human checklist mirroring what the scanner checks — plus the things a pattern scan can't see.
  • SECRETS-GUIDE.mdEnv patterns for Next.js / Vite / plain Node, a ready .gitignore block, and the leak playbook: rotate first, then clean up.
  • FIX-PROMPTS.mdThe fix-prompt library: one ready-to-paste prompt per finding type the scanner reports.

Kit purchases join the same 14-day refund policy as scans. Honest limits: the kit reduces the mistakes a scan finds — it is not a guarantee, and it is not a penetration test.

$29launch price · one-time

Drop the files into your project once; every future build by your agent follows them. Standard price is $39 once the launch ends.

Get the kit — $29 → Scan + Kit bundle — $59 →

The bundle is $9 less than buying the scan ($39) and kit ($29) separately. At bundle checkout you'll enter your app/repo URL and confirm it's yours to scan, like a scan. The kit alone needs no intake — the ZIP goes to your checkout email.

Try the free starter first

The complete AGENTS.md from the kit — the secrets rules and the “before you say done” self-check included — free, no checkout. The full kit adds the Claude Code and Cursor variants, the human pre-launch checklist, the secrets guide, and the fix-prompt library.

# Agent Rules — [PROJECT NAME] _Stack: [e.g. Next.js + Supabase] · Deploys to: [e.g. Vercel] · Repo: [URL]_ You are building a real app that real people will use. Most AI-built apps don't get hacked through exotic exploits — they leak a key, expose a database, or ship with debug mode on. These rules exist to make those specific mistakes hard for you to make. They override convenience. When a rule conflicts with a request, follow the rule and say which rule stopped you. ## Secrets — non-negotiable 1. **Never write a secret value into source code.** No API keys, tokens, passwords, or private keys in any file that gets committed — not in code, not in tests, not in comments, not "temporarily." Read secrets from environment variables. 2. **Never commit `.env` files.** `.env.example` (names only, no values) is the only env file that may be committed. Before your first commit, confirm `.env*` is covered by `.gitignore` (see SECRETS-GUIDE.md in this kit). 3. **Client-exposed variables are public.** Anything named `NEXT_PUBLIC_*`, `VITE_*`, or `REACT_APP_*` is shipped to every visitor's browser. Never put a key, secret, token, or service-role credential behind one of those prefixes. If a value must stay secret, it lives server-side only. 4. **If you see a live-looking secret already in the code or history, stop.** Tell the human, in plain words, that it must be treated as leaked: rotated at the provider first, then removed. Never "fix" a leak by just deleting the line. 5. **Never print secrets.** No logging of full keys, tokens, passwords, or authorization headers — including in debug output and error messages. ## Data & access 6. **Data is private by default.** Every table, bucket, and endpoint starts closed. Open exactly what the feature needs, for exactly who needs it. (On Supabase: row-level security ON for every table, with explicit policies — an RLS-off table is a public table.) 7. **Never use a service-role / admin key in client code.** Admin keys bypass every protection. They belong in server-only code paths, if anywhere. 8. **Check authorization on the server, per request.** "The button is hidden in the UI" is not access control. Any endpoint that reads or changes another user's data must verify the caller owns it. ## Building 9. **No debug in production.** `DEBUG=true`, framework debug flags, and verbose error pages are development-only. Production errors shown to users are generic; details go to server logs. 10. **Pin and eyeball new dependencies.** Prefer well-known packages. If you add a dependency, say its name and why in your summary. Never install a package whose name you are not sure exists — hallucinated package names are a real supply-chain attack. 11. **Validate input at the boundary.** Anything arriving from a user, a webhook, or a URL parameter is untrusted until checked. ## Before you say "done" Run this self-check and report the result honestly, item by item: - [ ] No secret values in any committed file (search for `sk_`, `AKIA`, `ghp_`, `service_role`, `password =` in what you touched) - [ ] No `.env*` file staged or committed - [ ] No secret behind a client-exposed env prefix - [ ] New data stores are private by default, with access rules written down - [ ] Debug flags off for production config - [ ] `PRELAUNCH-CHECKLIST.md` (this kit) walked for anything user-facing If an item fails, it is not done. Fix it or flag it — never silently skip it. ## Style of work - Small, reversible changes. Say what you changed and what you did not test. - When unsure whether something is safe to expose, treat it as not safe and ask.
Security Review — $399

A human pass over one app — repo plus live URL — delivered personally by BC, founder of Breaking Circuits, with a written findings note. Open to anyone who needs one, scheduled with the buyer after checkout — no slot limit.

Book a security review — $399 →
Questions

Before you paste that link in public…

No — and we say so everywhere. It's a focused, pattern-based safety scan for the mistakes vibe-coded apps actually make: exposed secrets, open data, missing auth, and hygiene. It doesn't try to exploit your app or validate live keys. For a public launch check, that's exactly the scope you need first.
Never in full. We redact to first prefix + last 4 characters (e.g. sk_live_••••8xK2) so you can identify which key it is without creating a second leak inside the report itself. Our redaction sweep is part of every release test.
Use your live URL for the teaser and full URL checks, and export / connect your repo for the deepest scan. If your platform gives you a GitHub sync or a zip export, that unlocks file-level findings (committed .env, client secrets) with exact line numbers.
Then you paid $39 for the best news possible — and a report you can show a co-founder or early user. Well-built apps do come back GREEN in our tests; we don't manufacture findings. Watch ($12/mo) exists because GREEN today can become RED after next week's feature.
We give your coding agent the exact fix prompt for each finding — most builders clear a report in one session by pasting prompts into Cursor / Lovable / Replit. We deliberately don't change your code directly: your agent knows your app, we know the vulnerability.
No. Owner-authorized scans only — you confirm at checkout that it's your app or you have permission. That's a hard guardrail, not fine print.
Founding Sponsors

Sponsor slots — open for launch.

Vibe Scan reaches vibe coders at the moment they're fixing their app's security. Three founding sponsor slots are open for launch: this page, the Intel & detections site, the free-scan results, and every paid report. Sponsors never influence scan verdicts, placements are always labeled, and sponsors never receive customer scan data.