Private beta

Give your codebase a fitness grade. Then coach it to an A.

BenchFit scores your repo A+ to F across six dimensions of code fitness, architecture gates, and Big Ball of Mud risk. Scan on your machine or in the cloud — then loop with your AI agent until the grade climbs.

They review. We measure. Same code, same score, every run. A review is an opinion; a fitness function is a time series.

Start scanning Join the beta → See the workflow

Go, Rust, TypeScript, Python, Java, Kotlin, Swift, C/C++ & C# — plus experimental PHP. No config. Your source is never retained in the cloud.

The scale
A+AB+ BC+C DF
Go Rust TypeScript Python Java Kotlin Swift C/C++ C# PHP exp
The workflow

From first scan to a grade you enforce

Five steps, one tight loop: know where you stand in five minutes, always know the next fix worth making, watch the trend prove your work, and make the bar unskippable in CI.

01GET A KEY, THEN INSTALL

Start free: one key, two commands

Five minutes from here to your first grade. The BenchFit CLI carries the scoring engine, so it is issued per account rather than published openly — request a free Community key, install with it, then benchfit login ties the CLI to your GitHub handle.

# 1 · request a free Community key
→ bench.fit/waitlist
$ curl -fsSL https://bench.fit/install.sh | BENCHFIT_KEY=bf_live_… sh
$ benchfit login
# opens a browser · authorize with GitHub · key stored locally
Free during the beta. Keys are per developer, tied to your GitHub handle, and revocable. macOS and Linux supported.
02SCAN

Know where you stand

One command answers the question your gut keeps dodging: how fit is this codebase, really? Run benchfit for a local scan, or add -cloud to score server-side. Either way you get a grade, a score, the six dimension bars, and gate status — no configuration required.

$ cd your-repo && benchfit -cloud
benchfit -cloud
  Packaging your-repo for cloud scan…
  Uploading 98 files (1.2 MB compressed) to bench.fit…

BenchFit Code & Architecture Platform
=====================================

  Grade: B+      Score: 80.6/100     BBoM: 18 healthy

  Scanned 98 files across 24 packages in 8.2s

Dimensions
------------------------------------------------------------
  R  Readability       94.2/100    ######################--
  C  Changeability     79.1/100    ##################------
  O  Operational       72.5/100    #################-------
  D  Dependency        69.5/100    ################--------
  T  Test Quality      72.4/100    #################-------
  X  Change Risk       58.9/100    ##############----------

Gates (32 checked)
------------------------------------------------------------
  32 passed, 0 failed
03IMPROVE

Always know the one next thing worth doing

This is where the grade actually moves. Ask benchfit next for the single highest-priority fix, hand it to your coding agent, let it make the change, then re-scan. BLOCKING gates come first, then WARNING gates, then the weakest dimension metrics.

$ benchfit next
# the one fix that moves your grade the most, right now

Drop this CLAUDE.md snippet in your repo and your agent knows the loop without being told each time:

CLAUDE.md
## Code fitness with BenchFit

This repo is graded by BenchFit. Target grade: A- or better.

When you finish a change, or when I ask you to improve code fitness:

1. Run `benchfit -format=json` (add `-cloud` to score server-side) for the
   grade, score, six dimension scores (R C O D T X), and gate results.
2. Run `benchfit next -json` for the single highest-priority recommendation
   (`--all` for the full prioritized list, `--dimension <R|C|O|D|T|X>` to
   focus). BLOCKING gates rank first, then WARNING gates, then weak metrics.
3. If a recommendation is unclear, run `benchfit explain last` (or
   `benchfit explain <ID>`) for what it measures, why it matters, and how to
   fix it — the guidance ships in the CLI, so `explain` works offline.
4. Make the smallest change that addresses it. Re-scan, confirm the score
   improved and no gate regressed, and repeat until the target grade.
5. If a recommendation is genuinely wrong for this repo, do not disable
   gates or exclude files: `benchfit snooze <ID>` mutes it for 7 days
   (advisory-only — scores, gates, and exit codes are never affected), and
   `benchfit quibble <ID> -m "why"` reports the false positive upstream.

