Vibefilo is a security and compliance check for apps built with AI builders such as Lovable, Bolt, v0, Replit, Cursor and Claude Code. It does not scan anything itself. It runs inside the developer's own coding agent (Claude Code, Cursor, Codex, Windsurf, VS Code or any MCP client): the agent reads the code with Vibefilo's rules, fixes what is safe, and re-checks every fix. Every result lands on a dashboard at vibefilo.dev.
It is built for solo builders and small teams who ship fast and cannot afford a security audit or a lawyer before launch. The mistakes they make are the same ones again and again, and generic scanners do not understand their stack.
I was the only person on it: product, the Next.js dashboard, the Hono API and MCP endpoint, the npm package, the database and its policies, payments, and the marketing site. It went from an empty repository to a live product in days, which is why so many decisions below favour reusing one schema and one rule format everywhere.
- 58
- rules across security, privacy and accessibility
- 11
- MCP tools between the agent and the dashboard
- 3
- check modes: Lite, Normal and Full
- 5
- coding agents wired up by one command
The problem
AI builders produce working apps fast, and they repeat the same mistakes.
Secrets leak. Keys end up in frontend code or committed .env files, and a leaked key is not fixed by deleting the line.
Databases are open. Supabase tables ship without Row Level Security, and API routes return user data without checking who is asking.
Privacy is an afterthought. Analytics and pixels load before consent, the privacy policy is a template that names none of the real services, and users cannot export or delete their data.
Nobody re-checks the fix. An agent says it fixed something and moves on. Without a second look, a finding is closed because someone said so, not because it passed.
The approach
Vibefilo makes four commitments and lets every design decision follow from them.
The agent scans, Vibefilo knows
Vibefilo never reads code on its own servers. It provides the rules, the check recipes and the fix guidance, and the user's agent does the work.
Code stays local
Only findings, short masked evidence and a data inventory reach the platform. Secret values never leave the machine, and evidence shows a location and a masked prefix only.
Nothing is fixed until verified
A finding turns Verified only when a re-check passes every goal attached to its rule. The score moves on that, not on the agent's say-so.
Ask before anything risky
Legal text, consent behaviour, deleting data, rotating keys and rewriting git history always need the user's approval first.
The central idea: Vibefilo is a rule pack plus a ledger, not a scanner. The rules are versioned YAML that tells an agent what to investigate and what must be true afterwards. The backend records what the agent reports and decides what counts as fixed. The agent never grades its own work.
How a check works
- 1
Install
npx @vibefilo/mcp init detects the agents on the machine, registers the MCP connection, installs the skill and slash commands, and links the folder to a project.
- 2
Sign in
The first tool call returns a link and a short code (OAuth device flow). If the user is already signed in on vibefilo.dev, approving is one click.
- 3
Check
The user runs /vibefilo lite, check or full. The agent fetches the audit plan, applies the rules to the code, and submits findings with masked evidence.
- 4
Fix
Safe fixes are applied automatically, risky ones wait for approval, and decisions that are not code (legal wording, key rotation) are listed for the user.
- 5
Verify and report
Each fix is re-checked against its verification goals. The dashboard shows the score and verdict live, and a Full check produces a PDF report.
Key features
A rule pack of 58 checks
The pack is YAML in git: 40 security rules, 9 privacy and GDPR rules and 9 accessibility rules. Each one says what to investigate, what to check and which verification goals must hold afterwards, so a fix can be judged the same way every time. Rules are seeded into Postgres on deploy, so users get new rules instantly without updating a package.
Security covers the usual vibe-coding failures (secrets, RLS and database access, missing auth, access control, frontend secrets, SSRF, CSRF, headers, CORS, rate limits, SQL injection, XSS, payment webhooks, uploads, error handling, password hashing, dependencies) and goes on to tenant isolation, JWT verification, OAuth flows and LLM input and output handling. Privacy covers the policy, cookie consent, signup consent, data export, account deletion, processors and trackers.
Three modes, honest coverage
Lite (15 credits) runs blocker-level rules on current files only. Normal (50) runs the full security set and the privacy checks at code level. Full (100) adds git history, live checks against the deployed URL and every severity.
The score always shows its mode and coverage, for example 'Lite check, 18% of rules checked'. Only a Full check with no open Blocker or High finding and nothing left to verify by hand can say Ready. Lower modes report 'No blockers found' at best, so a quick check can never be mistaken for a pre-launch audit.
The fix loop
Findings carry a fixability tier: auto (the agent fixes alone), assisted (after approval) or human (a business or legal decision). The agent works highest severity first, asks before anything risky, and records each re-check through vibefilo_verify_fix, which turns the finding Verified or reopens it.
A leaked secret is never treated as fixed by deletion alone: the agent tells the user to rotate it.
A consent banner that actually blocks
For the privacy findings that need code, the agent can install a cookie consent banner through vibefilo_install_consent. Scripts are held as inert text/plain until the visitor allows their category, accept and reject are equal choices, and consent records can go to an endpoint the customer owns. It asks the user before changing consent behaviour in their app.
A live dashboard
Runs, findings and scores arrive over Supabase Realtime as the agent works, with a score ring, severity breakdown, credit balance chart, connected agents and a per-project run history. A Markdown copy of every run is also saved in the repo, and a Full check can be exported as a PDF.
Teams are organisations with up to five members, invited by email with expiring single-use tokens.
The MCP package
@vibefilo/mcp is a small stdio bridge published to npm. It signs the user in, writes the config for Claude Code, Cursor, VS Code, Windsurf and Codex (showing each change and backing up any file it edits), and forwards tool calls to the backend. It stores no findings and does no analysis. It also ships init, login, status, doctor, logout and uninstall commands.
Tokens are kept in the OS keychain with an encrypted file fallback, access tokens last 15 minutes, and reusing an old refresh token revokes its whole family. For CI, a project-scoped API key works instead.
Credits, not a subscription
New organisations get 100 free credits, enough for one Full check, then buy packs through Polar, the merchant of record that handles global sales tax. Every response shows the cost and remaining balance, and big checks are confirmed first. Failed runs are refunded and credits expire after 12 months.
Charging happens in the same database transaction as the tool work, through an idempotent function that locks the wallet and enforces spending caps, so a retried request can never double charge.
Architecture
Coding agent
Claude Code, Cursor, Codex, Windsurf, VS Code
@vibefilo/mcp
Stdio bridge, tokens in the OS keychain
Browser
The vibefilo.dev dashboard
apps/backend
Hono API and MCP endpoint
apps/frontend
Next.js dashboard and docs
Postgres and RLS
Findings, credits, rule packs
Auth
Google and email sign-in
Realtime
Pushes live results to the dashboard
Storage
PDF reports
Polar
Credit packs, merchant of record
Brevo
Invites and alerts
Upstash Redis
Rate limits
Sentry
Errors, no PII
| Frontend | Next.js 16 and React 19, HeroUI v3 on Tailwind CSS v4, Motion, Recharts |
| API | Hono on Vercel Functions, one app serving REST, the MCP endpoint and signed webhooks |
| MCP | Official MCP SDK over stateless Streamable HTTP, plus the @vibefilo/mcp stdio bridge |
| Database | Supabase Postgres with RLS on every table, Drizzle ORM, SQL functions on pg_cron |
| Contracts | One Zod package shared by the bridge, the API and the dashboard |
| Auth | Supabase Auth for the dashboard, OAuth device flow for agents |
| Payments | Polar one-time credit packs with signed webhooks |
| Tooling | pnpm and Turborepo monorepo, Biome, Vitest, Playwright, GitHub Actions |
Decisions and trade-offs
Rules in git, not in code. Every rule change is reviewed and versioned as YAML, then seeded to Postgres. It costs a seeding step on deploy and buys instant rule updates for every user with no package release.
One schema package. The bridge, the API and the dashboard all import the same Zod schemas, so they can never disagree about what a finding looks like.
No LLM on the platform. Vibefilo does not generate legal text or analyse code itself. The user's own agent does that, which keeps code local, avoids a server-side model bill and keeps the product to guidance rather than advice.
Stateless MCP over HTTP. A new server per request with JSON responses works behind serverless functions, and the bridge and any future remote client use the same endpoint.
Charge inside the transaction. Debiting credits in the same transaction as the work, keyed by an idempotency key, is slower to build than a counter but makes double charges and lost refunds structurally impossible.
Security
Row Level Security everywhere. Every table has RLS, dashboard actions run through Postgres functions as the signed-in user, and the backend scopes every query to the token's organisation. pgTAP tests cover the policies and the money functions.
Tokens. Opaque tokens stored only as SHA-256 hashes, short-lived access tokens, rotating refresh tokens with reuse detection, and invite tokens that are hashed, single use and bound to the invited email.
Payments. Webhooks are signature checked and idempotent, and the welcome grant is idempotent per verified account so recreating an organisation never grants twice.
Privacy of findings. Evidence is masked before it leaves the machine, and Sentry runs with no PII, no IPs, headers, cookies or request bodies, replaying only sessions with an error and fully masked.
Checks its own work. The product is built to pass its own rules, and the pipeline runs lint, type checks, unit tests and database tests on every change.
Design
The audience is vibe coders, not compliance officers, so the dashboard leads with one next step ('Fix 3 Blockers', 'Run a Full check to get Ready') and shows progress rather than a wall of problems. It is dark only, with a near-black background, a lime accent, large radii and pill buttons.
Severity is never colour alone: Blocker, High, Medium and Low always pair a colour with an icon and a label. Motion stays under 300 ms, never blocks input and falls back to fades under reduced motion. Because the product sells accessibility checks, the dashboard itself has to pass them.
Challenges
Making 'verified' mean something. The agent is the one doing the work, so the platform needs its own way to know a fix held. Each rule carries explicit verification goals, and a finding changes status only through the verify tool.
Honest scores from partial checks. A fast check that reports 100 would be dangerous. Coverage is part of the score, and the Ready verdict is reserved for Full checks.
Money correctness. Charges, refunds for failed runs, expiry and daily caps all have to hold under retries and concurrency, so they live in SQL with idempotency keys and are covered by database tests.
Working across many agents. Each agent keeps its config in a different place and format. The init command detects them, shows every change before writing and backs up what it edits.
Shipping everything solo. Auth, billing, email, a PDF report, a published npm package, docs and a marketing site were built together rather than after the core loop.
Outcomes
Vibefilo is live at vibefilo.dev with documentation, a pricing page and an npm package, @vibefilo/mcp, that connects Claude Code, Cursor, Codex, Windsurf and VS Code with one command.
The repository has unit and integration tests for the API and billing, an end-to-end script that drives the real agent flow, Playwright tests for the public site, and nine pgTAP suites covering row level security, credits, refunds and payments. Full checks also export as a PDF report.
What is next
Private beta. Putting it in front of vibe coder communities and measuring how many first checks finish without help, and how many findings end up Verified.
Vibefilo checking itself. Running every security and privacy rule on Vibefilo and fixing what it finds, so its own Full check is Ready before launch.
Remote MCP. Agents that support remote OAuth connecting straight to the hosted endpoint, with no local process.
More rules. New checks shipped through the rule pack, which reaches every user without a package update.
Stack
- Next.js
- React
- TypeScript
- Tailwind CSS
- Hono
- Node.js
- PostgreSQL
- Supabase
- Zod
- MCP
- Agentic AI Development
- Turborepo
- pnpm
- Vitest
- Playwright
- GitHub Actions