Open source core · MIT · zero dependencies

Catch what your AI agents break, before you ship it.

ForgeValidators catches the mistakes AI coding agents actually make - exposed keys, dead buttons, swallowed errors, invented columns, silent drift. Scan your live site free in seconds, or run the CLI on your codebase before you ship.

Scan your site free Install the CLI
$ npm install -g forgevalidators
your-project ~ forgevalidators
$ forgevalidators
-- ForgeValidators Report ------------------
PASS injection-safety 45 files
PASS error-leaks 45 files
FAIL response-success-checks 2 errors
FAIL dead-references 1 error
WARN input-safety 2 warnings
PASS inline-handlers 45 files
PASS dead-endpoints 32 endpoints
> response-success-checks
dashboard.js:214 fetch result used without a
success check; renders empty
> dead-references
checkout.html:71 calls apply-coupon, which
no longer exists
5 passed, 2 failed, 1 warning -> exit 1, build blocked
Pro · inside your agent's loop
agent: running validators...
tool: FAIL "user_mail" not in schema
agent: fixed -> user_email
tool: PASS all green
25+ checks that block the build. Born from real incidents, enforced on every change.
1 commandruns the whole suite in seconds
0 dependenciesplain Node 18+, nothing phones home
exit 1wired into CI, it blocks the ship
What you get

One command. Every lesson already learned.

Install it, run it, wire it into CI. From zero to a guarded codebase in under five minutes, with no config required to start.

01 /

Install

Node 18+, zero dependencies, Windows, macOS, and Linux. No account. Nothing phones home.

$ npm install -g forgevalidators added 1 package in 2s
02 /

Run

Sensible defaults for Netlify + Supabase style projects; one config file adapts anything else. Checks that do not apply skip cleanly.

$ forgevalidators PASS injection-safety FAIL response-success-checks ...
03 /

Enforce

Exit code 0 or 1: a failure class you have met once never ships twice. Intentional exceptions live inline, visible in review.

# ci.yml - run: forgevalidators # exit 1 -> job fails, bug never ships el.innerHTML = safe; // inject-ok
zero dependencies·no account·runs offline·CI exit codes·inline suppress comments·MCP server for AI agents (Pro)
What it catches

Bugs you will never ship again.

25+ checks today, growing as new incidents earn them. Everything below is in the free tier.

Silent failures

No. 01 · free
  • API calls that fail and render as an empty page. success never checked
    response-success-checks
  • Buttons that do nothing when clicked. handlers trapped in closures
    inline-handlers
  • Crashes hiding inside query chains. .catch() on a PromiseLike throws
    promiselike-catch
  • Confirming one record, changing another. effect target re-checked at execute
    effect-target-recheck

Security holes

No. 02 · free
  • Stack traces served to your users. internal errors leaking out
    error-leaks
  • Injection waiting in query strings. SQL and filter injection
    input-safety
  • XSS sitting in innerHTML and eval. injection sinks plus URL params
    injection-safety
  • Deployed functions nothing calls. free attack surface
    dead-endpoints
  • Backend queries that quietly return less. anonymous client filters rows
    anon-client

Drift and rot

No. 03 · free
  • Calls to functions that no longer exist. deleted but still referenced
    dead-references
  • Catalogs that lie about what is on disk. registry vs reality
    registry-mirror-drift
  • Client actions the server never routes. action params cross-checked
    action-params
  • Token fields that are not there. JWT field access verified
    jwt-field-access
  • Pages that quietly break on phones. viewport and touch targets
    responsive-css

The database-aware checks - invented columns, auth boundaries, schema drift, response envelopes - are Pro. See what they catch.

Why trust these checks

Every one was born from a real failure.

These rules were not brainstormed. They come from a production codebase where AI agents write effectively all the code - hundreds of serverless functions, tens of thousands of commits, up to twenty agents at once. Every time AI broke something real, the failure became a permanent, machine-enforced check. Three of those days:

Exhibit A · incident recorddata corruption
14 days silent

The guessed status word

An agent wrote "deleted" into a lifecycle field. The canonical word was "archived". Nothing crashed. The write succeeded. For two weeks, a daily job quietly produced orphaned records before a validator caught the pattern.

What it became: written status words are checked against the canonical vocabulary. Guessed values fail before they land.
Exhibit B · incident recordswallowed errors
21 days swallowed

The plausible endpoint

A UI component called an endpoint that looked right and was wrong. Every call failed with an HTTP error, which an error handler swallowed into an empty list. Users saw nothing. Logs said nothing. Three weeks.