Exit codes: 0 ok; 1 threshold tripped (-strict / -min-score / -min-grade); 2 error.
Never disable a gate or exclude files to raise the score — fix the cause.

Or skip the snippet entirely — BenchFit is an MCP server, so your agent can call the whole loop as native tools (scan, next, explain, quibble):

$ claude mcp add benchfit -- benchfit mcp
# your agent now scans, plans, and files feedback on its own

For the vibe coder: your AI writes the code — BenchFit tells you both the truth about it. One command, a grade in your terminal.

Worth learning — the commands you'll reach for most:

benchfitLocal scan of the current directory
benchfit -cloudScore server-side via the cloud API
benchfit nextThe single highest-priority recommendation
benchfit next --dimension RPrioritized fixes for one dimension
benchfit next -jsonMachine-readable recommendation for agents
benchfit explain <ID|last>What a gate/metric means, why it matters, how to fix it
benchfit mcpServe the loop to coding agents over MCP
benchfit webOpen your BenchFit dashboard (all your projects) in a browser
benchfit -cloud -strictFail on blocking architecture gates
04WATCH

Watch the trend prove your work

A single scan is a data point; the dashboard is the evidence. benchfit web opens every project — grade over time, current gate status, and where the score is heading. Good for standups, better for the moment someone asks whether the refactor was worth it.

$ benchfit web
# opens your score dashboard
05ENFORCE

Make the bar unskippable

A bar nobody can skip is the only bar that holds. Set a floor and CI fails the build when the repo drops below it: -strict fails on blocking architecture gates; -min-grade and -min-score fail below a threshold you choose. Store your key as the repo secret BENCHFIT_KEY.

.github/workflows/fitness.yml
name: code-fitness
on:
  pull_request:
  push:
    branches: [main]

