# Prbl

> Prbl is a security scanner built specifically for AI-generated code, the 10-60% of a typical codebase written by tools like Cursor, GitHub Copilot, Claude Code, and Replit that often ships without a careful human review.

Prbl is for developers and teams who use AI coding tools ("vibe coding") and want to catch the vulnerability classes those tools produce systematically: hardcoded credentials, SQL/NoSQL injection, missing authentication on generated routes, fallback secrets in environment variables, Broken Object Level Authorization (BOLA), and timing-unsafe comparisons.

It runs alongside general-purpose scanners like Semgrep, Snyk, and CodeQL rather than replacing them. Prbl asks one specific question those tools don't: did an AI tool generate this code, and does it have the gaps AI tools leave behind?

## Product
- [Homepage](https://getprbl.com/): Product overview, how it works, pricing, FAQ
- [Scan a repo free](https://getprbl.com/scan): Free scan, no account needed
- [Pricing](https://getprbl.com/pricing.md): Machine-readable pricing for AI agents
- [Trust & Security](https://getprbl.com/trust): What happens to your code when Prbl scans it, independently verified

## Docs & Guides
- [Blog index](https://getprbl.com/blog): All guides on AI code security
- [We scanned 2,736 AI-built apps to see how many leave the door unlocked](https://getprbl.com/blog/ai-built-apps-unprotected-dashboard-study): Original research, our largest scan to date. 124 of 2,736 apps (4.5%, about 1 in 22) served private surface to an anonymous visitor with no login: 89 had an unprotected dashboard or account page, 25 had an API returning data with no token, 10 had a database readable with the public key. All probes read-only and unauthenticated, exactly what any visitor's browser can already do.
- [We checked real AI-built apps to see how many leave their database open](https://getprbl.com/blog/ai-built-apps-open-database-study): Original research; used each app's own public Supabase anon key, exactly as any visitor could, to ask for one row per table. On 4 of the 15 Supabase-backed apps checked, the database answered: more than one in four had at least one table anyone could read with no login, meaning Row Level Security was not protecting it.
- [Is Lovable safe? An honest breakdown](https://getprbl.com/blog/is-lovable-safe): The real CVE (CVE-2025-48757, 170+ apps across 303 endpoints leaking data via a missing Row Level Security policy), the three gaps that make a Lovable app unsafe, and how to check your own app.
- [Is Bolt.new safe? An honest breakdown](https://getprbl.com/blog/is-bolt-new-safe): Exposed keys in the frontend bundle, missing Row Level Security, and broken access control, the three gaps specific to Bolt.new's fast-generated output.
- [How to stop Cursor, Copilot, and Claude Code from hardcoding your secrets](https://getprbl.com/blog/prevent-ai-hardcoding-secrets): Practical prevention guide; a four-layer setup so an inline secret cannot reach the repo: gitignored .env with a committed .env.example, a secrets rule in the tool's instruction file (CLAUDE.md / copilot-instructions.md / .cursor/rules / AGENTS.md), a gitleaks pre-commit hook, and GitHub push protection. The instruction file is the weakest layer; the pre-commit hook is the one that holds.
- [Your AI assistant hardcoded an API key and you pushed it. Do these 5 things now.](https://getprbl.com/blog/committed-api-key-github-fix): Practical field guide for developers using Cursor, Copilot, Claude Code, or Codex. The exact remediation order for a leaked secret: rotate first (the key is already compromised), check provider logs, purge git history, move to env vars, install a pre-commit secret scanner. Rotation over deletion is the key insight.
- [We ran Prbl and Semgrep on the same 17 repos. One reported 24 high-severity issues. One was real.](https://getprbl.com/blog/false-positive-rate-vs-semgrep): Head-to-head false-positive study; on 17 AI-built web apps, Semgrep's default ruleset reported 24 high-severity findings (1 real, 23 false positives, ~4% precision) vs Prbl's 8 (all real, 100% precision). Both caught the one real injection; Prbl also caught hardcoded admin passwords and disabled TLS that Semgrep's default ruleset missed. Precision, not recall.
- [We scanned code from every major AI model to find the safest one. There isn't one.](https://getprbl.com/blog/safest-ai-coding-model): Capstone study; 544 web apps across Cursor (12.5%), OpenAI Codex (9.8%), Claude Fable 5 (13.8%), Opus 4.8 (16.2%), Opus 4.5 (17.7%). No statistically significant difference between any two tools. The flaws are human paste-ins (hardcoded credentials, disabled TLS, weak randomness), so model choice is not a security decision.
- [Watch our scanner tear a vibe-coded app apart, finding by finding](https://getprbl.com/blog/vibe-coded-app-security-teardown): Guided teardown of a typical AI-built app; five findings walked through one at a time (hardcoded Supabase key, disabled TLS, weak randomness, timing-unsafe comparison, secrets in logs) with the fix for each, and a one-click live scan you can run yourself with no account.
- [We scanned 120 web apps built with Cursor. Is Cursor-generated code secure?](https://getprbl.com/blog/cursor-code-security-scan): Original research; 120 Cursor-built web apps scanned, 12.5% had a high-severity finding, dominated by hardcoded credentials and disabled TLS. Statistically identical to Codex (9.8%) and all three Claude models, because the flaws are human paste-ins, not tool reasoning failures.
- [Meta just entered the AI coding race. Its benchmarks don't answer the security question.](https://getprbl.com/blog/meta-muse-spark-ai-coding-security): Perspective on Meta's Muse Spark 1.1 launch; coding-benchmark wins measure whether code works, not whether it's secure. Cross-vendor data predicts it lands in the same flaw band as Claude and Codex. Commits to scanning it once a corpus exists.
- [We scanned 83 apps built with OpenAI's Codex. They weren't the apps we expected.](https://getprbl.com/blog/what-codex-builds-security): Codex-focused; its corpus skews to ML/AI tooling and model servers, not consumer web apps, shifting the security profile toward disabled TLS and weak randomness. Same root cause: human paste-ins.
- [We tested OpenAI's Codex and three Claude models for security. None was safer.](https://getprbl.com/blog/codex-vs-claude-security): Cross-vendor study; 434 web apps (Codex + 3 Claude models). Codex 9.6%, Fable 5 12.0%, Opus 4.8 15.5%, Opus 4.5 16.3% high-severity, no pairwise difference significant.
- [A Semgrep alternative built for AI-generated code](https://getprbl.com/blog/semgrep-alternative-ai-generated-code): Comparison; Semgrep is a general-purpose engine that needs tuning, Prbl ships tuned for AI-code vulnerability classes. Includes a precision test where Semgrep's default ruleset flagged 54 findings (53 false positives) on create-t3-app and Prbl flagged 0.
- [Snyk vs Prbl: which one catches AI-generated code bugs?](https://getprbl.com/blog/snyk-vs-prbl): Comparison; Snyk scans dependencies/containers/IaC (supply chain), Prbl scans the first-party AI-generated code (hardcoded secrets, injection, missing auth). Different halves of the app; most teams run both.
- [We scanned nearly 2,000 AI-built apps. The same secret kept leaking.](https://getprbl.com/blog/hardcoded-secrets-ai-code): Cross-study synthesis of 1,968 apps (HN, Lovable/Bolt, Claude Code); hardcoded secrets were the top high-severity finding in every corpus (20.4% of app-builder apps, 9.3% of Claude web apps, top-3 on HN)
- [We scanned 119 web apps built with Claude Fable 5. The model got smarter. The secrets still leaked.](https://getprbl.com/blog/fable5-code-security-scan): Original research; 119 web apps built with Claude Fable 5 scanned, 12.6% had a high-severity finding, dominated by hardcoded secrets and TLS. Opus 4.8 statistically the same (15.2%). Uses taint-aware analysis.
- [The 4 security holes Claude Fable 5 leaves in your app (and the 2-minute fix for each)](https://getprbl.com/blog/claude-fable-5-security-flaws): Practical field guide to the four most common flaws in Claude Fable 5 web apps (hardcoded keys, weak randomness, disabled TLS, hardcoded session secrets), each with before/after code and a fix.
- [We scanned web apps from three Claude model generations. Newer did not mean safer.](https://getprbl.com/blog/claude-models-security-comparison): Original research; Fable 5 (12.7%), Opus 4.8 (15.3%), Opus 4.5 (16.7%) high-severity rates are statistically indistinguishable (p=0.41). Model capability gains do not reduce credential-hygiene flaws.
- [One default file explains most of the security gap between Lovable and Bolt](https://getprbl.com/blog/lovable-supabase-key-pattern): Follow-up research; 59% of Lovable's credential findings trace to one default-generated Supabase client file, with a Row Level Security explainer
- [We fixed our scanner 11 times in one week. Here's every fix.](https://getprbl.com/blog/scanner-fixed-17-times): Every false-positive fix made before publishing the Lovable/Bolt study, with the regression test behind each one
- [More than 1 in 4 apps built with Lovable or Bolt has a high-severity security flaw. We checked.](https://getprbl.com/blog/lovable-bolt-security-scan): Original research, 628 real Lovable/Bolt-generated apps scanned, 27.1% had a high-severity finding
- [1 in 3 repos shipped to Hacker News has a high-severity security flaw. We checked.](https://getprbl.com/blog/hn-security-scan-findings): Original research, 976 real GitHub repos scanned, 31.6% had a high-severity finding
- [Our scanner flagged its own marketing copy as a leaked password](https://getprbl.com/blog/scanner-flagged-its-own-marketing-copy): A real dogfooding false-positive case study
- [How we test Prbl: 113 repos, 303 regression tests, under 10% false positives](https://getprbl.com/blog/testing-methodology): Validation pipeline and a precision comparison against Semgrep
- [How do I secure my vibe coded app?](https://getprbl.com/blog/how-to-secure-vibe-coded-app)
- [What security vulnerabilities does AI-generated code have?](https://getprbl.com/blog/ai-generated-code-vulnerabilities)
- [Is Cursor-generated code secure?](https://getprbl.com/blog/is-cursor-generated-code-secure)
- [What does JWT decode without verify mean?](https://getprbl.com/blog/jwt-decode-without-verify)
- [How do I find hardcoded secrets in my codebase?](https://getprbl.com/blog/find-hardcoded-secrets-in-codebase)
- [What is a fallback secret in environment variables?](https://getprbl.com/blog/fallback-secrets-environment-variables)
- [How do I prepare my SaaS for a security audit?](https://getprbl.com/blog/prepare-saas-for-security-audit)
- [What is BOLA in web security?](https://getprbl.com/blog/what-is-bola-web-security)

## Fixes (AI-generated bug patterns)
- [Fix index](https://getprbl.com/fix): Exact fixes for the security patterns AI coding tools introduce most
- [rejectUnauthorized: false](https://getprbl.com/fix/ssl-rejectunauthorized-false): Disabled TLS certificate verification (CWE-295) and the correct fix
- [Math.random() for tokens](https://getprbl.com/fix/math-random-security): Weak randomness (CWE-330) and the cryptographic fix
- [CORS wildcard origin](https://getprbl.com/fix/cors-wildcard-origin): Permissive Access-Control-Allow-Origin (CWE-942) and the allowlist fix
- [SQL string concatenation](https://getprbl.com/fix/sql-string-concatenation-injection): SQL injection (CWE-89) and the parameterized-query fix
- [Command injection (shell=True / exec)](https://getprbl.com/fix/command-injection-shell): OS command injection (CWE-78) and the argument-array fix
- [Missing auth on an API route](https://getprbl.com/fix/missing-auth-api-route): Missing authorization / BOLA (CWE-862) and the ownership-check fix
- [dangerouslySetInnerHTML XSS](https://getprbl.com/fix/dangerouslysetinnerhtml-xss): Cross-site scripting (CWE-79) in React and the sanitize/escape fix
- [eval() with user input](https://getprbl.com/fix/eval-user-input): Code injection (CWE-95) and safe alternatives
- [Path traversal](https://getprbl.com/fix/path-traversal-user-input): Reading files outside a directory (CWE-22) and the resolve-and-verify fix
- [Open redirect](https://getprbl.com/fix/open-redirect): Phishing via user-controlled redirects (CWE-601) and the allowlist fix
- [Weak password hashing (MD5/SHA-1)](https://getprbl.com/fix/weak-password-hashing): Insufficient hash strength (CWE-916) and the bcrypt/argon2 fix
- [SSRF from a user URL](https://getprbl.com/fix/ssrf-user-url): Server-side request forgery (CWE-918) and the allowlist fix
- [XXE (XML external entity)](https://getprbl.com/fix/xxe-xml-parsing): Unsafe XML parsing (CWE-611) and the defusedxml fix
- [Insecure deserialization (pickle)](https://getprbl.com/fix/insecure-deserialization-pickle): Deserializing untrusted data (CWE-502) and the JSON fix
- [Lovable exposed my Supabase service_role key](https://getprbl.com/fix/lovable-exposed-service-role-key): The key that bypasses RLS; rotate immediately
- [v0 exposed my Supabase key](https://getprbl.com/fix/v0-exposed-supabase-key): Anon vs service_role, RLS, and NEXT_PUBLIC
- [Cursor exposed my database URL](https://getprbl.com/fix/cursor-exposed-database-url): Connection strings embed credentials; rotate and move to env
- [Replit exposed my OpenAI key](https://getprbl.com/fix/replit-exposed-openai-key): The most-harvested key on Replit; revoke and use Secrets
- [Cursor exposed my API key](https://getprbl.com/fix/cursor-exposed-api-key): Step-by-step remediation when Cursor hardcodes or indexes a key: rotate first, then .cursorignore + .cursor/rules to prevent it
- [Lovable exposed my Supabase key](https://getprbl.com/fix/lovable-exposed-supabase-key): Why the hardcoded anon key is only safe with Row Level Security, and how to secure a Lovable app's Supabase setup
- [Bolt exposed an API key](https://getprbl.com/fix/bolt-exposed-api-key): Fixing a hardcoded key in a Bolt-generated app: rotate, purge history, move to env vars
- [v0 hardcoded an API key](https://getprbl.com/fix/v0-hardcoded-api-key): Fixing an inline key in v0 output, including keeping it server-side and off the NEXT_PUBLIC_ prefix

## Learn (concept explainers)
- [Learn index](https://getprbl.com/learn): Plain-language AI code security concepts
- [What is Row Level Security (RLS)?](https://getprbl.com/learn/what-is-row-level-security): Database rules that protect a Supabase database; the gap most AI builders skip
- [Supabase anon key vs service_role key](https://getprbl.com/learn/supabase-anon-key-vs-service-role-key): Which is public, which bypasses RLS, and where each belongs
- [Why an env var isn't enough to hide a secret](https://getprbl.com/learn/client-side-vs-server-side-secrets): Client-side vs server-side secrets and the NEXT_PUBLIC trap
- [What are HTTP security headers?](https://getprbl.com/learn/what-are-security-headers): CSP, HSTS, X-Frame-Options and why AI-built apps ship without them
- [What is a hardcoded secret?](https://getprbl.com/learn/what-is-a-hardcoded-secret): The #1 high-severity flaw in AI-generated code
- [What is CORS and why is a wildcard origin risky?](https://getprbl.com/learn/what-is-cors-wildcard-risk): Cross-origin rules and the wildcard trap
- [What is an API key?](https://getprbl.com/learn/what-is-an-api-key): Public vs secret keys and how to store them safely
- [What is SQL injection?](https://getprbl.com/learn/what-is-sql-injection): How user input becomes query code, and the parameterized fix
- [What is cross-site scripting (XSS)?](https://getprbl.com/learn/what-is-xss): How attacker scripts run in a user's browser, and prevention
- [What is a JWT?](https://getprbl.com/learn/what-is-a-jwt): Signed tokens and the decode-vs-verify mistake

## Is your AI coding tool secure?
- [Tool security index](https://getprbl.com/security): Is-it-secure guides by tool, with real scan data and a checklist
- [Is Cursor secure?](https://getprbl.com/security/cursor): Two separate questions. The editor itself, mostly yes if updated to Cursor 2.0 (a cluster of 2025 prompt-injection and RCE CVEs, including CVE-2025-54135, are all patched). The code it writes, not automatically: hardcoded API keys, committed .env files, and API routes with no server-side authorization are the recurring issues
- [Is Lovable secure?](https://getprbl.com/security/lovable): 35.1% of Lovable apps had a high-severity flaw in our scan; the hardcoded Supabase key + missing RLS is the main risk
- [Is Bolt.new secure?](https://getprbl.com/security/bolt): 19.8% high-severity flaw rate; hardcoded secrets, missing RLS, missing security headers
- [Is v0 code secure?](https://getprbl.com/security/v0): Next.js risks: secrets shipped to the browser via NEXT_PUBLIC and client components
- [Is Replit safe?](https://getprbl.com/security/replit): Public Repls scraped for keys; Agent embeds keys client-side; use the Secrets pane
- [Is Windsurf safe?](https://getprbl.com/security/windsurf): Cascade agent hardcodes secrets and can leak them through prompts and MCP
- [Is GitHub Copilot code secure?](https://getprbl.com/security/github-copilot): Suggests hardcoded credentials from training data; repos with Copilot leak secrets more often
- [Is Base44 secure?](https://getprbl.com/security/base44): Managed backend hides risk; documented flaws include token-leaking redirects and client-only enforcement
- [Is Claude Code secure?](https://getprbl.com/security/claude-code): Strong code, same credential-hygiene flaws; ~1 in 8 Claude-built apps had a high-severity flaw in our scan
- [Is OpenAI Codex secure?](https://getprbl.com/security/codex): Lowest flaw rate we measured (9.8%) but not significant; same leaks
- [Is Databutton secure?](https://getprbl.com/security/databutton): Full-stack generation risks: hardcoded secrets and unrestricted data access
- [Is Firebase Studio secure?](https://getprbl.com/security/firebase-studio): App security depends on Firebase Security Rules; permissive rules leave the database open

## Compare
- [Prbl vs Snyk](https://getprbl.com/alternatives/snyk)
- [Prbl vs Semgrep](https://getprbl.com/alternatives/semgrep)
- [Prbl vs GitHub Advanced Security](https://getprbl.com/alternatives/github-advanced-security)

## Use cases
- [Prbl for Cursor users](https://getprbl.com/for/cursor-users)
- [Prbl for vibe coders and solo founders](https://getprbl.com/for/vibe-coders)
- [Prbl for SOC 2 prep](https://getprbl.com/for/soc2-prep)

## Key facts
- Original research (largest to date): scanned 2,736 live AI-built apps for broken access control; 124 (4.5%, about 1 in 22) served a private dashboard, API, or database to an anonymous visitor with no login
- Original research: used the public Supabase anon key, exactly as any visitor could, against 15 Supabase-backed apps; 4 (more than 1 in 4) had at least one database table anyone could read with no login
- 15 distinct rule classes covering AI-generated code vulnerability patterns
- Stress-tested across 113 real repositories
- 373 regression tests
- Independently verified: Mozilla Observatory A+ (115/100), passing CodeQL, 0 fixable vulnerabilities via pip-audit
- Precision comparison: Semgrep's default ruleset produced 54 findings (53 false positives) on create-t3-app; Prbl produced 0 findings on the same repo
- Original research: scanned 976 real GitHub repos linked from Hacker News; 31.6% had at least one high-severity finding. Most common high-severity patterns: path traversal, hardcoded credentials, code injection
- Original research: scanned 628 real apps generated by Lovable and Bolt; 27.1% had at least one high-severity finding. Most common: hardcoded credentials (128 apps), weak randomness (39 apps)
- Original research: scanned 119 web apps built with Claude Fable 5; 12.6% had at least one high-severity finding, dominated by hardcoded secrets and disabled TLS. Claude Opus 4.8 (prior generation) scored a statistically indistinguishable 15.2%, showing model capability gains do not reduce credential-hygiene flaws
- Pricing: Free (10 scans/month, 3 repos), Pro $29/month or $290/year (200 scans/day, 50 rewriter credits), Team $99/month or $999/year (1,000 scans/day across the team, 200 rewriter credits), Enterprise from $500/month or $5,000/year (unlimited team members, 1,000+ rewriter credits). Annual billing on all paid tiers gets 2 months free. Scanning is manual today via the dashboard or free scan tool; automatic CI/GitHub Actions scanning is in development.