openai/math

Rules of thumb, not measurements: one man-year rebuilds about 10,000 lines of main code (design, testing and coordination included), and keeping a code base alive takes about 15% of its rebuild value per year (20 man-years of rebuild value need about 3 man-years of maintenance every year). Your changes are remembered in this browser for every report.

Ease of change*

2.9ABCDE

for people · measured on 6 of 10 sub-scores

Ease of change*

2.5ABCDE

for AI · measured on 6 of 9 sub-scores

Complex units

16%high

of unit code with McCabe > 25

Long units

31%high

of unit code in units > 50 lines

Large files

39%high

of main code in files > 500 lines

Goals

0 / 4high

controls in range

Ease of change*

How easily the code can be understood and changed, from 0 to 10. Other things equal, less code is easier and cheaper to change, for people and for agents. Both ratings weigh the same sub-scores: people struggle most with complex logic and knowledge held by few; agents pay for every line they read, copy duplicates and need tests to check their work. The total is a weighted geometric mean; above the weakest code sub-score + 4 only half of it counts, so one weak spot is not averaged away. Sub-scores are ordered by drag, how much the uncapped mean would rise if that sub-score were 10; click one to see why it matters. * A heuristic: compare repositories rather than read it as absolute. Set weights, or your own framework, in analysis.maintainabilityScores.

Human2.9ABCDE

Measured on 6 of 10 sub-scores (not measured: Duplication, Change entropy, Context per change, Knowledge spread).

Volume0.0×1−1.522,372,333 lines of main code
For people: More code is more to learn, search and keep in mind; onboarding and judging a change's impact slow down as it grows.
For AI agents: An agent sees only a slice at a time: the bigger the code base, the more it searches, and the likelier it misses relevant code or rewrites an existing helper.
Tests presence1.0×0.75−0.80 test lines per 100 main lines
For people: A test suite documents the intended behaviour and makes changes safe. Counted is whether there is one of reasonable size, not its coverage.
For AI agents: Tests let an agent check its own work; without them its mistakes surface later, in review or in production.
Unit complexity4.8×2−0.716% of unit code with McCabe > 25
For people: Every branch is another path to understand and test; complex logic is where mistakes are made and missed in review.
For AI agents: Nested conditions are where generated changes break edge cases; complex units need more tests and review before an agent's change can be trusted.
Unit size4.3×1.5−0.631% of unit code in units > 50 lines
For people: Long functions do many things at once: they are hard to name, read, test and reuse.
For AI agents: To change one line, an agent reads and often rewrites the whole function: bigger edits, more tokens, more breakage.
File size3.6×0.75−0.339% of main code in files > 500 lines
For people: Large files are hard to navigate, mix responsibilities and attract merge conflicts.
For AI agents: Agents read whole files into their context: every change to a large file costs many tokens and crowds out other relevant code.
File complexity5.7×1−0.221% of main code in files with McCabe sum > 125
For people: Complex files concentrate risk: understanding one means keeping many paths in mind.
For AI agents: Much to read and much logic to get right in one place: the costliest combination for an agent.

AI2.5ABCDE

Measured on 6 of 9 sub-scores (not measured: Duplication, Change entropy, Context per change).

Tests presence1.0×1.5−1.60 test lines per 100 main lines
For AI agents: Tests let an agent check its own work; without them its mistakes surface later, in review or in production.
For people: A test suite documents the intended behaviour and makes changes safe. Counted is whether there is one of reasonable size, not its coverage.
Volume0.0×0.75−1.022,372,333 lines of main code
For AI agents: An agent sees only a slice at a time: the bigger the code base, the more it searches, and the likelier it misses relevant code or rewrites an existing helper.
For people: More code is more to learn, search and keep in mind; onboarding and judging a change's impact slow down as it grows.
File size3.6×1.75−0.739% of main code in files > 500 lines
For AI agents: Agents read whole files into their context: every change to a large file costs many tokens and crowds out other relevant code.
For people: Large files are hard to navigate, mix responsibilities and attract merge conflicts.
Unit size4.3×1−0.331% of unit code in units > 50 lines
For AI agents: To change one line, an agent reads and often rewrites the whole function: bigger edits, more tokens, more breakage.
For people: Long functions do many things at once: they are hard to name, read, test and reuse.
Unit complexity4.8×1−0.316% of unit code with McCabe > 25
For AI agents: Nested conditions are where generated changes break edge cases; complex units need more tests and review before an agent's change can be trusted.
For people: Every branch is another path to understand and test; complex logic is where mistakes are made and missed in review.
File complexity5.7×0.75−0.221% of main code in files with McCabe sum > 125
For AI agents: Much to read and much logic to get right in one place: the costliest combination for an agent.
For people: Complex files concentrate risk: understanding one means keeping many paths in mind.

Where to look first

The most complex main files (no git history, so no change frequency).

1
verify.py
preprints/Exact-Fourier-certificates-for-complex-Hadamard-matrices-of-order-six-September-24-2026/verification/
McCabe 251542 LOC
2
exact-source.py
preprints/The-critical-dimension-for-one-phase-Bernoulli-minimizers-September-24-2026/verification/checks/original/checks/
McCabe 239385 LOC
3
verify_parameters.py
preprints/Staggered-extraction-for-exact-matrix-multiplication-over-every-field-September-24-2026/verification/scripts/
McCabe 231472 LOC
4
appendix-a.cpp
preprints/Foulkes-Conjecture-for-the-Sixth-Symmetric-Power-September-25-2026/verification/programs/
McCabe 229699 LOC
5
check_certificate.py
preprints/An-atomic-certificate-for-triangular-lattice-universal-optimality-September-26-2026/verification/
McCabe 190364 LOC
6
numeric_balls.py
preprints/Universal-optimality-of-the-triangular-lattice-September-23-2026/verification/
McCabe 142277 LOC
7
independent_checker.py
preprints/Cycle-clique-Ramsey-numbers-September-25-2026/verification/code/
McCabe 132256 LOC
8
engine.py
preprints/The-critical-dimension-for-one-phase-Bernoulli-minimizers-September-24-2026/verification/independent-certificate/
McCabe 132301 LOC
9
exact_verifier.py
preprints/Stable-Self-Similar-Blowup-for-a-Supercritical-Defocusing-Schrodinger-Equation-on-the-Torus-September-24-2026/verification/certificates/
McCabe 130352 LOC
10
interval_certificate.py
preprints/A-sharp-Fourier-certificate-for-planar-circle-packing-September-23-2026/verification/
McCabe 129283 LOC

Explore all files →

Standard analyses:
		Main Code: 22,372,333 LOC (129381 files) = LEAN (88%) + TEX (11%) + BIB (<1%) + PY (<1%) + CPP (<1%) + YAML (<1%) + HPP (<1%) + JSONL (<1%) Secondary code: Test: 2,147 LOC (12); Generated: 0 LOC (0); Build & Deploy: 59 LOC (11); Other: 64,387 LOC (1275);
		File Size: 19% long (>1000 LOC), 38% short (<= 200 LOC)
		Logical Component Decomposition: primary (3 components)
		Goals: Keep the system simple and easy to change (4)

Experimental analyses (less reliable heuristic analyses):
		Unit Size: 11% long (>100 LOC), 39% short (<= 10 LOC)
		Conditional Complexity: 15% complex (McCabe index > 50), 33% simple (McCabe index <= 5)
		Static Component Dependencies: primary (3 components)