What it became: any response consumed without a success check now fails validation. Empty is no longer a disguise for broken.
Exhibit C · incident recordmerge collision
0 bytes left

The vanishing file

Two agents edited the same hot file in parallel. The merge truncated a core file to zero bytes. No error, no warning - an empty file where working code used to be.

What it became: protected files declare a minimum size and required anchors. If one shrinks past its floor, the build fails loudly.
349machine-enforced rules classified in the parent codebase, July 2026
28.9%trace to a documented AI incident, with evidence
55.9%exist because of how AI fails
Contract driftcode quietly diverging from what it promised
85
Duplicate rebuildsAI rebuilding what exists, then the copies diverge
34
Stale referencespointers left behind after things move or die
31
Skipped process stepsproofs and checks silently omitted
26
Hallucinated APIsthe famous onecalls to endpoints, fields, and columns that do not exist
21

One codebase, one methodology, mostly one family of models. These percentages describe our system, measured carefully. A data point the industry does not otherwise have - not a law of nature.

ForgeValidators Pro

Put the checks inside your agent's loop.

Pro adds the validators that need to know your actual schema - the ones that catch what an agent invented:

  • +Column hallucination. References to columns that do not exist in your database.
  • +Auth boundary. Endpoints that declare protection their code never implements.
  • +Schema drift. Your schema documentation vs the live database.
  • +Response envelope. Double-wrapped and misshapen API responses.

The MCP server

Pro registers each validator as a tool your AI agent can call: Claude Code, Cursor, Copilot, anything MCP-compatible. The agent validates before it claims done, instead of you finding out after.

agent: edit complete. running validators... tool: FAIL column-references - "user_mail" not in schema agent: fixing: user_mail -> user_email tool: PASS column-references agent: done. all validators green.
$49/dev/month. One prevented incident saves $750 to $7,500 in engineering time. The tool pays for itself on the first bug it catches, and most teams catch their first in week one.
Pricing

Start free. It is not a demo.

Free
$0
forever, MIT license
  • +The full core suite: 25+ validators, including the incident-born checks
  • +CLI with CI-ready exit codes
  • +Zero dependencies, Node 18+
  • +Inline suppress comments for intentional exceptions
  • +No account, no license key, nothing phones home
$ npm install -g forgevalidators
Source, issues, and docs on GitHub.
Pro
$49
per developer / month
  • +Everything in Free
  • +Database-aware validators: column hallucination, auth boundary, schema drift, response envelope
  • +MCP server: validators inside Claude Code, Cursor, and Copilot
  • +License key, validates offline
  • +Priority support
We onboard Pro teams in order. No card required to get in line.

Beyond Pro

Detection tells you a bug exists. Prevention makes it impossible to write: query builders that reject invented column names at call time, schema registries that answer "did you mean", and a learning protocol where every AI session leaves the system smarter than it found it. That deeper layer is how the codebase behind these validators actually runs. If catching the same class of bug twice offends you, ask us about it.

FAQ

Fair questions.

Is the free tier actually useful, or a crippled demo?
It is the product. The core suite is MIT-licensed and includes the incident-born validators, because a free tier that catches nothing convinces nobody. Pro exists for the checks that need access to your live schema, and for putting validators inside AI agents' tool loops.
What stacks does it work on?
JavaScript and TypeScript codebases on Node 18+. Defaults are tuned for serverless projects in the Netlify + Supabase family; a small config file adapts it to other layouts. Validators that do not apply to your stack skip cleanly and say why.
How is this different from Snyk, Semgrep, or SonarQube?
Those tools scan for known vulnerability signatures, mostly in human-written code. They will not notice a plausible-but-wrong endpoint, a swallowed response, or a guessed enum value, because none of those match a CVE. ForgeValidators is built from the failure record of AI-written code. Run both. They do not overlap much.
Does my code leave my machine?
No. The CLI runs locally with zero dependencies. There is no server to send your code to. The Pro license key validates offline.
What about false positives?
Every validator honors an inline suppress comment (like // inject-ok) so intentional exceptions live next to the code they excuse, visible in review. Prevention-class validators warn instead of fail on principle.
Where do your numbers come from?
A classification pass over all 349 machine-enforced rules in the parent codebase (July 2026), with an evidence quote required for every claim and the counts independently re-verified. It is one codebase and one methodology, and we say so. That is still a longer, deeper incident record of AI-written code than anything public we could find.

The next silent bug is already being written.

Five minutes from now, your codebase can be checking for it on every change.

$ npm install -g forgevalidators
View on GitHub