jobs:
  benchfit:
    runs-on: ubuntu-latest
    env:
      BENCHFIT_KEY: ${{ secrets.BENCHFIT_KEY }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: stable
      - name: Install BenchFit
        run: curl -fsSL https://bench.fit/install.sh | sh
      - name: Grade code fitness
        run: benchfit -cloud -strict -min-grade=B

For the engineering lead: a fitness grade for every repo, a floor you enforce in CI, and a portfolio trend your VP can read.

What's measured

Six dimensions, weighted by what matters in production

Every score answers one question: will this code survive production? Six dimensions, weighted so that code which can't be operated, tested, or changed safely doesn't get to be elegant.

R

Readability

Function length, cyclomatic complexity, naming, nesting, documentation, dead code.

C

Changeability

Cohesion, coupling, abstraction, API stability, value objects, connascence.

O

Operational

Error handling, logging, health checks, graceful shutdown, resilience, rollback readiness.

D

Dependency

Freshness, vulnerabilities, obsolescence, vendor abstraction, DevSecOps pipeline.

T

Test Quality

MC/DC condition coverage, isolation, assertion density, edge cases, contract tests.

X

Change Risk

Commit size, hotspots, knowledge distribution, breaking-change detection.

Blocking gates

Hard structural limits

Circular dependencies, data-ownership violations, error leakage. A blocking failure forces the grade to F, no matter the score.

Warning gates

One step down each

God files, missing tests, temporal coupling. Each warning failure steps the grade down by one — visible, not fatal.

BBoM risk

Big Ball of Mud score

A single number for structural entropy — healthy, at-risk, or mud — so you can catch a codebase sliding before it's stuck.

How your code is handled

Cloud scanning without the trust tax

Your source, handled carefully

In cloud mode the CLI uploads a filtered copy of your source and nothing more.

  • Dotfiles, secrets, and dependency & build directories are excluded before anything leaves your machine.
  • Your .git never leaves — git statistics are computed locally and only aggregates are sent.
  • The server deletes your source the moment scoring finishes. It keeps your report card — scores, gates, and the file paths of findings, visible only to you — never your source.
  • Reports are stored under a pseudonymous account id, and Delete my data in your dashboard removes every report, score, and share link on demand. Questions: privacy@bench.fit.

Instrumented end to end

Observability isn't an afterthought here — it's a value we hold ourselves to.

  • The cloud service is traced end to end with OpenTelemetry — every scan is a span you could follow.
  • The same operational rigor BenchFit grades your code for, applied to BenchFit itself.
  • Live at bench.fit.

The grader that caught itself cheating

BenchFit grades its own codebase with the same engine you get — and publishes the result to its members, climb and stumbles included.

  • When our own Go module quietly flattered the repo it was built in, we deleted the exemptions, bumped the scoring epoch, and took the honest F. We fixed the grader, not the grade.
  • Every point since has been earned in the open — the climb back is a ledger, not a press release.
  • Read the self-grade ledger → — it ships with the product, from the Vibe plan up.
Invites

Growth is earned

BenchFit spreads by invitation, and invitations are earned, not sprayed. Every member is here because someone's referral actually ran the tool.

01 · Invite

Start with a few codes

Every account begins with a small invite allowance. Unused codes expire — scarcity is the point, not a bug.

02 · They scan

A referral counts when it runs

An invite converts when your invitee runs a real scan. Signups alone earn nothing — no spray-and-pray.

03 · Earn more

Invites unlock as your network scans

Your allowance grows with every referral who genuinely uses the tool. If the product weren't worth running, this loop would starve — that's the bet.

Plans

Three ways in

Free with a public profile, paid with anonymity, or Enterprise for companies. Every plan gets the full grading engine — plans differ in identity, rate limits, and support.

Community Free forever

Prove your improvement, free forever. The price of free: your handle is your public profile, and your scans' anonymized aggregates help set the community bar. Your scores stay private until you choose to share them.

  • Local and cloud scanning across Go, Rust, TypeScript, Python, Java, Kotlin, Swift, C/C++ & C# — plus experimental PHP
  • All six dimensions, architecture gates, BBoM risk, dashboards & CI enforcement
  • Shareable score links — your public scorecard, when you want one
  • Low-cost add-ons (scorecard galleries, design input) — early access by email
Get started

No key yet? Join the beta →

Vibe Beta — pricing at launch

Your grades stay yours alone. A handle of your choosing, no public profile — plus the headroom to scan as often as your loop demands.

  • Everything in Community, without the public handle
  • Vibe → Vibe Pro → Vibe Monitor: rising scan rates & repo budgets
  • Vibe Monitor: headroom to scan every repo on every push from CI — your dashboard tracks the trend
  • Self-serve checkout is almost here — until it arms, switching plans is one email away
Upgrade to Vibe
Enterprise From $45K/yr

Win the argument with data: the trend line, the regression, the evidence your VP can read — not a vibe. All commercial and corporate use requires Enterprise; using a personal plan at work violates the terms of use.

  • $45K/yr — site license, onboarding, priority limits
  • $125K/yr — scales with use, same as every plan here
  • Call us — custom: on-prem/self-hosted, compliance packs, deep roadmap collaboration
  • Enterprise accounts stay Enterprise — pair one with a personal account on the same email
Talk to us

Terms in one line: individuals scan free (Community) or paid-and-anonymous (Vibe); any use by or for a company requires an Enterprise plan. Rate limits apply on every plan so the service stays fast for everyone. Full Terms of Service and Privacy Policy.

Roadmap

Where BenchFit is headed

AI writes code faster than ever — but architecture degrades silently while every dashboard shows green. BenchFit is the bar, made explicit. Here's the direction.

Shipped

The fitness engine

  • Go, Rust, TypeScript, Python, Java, Kotlin, Swift, C/C++ & C# — plus experimental PHP — one grade across your monorepo
  • Cloud scanning, GitHub sign-in, per-repo dashboards & portfolio rollup
  • CI enforcement gates & OpenTelemetry-grade observability
Next

Breadth & the agent loop

  • More languages — the rest of the top ten; C++ and C# graduate from experimental
  • A native agent interface, so your AI drives the fix loop directly
  • Enterprise self-host, SSO & compliance packs for regulated teams
The horizon

The OS for AI-assisted engineering

A fitness grade every team — and every AI agent — optimizes toward, as fundamental to shipping software as CI/CD. The bar must be explicit, or there is no bar at all.

Get started

Grade your codebase in the next five minutes

Sign up from the terminal, run one scan, and see where your repo stands. Then start closing the gap to an A.

$ benchfit login && benchfit -cloud
Get started Re-read the workflow