openai/ten-proofs

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*

3.1ABCDE

for people · measured on 4 of 10 sub-scores

Ease of change*

2.1ABCDE

for AI · measured on 4 of 9 sub-scores

Duplication

8%watch

of main code duplicated

Large files

66%high

of main code in files > 500 lines

Goals

2 / 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.

Human3.1ABCDE

Measured on 4 of 10 sub-scores (not measured: Unit size, Unit complexity, File complexity, Change entropy, Context per change, Knowledge spread).

File size0.7×0.75−2.466% 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.
Tests presence1.0×0.75−2.0no test code
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.
Duplication6.9×1−0.38% of main code duplicated
For people: A fix in one copy must be repeated in all the others; a missed copy becomes a bug.
For AI agents: Agents copy the patterns they find, so duplicates multiply; a change to one copy misses the others, and every copy costs context.
Volume9.6×14,377 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.

AI2.1ABCDE

Measured on 4 of 9 sub-scores (not measured: Unit size, Unit complexity, File complexity, Change entropy, Context per change).

File size0.7×1.75−2.766% 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.
Tests presence1.0×1.5−1.8no test code
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.
Duplication6.9×1.5−0.28% of main code duplicated
For AI agents: Agents copy the patterns they find, so duplicates multiply; a change to one copy misses the others, and every copy costs context.
For people: A fix in one copy must be repeated in all the others; a missed copy becomes a bug.
Volume9.6×0.754,377 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.

Where to look first

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

1
MulticolorTriangleRamsey.lean
2,909 LOC
2
H_GapCVP.lean
ComparatorChallenges/
258 LOC
3
B_SphericalCodes.lean
ComparatorChallenges/
215 LOC
4
E_ConnesRigidity.lean
ComparatorChallenges/
183 LOC
5
A_SpherePacking.lean
ComparatorChallenges/
149 LOC
6
B_BinaryCodes.lean
ComparatorChallenges/
142 LOC
7
G_QuantumParallelRepetition.lean
ComparatorChallenges/
111 LOC
8
C_PermanentFormulaLowerBound.lean
ComparatorChallenges/
83 LOC
9
J_CompactnessConjecture.lean
ComparatorChallenges/
73 LOC
10
lakefile.toml
62 LOC

Explore all files →

Standard analyses:
		Main Code: 4,377 LOC (16 files) = LEAN (98%) + TOML (1%) + YAML (<1%) Secondary code: Test: 0 LOC (0); Generated: 0 LOC (0); Build & Deploy: 2 LOC (1); Other: 376 LOC (15);
		Duplication: 7%
		File Size: 66% long (>1000 LOC), 22% short (<= 200 LOC)
		Logical Component Decomposition: primary (2 components)
		Goals: Keep the system simple and easy to change (4)

Experimental analyses (less reliable heuristic analyses):
		Static Component Dependencies: primary (2 components)