Language-agnostic, LLM-native code analysis

The garbage collector
for your project.

Coding agents ship fast but leave debris behind — dead code, stale comments, outdated docs. Each iteration adds more, and your agents waste reasoning effort working around it instead of doing useful work. osojicode finds the cruft, measures it, and gives your agents a clean path to fix it.

Install the CLI See how it works

The problem

Agents can't tell fresh from stale. A comment written eighteen months ago gets the same confidence as one written yesterday. The cruft accumulates silently until your agents are spending more effort reasoning around debris than doing useful work.

Junk code

Dead symbols, unreachable paths, commented-out blocks. Code that serves no purpose but still gets parsed, interpreted, and reasoned about.

Stale documentation

Docs that were accurate when written but drifted as the code evolved. Wrong version numbers, missing features, outdated examples.

Misleading comments

"Phase 2 placeholder" on a fully implemented function. "Only Python supported" when four languages work. Every one a trap an agent walks into.

How it works

osojicode audits your project, quantifies the debris, and produces structured findings your agents can act on.

LLM-native analysis, not static rules

osojicode doesn't wrap linters or parse ASTs. It reads your code the way an agent does — semantically, across any language, without per-language configuration. That's how it catches things rule-based tools can't: a comment that contradicts the function it describes, a doc that claims only Python is supported when four languages work, a TODO for work that was finished months ago.

Audit

Shadow documentation is generated for every source file — a cited, factual account of what the code actually does. Existing docs are checked against this ground truth.

Measure

A scorecard quantifies what it finds: documentation coverage, accuracy errors, junk code fraction, stale content. Numbers, not opinions.

Clean

Structured findings feed directly into your coding agent's workflow. osojicode diagnoses, your agent fixes. Run it again until clean.

Numbers, not opinions

Every audit produces a scorecard. Track your project's health over time. Know exactly what to fix and measure the impact of fixing it.

Audit scorecard — mcp-debugger

Documentation coverage 81%

Accuracy errors / live doc 0.07

Junk code fraction 1.2%

Dead symbols 60

Stale comments 11

Dead documentation 3

Unactuated config fields 9

Total junk lines 1,086 across 32 files

Why it matters

Clean codebases are easier to maintain and cheaper to work with — for humans and agents alike.

Less wasted reasoning

Every contradiction an agent has to reason around costs tokens and risks wrong answers. Remove the contradictions and the reasoning gets simpler, faster, cheaper.

Cheaper models, same results

A clean codebase may let a cheaper model accomplish what currently takes an expensive one. The cost of the audit pays for itself in the model tier it lets you drop to.

Fewer broken iterations

Agents degrade across iterations partly because accumulated cruft compounds misunderstanding. Keeping the codebase clean extends how many pivots an agent can handle before breaking.

Maintainability for everyone

Clean code isn't just an agent concern. Humans onboard faster, reviews go smoother, and the next contributor — human or AI — inherits a codebase that tells the truth.

Run it like you run your tests

osojicode fits into the workflow you already have. CLI for local use, git hooks for ongoing maintenance, CI integration for teams.

The mess doesn't come back if you don't let it.

# Full audit of the project

$ osoji audit

Generating shadow docs...

Analyzing 437 source files

Checking documentation accuracy

Detecting junk code

✓ Coverage: 81%

⚠ Junk code: 1,086 lines in 32 files

⚠ 9 errors, 171 warnings

Report: .osoji/audit-report.md

# Feed findings to your agent

$ osoji audit --findings | claude-code

# Check again after cleanup