ImageSupercov

Code quality and coverage for coding agents

Measure code quality with npx supercov.

ImageStar on GitHub

How Supercov works

Supercov scores code quality with Jev and gives coding agents the deepest Image JavaScript coverage for code verification, including MC/DC and assertion coverage.

Read more
CodexClaude CodeCursorGemini CLIGitHub Copilot
ImageCodexImageClaude CodeImageCursorImageGemini CLIImageGitHub Copilot
Improve code quality and coverage•••

Working

Supercov gives the agent the next thing to fix.

Each run returns the quality score and the uncovered paths. The agent refactors or adds focused tests, reruns the suite, and continues while useful work remains.

Code quality

Scoring src/session.js answers twelve property checks and returns 8.4 of 10, a good band. Only primitive obsession is present, at 0.60. Each check is a judgment you can verify against the file, and the score is arithmetic over those checks.

Read more

Code quality, scored by Jev.

One command scores your source and ranks the weakest files, so your agent knows what to refactor before it writes anything.

Coverage agents can act on.

File-by-file coverage, uncovered paths, and assertion gaps—so your agent knows what to test next.

Assertion coverage

Recorded execution shows the total calculation ran in the passing test. The agent traces order.status to its assertion, but finds no assertion for order.total. For two items at $25, it adds expect(order.total).toBe(50). A wrong total now fails this test. Finding the gap does not require executing mutated code.

Read more

Find missing assertions without mutation testing.

Your agent traces what tests check using recorded execution evidence. No mutants to generate or execute.

Supported byImageSupercorp
Image

3.4kGitHub stars↗

npm downloads

200k+weekly downloads

Supported by Supercorp.

Backed by Supercorp’s open-source track record.

  • ImageRSpec
  • ImageMinitest
  • ImageJest
  • ImageMocha
  • ImageVitest
  • ImageVitest Browser Mode
  • Imagepytest
  • ImagePlaywright
  • Imagenode:test
  • ImageAVA
  • Imagecargo test
  • Imagecargo-nextest
  • Imageunittest
  • ImageCucumber
  • Imagetest-unit
  • Imagerustdoc
  • Imagego test
  • ImageJUnit 5
  • ImageTestNG
  • ImageKotest
  • ImageSpock

Supported test suites.

Playwright, Vitest, Jest, Cargo, pytest, RSpec, go test, JUnit, and more.

Use leftover tokens on coverage.

Before a reset—or overnight—turn idle agent time into coverage that stays with the repository.

For software factories.

Every pass returns fresh, executable evidence, so agents can keep iterating around the clock while regressions are caught before they ship.

Low overhead.

Fast instrumentation keeps the test loop moving.

Any language.

JavaScript, TypeScript, Rust, Python, Ruby, Go, Java, and Kotlin—with more to come.

Any agent.

Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot—and more.

View on GitHub

Free and open source.

MIT licensed. Inspect, extend, and run it anywhere.

How Supercov compares.

JavaScript & TypeScript

Coverage features for JavaScript & TypeScript
FeatureImageSupercovVitestnyc / Istanbulc8
Code quality scoringSupportedNot built inNot built inNot built in
Line coverageSupportedSupportedSupportedSupported
Branch coverageSupportedSupportedSupportedSupported
MC/DCSupportedNot built inNot built inNot built in
Per-test coverageSupportedNot built inNot built inNot built in
Assertion coverageSupportedNot built inNot built inNot built in
Sources and notes September 18, 2026
  • Vitest uses its standard V8 or Istanbul coverage provider here. Supercov works with your existing test runner.
  • Per-test coverage means individual tests, not test files. Supercov needs a supported runner; concurrency can limit attribution.
  • Assertion coverage links source to passing assertions through an agent-reviewed map. It is not a mutation score or proof of correctness.
  • Code quality scoring means a per-file score of the source itself, from named property checks answered by Jev. The tools compared here report coverage; linters and dedicated quality platforms are outside this table.

Python

Coverage features for Python
FeatureImageSupercovcoverage.pySlipCover
Code quality scoringSupportedNot built inNot built in
Line coverageSupportedSupportedSupported
Branch coverageSupportedSupportedSupported
MC/DCSupportedNot built inNot built in
Per-test coverageSupportedSupportedNot built in
Assertion coverageSupportedNot built inNot built in
Sources and notes September 18, 2026
  • Supercov requires CPython 3.12+ for full coverage. pytest-cov uses coverage.py; enable test contexts for per-test coverage.
  • Per-test coverage means individual tests, not test files. Supercov needs a supported runner; concurrency can limit attribution.
  • Assertion coverage links source to passing assertions through an agent-reviewed map. It is not a mutation score or proof of correctness.
  • Code quality scoring means a per-file score of the source itself, from named property checks answered by Jev. The tools compared here report coverage; linters and dedicated quality platforms are outside this table.

Ruby

