🧮 Code Readability / Complexity Estimator

This tool gives you a rough, at-a-glance read on how complex and maintainable a code snippet is — without needing to install a linter, configure a static analysis tool, or even know what language you're looking at. Paste in any snippet and it immediately estimates cyclomatic complexity, maximum nesting depth, comment coverage, and average line length using simple text-pattern heuristics, then combines complexity and nesting into a single Simple / Moderate / Complex / Very Complex maintainability rating. It's built for quick sanity checks — skimming a pull request, deciding whether a function needs refactoring, or getting a fast second opinion before diving into a proper code review — not as a replacement for real static analysis tooling.

How It Works

Lines of code are counted by splitting the snippet on line breaks and discarding blank lines; comment lines are identified by checking whether a trimmed line starts with a common comment marker (//, #, /*, *, or --), and the comment ratio is comments ÷ non-blank lines. Cyclomatic complexity starts at 1 (representing a single straight-line path through the code) and adds 1 for every occurrence of a decision-point keyword or operator — if (which also naturally covers every else if, since that still contains the word "if"), for, while, case, catch, elif, &&, ||, and the ternary ?: operator — found via word-boundary regex matches across the whole snippet. Nesting depth is estimated by measuring each line's leading whitespace (tabs expanded to spaces), detecting the most common non-zero indentation step between distinct indent levels, and dividing the deepest indentation found by that step size.

Why It Matters

High cyclomatic complexity and deep nesting are strongly correlated with code that's harder to test, harder to reason about, and more likely to contain bugs — every additional decision point roughly doubles the number of distinct paths a reviewer or test suite needs to cover. A quick heuristic score like this one can't replace a real code review, but it's a fast, zero-setup way to flag a function that's grown too tangled and might be worth breaking into smaller pieces before it becomes a maintenance burden.

Tips for Accurate Results

• Treat every number here as a rough estimate, not ground truth — this tool uses text patterns, not a real parser, so it can't perfectly distinguish code from strings or comments in every language.
• For consistent nesting depth estimates, paste code that uses consistent indentation (all spaces or all tabs) — mixed indentation can throw off the detected indent width and skew the depth estimate.
• Use this as a first-pass triage tool to flag functions worth a closer look, then confirm with a real static analysis tool appropriate to your language (ESLint/TypeScript for JS/TS, radon or pylint for Python, SonarQube for many languages).
• A high comment ratio doesn't automatically mean good documentation — stale or redundant comments can inflate the ratio without improving actual readability.
• Break down large snippets into individual functions before analyzing them here — a single giant snippet mixing many functions will report combined metrics that don't reflect any one function's real complexity.