Summary

This free ai code checker scores pasted code from 0 to 100 using six client-side heuristics: line length, nesting depth, comment ratio, magic numbers, leftover TODO/FIXME markers, and single-letter naming. Nothing is uploaded, the score updates as you type, and each category shows its own point breakdown so you know exactly what to fix first.

Paste your code, get an instant quality score

This free AI code checker runs a 0-100 heuristic on whatever you paste: line length, nesting, comments, magic numbers, naming. Nothing you type leaves your browser.

Check my code

AI code checker

Paste a function or a short file below. The score updates as you type, based on six checks that run entirely client-side: nothing you paste is sent anywhere.

code-checker.sh
0 /100
Checking Heuristic quality score, not a linter or a compiler

Type or paste code above to see where the points go.

Line length0/20
Nesting depth0/20
Comments0/20
Magic numbers0/15
TODO / FIXME markers0/10
Naming0/15
How it works

What the score actually checks

Line length & nesting

Lines past 100 characters and if-blocks nested more than three or four deep are the fastest way to make a diff painful to review. We measure both: nesting depth comes from counting brackets for C-style languages and indentation levels for Python-style ones, so the check works whether or not your language uses braces. Anything past four levels starts losing points fast, because that's usually the point where a reviewer has to scroll back up to remember which condition they're inside.

Comments & magic numbers

Code that explains itself has a light layer of comments, roughly one line in five to one in ten, and few unexplained literals. We flag files with almost no documentation, and separately flag files where numbers like 500 or 0.85 show up with no name attached and no comment nearby. TODO and FIXME lines don't count toward the comment score: they're markers, not documentation, so a file full of them still reads as under-explained.

Naming & leftover markers

Single-letter variables outside common loop counters like i, j or n make code harder to follow the moment it's more than a few lines long, so we count how many of your declared and assigned variables fall into that trap. Leftover TODO and FIXME comments cost a couple of points each too: they're honest signals of unfinished work, but they add up the same way they would in an actual pull request review.

Why a heuristic, not fake AI

No server, no model, no black box

Every AI code checker on the internet promises a magic AI score. This one doesn't run an AI at all: it's six explainable checks, the same things a human reviewer scans for in the first thirty seconds of opening a pull request. Line length, nesting depth, comment ratio, magic numbers, leftover TODOs, single-letter names. Each has a fixed point budget, so you can see exactly why a file scored what it scored, not just a number with no receipts.

  • Runs entirely client-side, in the tab you're already in
  • Same six checks every time, no randomness between runs
  • Built for a quick gut-check before a PR, not a compliance audit
Close-up of hands typing on a mechanical keyboard with a code editor glowing on the monitor behind

Common questions

Is this ai code checker actually free?
Yes. No signup, no account, no rate limit. The scoring runs in your browser tab and nothing is metered on our end.
Does my code get uploaded anywhere?
No. The whole calculation happens in JavaScript, in your browser, the moment you type. We don't see your code and we don't store it.
What is the score actually based on?
Six checks: average line length, nesting depth (bracket and indentation based), comment ratio, count of unexplained numeric literals, leftover TODO/FIXME markers, and how many variables have single-letter names outside common loop counters. Each has a fixed point budget out of 100.
Which languages does it support?
Any text-based language. The comment detection covers //, #, /* */ and -- style comments, which covers JS, Python, Java, C-family languages, Ruby, SQL and most others. It reads the text, not a language-specific parser.
Why did my code score lower than I expected?
Usually one category is dragging the total down: check the breakdown bars. Deep nesting and a wall of bare numbers are the two most common culprits we see.
Is this a replacement for a real linter or code review?
No. It's a fast, honest gut-check on readability, not a compiler, not a security scanner, and not a substitute for ESLint, Pylint, or an actual reviewer. Use it as a first pass, not a verdict.
Why does adding comments not always raise the score?
Because the comment check rewards a healthy ratio, roughly 5 to 40 percent of lines, not a maximum. A file that's mostly comments loses points too: it usually means the comments are restating the code instead of adding context, which slows a reviewer down as much as having none at all.
How is nesting depth measured for languages without curly braces?
For Python, YAML-style config and anything else that uses indentation instead of brackets, we detect the smallest indent step used in the file (2 spaces, 4 spaces, whatever you picked) and count how many of those steps deep the furthest line goes. For JS, Java, C, Go and similar, we count bracket nesting directly. The deeper of the two measurements is what counts against the score.
I pasted a huge file and the score barely moved. Why?
Every check is ratio-based, not count-based: line length looks at the share of lines over 100 characters, comments look at the share of commented lines, magic numbers look at the count relative to total lines. That means a 500-line file with the same proportions as a 20-line one scores about the same. It rewards consistent style, not file size.

Still not sure what to build next?

whatshouldibuildnext.com runs a free AI spec generator too: describe an idea, get a scoped spec and a stack suggestion, no signup required.

Find your next project idea
~/build
Generate an idea