openai/orion-multistep-analysis

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*

6.5ABCDE

for people · measured on 7 of 10 sub-scores

Ease of change*

5.8ABCDE

for AI · measured on 7 of 9 sub-scores

Duplication

4%good

of main code duplicated

Complex units

9%watch

of unit code with McCabe > 25

Long units

15%watch

of unit code in units > 50 lines

Large files

39%high

of main code in files > 500 lines

Goals

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

Human6.5ABCDE

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

Unit complexity6.8×2−0.79% 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.7×0.75−0.639% 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.8×1−0.521% 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.
Tests presence4.4×0.75−0.56 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 size7.0×1.5−0.415% 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.
Volume9.3×1−0.17,495 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.
Duplication8.4×1−0.14% 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.

AI5.8ABCDE

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

File size3.7×1.75−1.439% 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 presence4.4×1.5−0.96 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.
Unit size7.0×1−0.315% 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.8×1−0.39% 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.8×0.75−0.321% 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.
Duplication8.4×1.5−0.24% 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.3×0.757,495 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
RunDetailPage.tsx
frontend/src/pages/
McCabe 2231,295 LOC
2
orchestrator.py
src/research_agent/supervisor/
McCabe 87556 LOC
3
web_reporter.py
src/research_agent/reporters/
McCabe 84385 LOC
4
jobs.py
src/research_agent/backend/
McCabe 83418 LOC
5
__init__.py
src/research_agent/tools/
McCabe 76257 LOC
6
csv_importer.py
src/research_agent/backend/services/
McCabe 53201 LOC
7
runtime.py
src/research_agent/agents/
McCabe 42290 LOC
8
prompts.py
src/research_agent/backend/
McCabe 36201 LOC
9
runs.py
src/research_agent/backend/routes/
McCabe 34197 LOC
10
streams.py
src/research_agent/backend/
McCabe 2488 LOC

Explore all files →

Standard analyses:
		Main Code: 7,495 LOC (63 files) = PY (44%) + TSX (34%) + CSS (14%) + TS (6%) + HTML (<1%) + YAML (<1%) Secondary code: Test: 479 LOC (10); Generated: 3,907 LOC (1); Build & Deploy: 170 LOC (5); Other: 4,115 LOC (8);
		Duplication: 4%
		File Size: 31% long (>1000 LOC), 21% short (<= 200 LOC)
		Logical Component Decomposition: primary (4 components)
		Goals: Keep the system simple and easy to change (4)

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