Coverage features for Ruby
FeatureImageSupercovSimpleCov
Code quality scoringSupportedNot built in
Line coverageSupportedSupported
Branch coverageSupportedSupported
MC/DCSupportedNot built in
Per-test coverageSupportedSupported
Assertion coverageSupportedNot built in
Sources and notes September 18, 2026
  • Supercov supports MRI Ruby: full MC/DC on 3.4+, limited measurement on 3.3. SimpleCov 1.3 requires Ruby 3.3+.
  • SimpleCov’s per-test coverage requires track_tests. Neither tool promises exact per-test coverage for overlapping threaded tests.
  • Per-test coverage means individual tests, not test files. Supercov needs a supported runner; concurrency can limit attribution.
  • Assertion coverage links source to passing assertions through an agent-reviewed map. It is not a mutation score or proof of correctness.
  • Code quality scoring means a per-file score of the source itself, from named property checks answered by Jev. The tools compared here report coverage; linters and dedicated quality platforms are outside this table.

Rust

Coverage features for Rust
FeatureImageSupercovcargo-llvm-covTarpaulin
Code quality scoringSupportedNot built inNot built in
Line coverageSupportedSupportedSupported
Branch coverageSupportedSupportedNot built in
MC/DCSupportedSupportedNot built in
Per-test coverageSupportedNot built inNot built in
Assertion coverageSupportedNot built inNot built in
Sources and notes September 18, 2026
  • Supercov requires Rust 1.95 and supported Cargo runners. cargo-llvm-cov’s branch and MC/DC flags require nightly. Tarpaulin’s branch option is not implemented.
  • Per-test coverage means individual tests, not test files. Supercov needs a supported runner; concurrency can limit attribution.
  • Assertion coverage links source to passing assertions through an agent-reviewed map. It is not a mutation score or proof of correctness.
  • Code quality scoring means a per-file score of the source itself, from named property checks answered by Jev. The tools compared here report coverage; linters and dedicated quality platforms are outside this table.

Go

Coverage features for Go
FeatureImageSupercovgo test -cover
Code quality scoringSupportedNot built in
Line coverageSupportedSupported
Branch coverageSupportedNot built in
MC/DCSupportedNot built in
Per-test coverageSupportedNot built in
Assertion coverageSupportedNot built in
Sources and notes September 18, 2026
  • Supercov requires Go 1.22 or newer and runs your own `go test` command against an instrumented copy of the module.
  • The Go toolchain counts statements per run. A test that calls t.Parallel() shares one counter array with the tests beside it, so Supercov counts that coverage run-wide rather than naming a test for it.
  • Per-test coverage means individual tests, not test files. Supercov needs a supported runner; concurrency can limit attribution.
  • Assertion coverage links source to passing assertions through an agent-reviewed map. It is not a mutation score or proof of correctness.
  • Code quality scoring means a per-file score of the source itself, from named property checks answered by Jev. The tools compared here report coverage; linters and dedicated quality platforms are outside this table.

Java

Coverage features for Java
FeatureImageSupercovJaCoCoOpenClover
Code quality scoringSupportedNot built inNot built in
Line coverageSupportedSupportedSupported
Branch coverageSupportedSupportedSupported
MC/DCSupportedNot built inNot built in
Per-test coverageSupportedNot built inSupported
Assertion coverageSupportedNot built inNot built in
Sources and notes September 18, 2026
  • Supercov requires JDK 17 or newer with Maven or Gradle, and measures JUnit 5, JUnit 4 through Vintage, TestNG, Kotest and Spock per test, instrumenting an isolated copy rather than your build file. If tests still run concurrently it says so and drops condition coverage instead of guessing.
  • JaCoCo counts branches from bytecode and reports per run, not per test. OpenClover records per-test coverage from source instrumentation; neither computes MC/DC.
  • Per-test coverage means individual tests, not test files. Supercov needs a supported runner; concurrency can limit attribution.
  • Assertion coverage links source to passing assertions through an agent-reviewed map. It is not a mutation score or proof of correctness.
  • Code quality scoring means a per-file score of the source itself, from named property checks answered by Jev. The tools compared here report coverage; linters and dedicated quality platforms are outside this table.

Kotlin

Coverage features for Kotlin
FeatureImageSupercovKoverJaCoCo
Code quality scoringSupportedNot built inNot built in
Line coverageSupportedSupportedSupported
Branch coverageSupportedSupportedSupported
MC/DCSupportedNot built inNot built in
Per-test coverageSupportedNot built inNot built in
Assertion coverageSupportedNot built inNot built in
Sources and notes September 18, 2026
  • Supercov measures Kotlin through the same JVM path as Java, taking test identity from the framework’s own lifecycle, so Kotest and Spock tests keep the names they report. A condition that also narrows a type carries no MC/DC obligation, and the run names every such case.
  • Kover wraps JaCoCo’s engine for Kotlin and Android projects. Both report line and branch coverage per run; neither computes MC/DC or per-test coverage.
  • Per-test coverage means individual tests, not test files. Supercov needs a supported runner; concurrency can limit attribution.
  • Assertion coverage links source to passing assertions through an agent-reviewed map. It is not a mutation score or proof of correctness.
  • Code quality scoring means a per-file score of the source itself, from named property checks answered by Jev. The tools compared here report coverage; linters and dedicated quality platforms are outside this table.

Built-in coverage reports, unless noted. Read the comparisons