anthropics/uplifting-biomolecular-modeling

GitHub

726K

lines of main code

3.6K files

240K

lines of test code

1.7K files

126K

lines of other code

1.1K files

ABCDE

ease of change
for people* (7/10)

ABCDE

ease of change
for AI* (7/9)

688K

py

12K

cu

9.8K

cuh

PT

5.8K

pt

5.6K

cc

1.9K

h

1.8K

yaml

0.6K

cpp

0.5K

toml

PYI

0.2K

pyi

IN

0.03K

in

Rule-of-thumb estimates

Rebuild value

lines of main code per man-year per man-year currency

to rebuild

rebuild value

Maintenance effort

% of the rebuild value per year

per year to maintain

maintenance cost per year

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.8ABCDE

for people · measured on 7 of 10 sub-scores

Ease of change*

3.2ABCDE

for AI · measured on 7 of 9 sub-scores

Duplication

39%high

of main code duplicated

Complex units

9%watch

of unit code with McCabe > 25

Long units

20%watch

of unit code in units > 50 lines

Large files

40%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.

Human3.8ABCDE

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

Duplication0.1−1.739% 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.
Volume3.0−0.6726,274 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.
Unit size6.0−0.420% 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.
Unit complexity6.7−0.49% 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.
File size3.4−0.440% 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 complexity4.7−0.427% 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.
Test code6.3−0.233 test lines per 100 main lines
For people: Tests document the intended behaviour and make changes safe.
For AI agents: Tests let an agent check its own work; without them its mistakes surface later, in review or in production.

AI3.2ABCDE

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

Duplication0.1−2.339% 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.
File size3.4−0.840% 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.
Volume3.0−0.4726,274 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.
Test code6.3−0.333 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: Tests document the intended behaviour and make changes safe.
Unit size6.0−0.220% 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 complexity6.7−0.29% 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 complexity4.7−0.227% 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
__init__.py
common/opt_core/opt_core/kernels/trimul/
McCabe 1,0001,699 LOC
2
__init__.py
common/opt_core/opt_core/kernels/apb/
McCabe 7481,406 LOC
3
__init__.py
common/opt_core/opt_core/kernels/transition/
McCabe 7021,448 LOC
4
typing_extensions.py
chrombpnet/opt/kit/torch/chrombpnet_k1/_vendor/
McCabe 6872,610 LOC
5
stack.py
boltz2/opt/boltz2_opt/
McCabe 6271,047 LOC
6
dist.py
common/opt_core/opt_core/mem/rowpair/
McCabe 6011,424 LOC
7
stack.py
esmfold2/opt/esmfold2_opt/
McCabe 5911,192 LOC
8
modes.py
af3_jax/opt/af3_jax_opt/
McCabe 573843 LOC
9
pair_fused.py
common/opt_core/opt_core/attn/
McCabe 5671,272 LOC
10
__init__.py
common/opt_core/opt_core/kernels/ln/
McCabe 506783 LOC

Explore all files →

Standard analyses:
		Main Code: 726,274 LOC (3636 files) = PY (94%) + CU (1%) + CUH (1%) + PT (<1%) + CC (<1%) + H (<1%) + YAML (<1%) + CPP (<1%) + TOML (<1%) + PYI (<1%) + IN (<1%) Secondary code: Test: 240,456 LOC (1731); Generated: 0 LOC (0); Build & Deploy: 10,976 LOC (173); Other: 114,970 LOC (942);
		Duplication: 39%
		File Size: 17% long (>1000 LOC), 25% short (<= 200 LOC)
		Logical Component Decomposition: primary (37 components)
		Goals: Keep the system simple and easy to change (4)

Experimental analyses (less reliable heuristic analyses):
		Unit Size: 7% long (>100 LOC), 50% short (<= 10 LOC)
		Conditional Complexity: 9% complex (McCabe index > 50), 47% simple (McCabe index <= 5)
		Static Component Dependencies: primary (37 components)