Phase 2 · coming next

An AI agent on
every pull request.

Robit reads the diff, test results, changed-file coverage, and the plain Markdown scenarios in .robit/. It explains failures, ranks gaps, drafts the test plan, and leaves the final call on what ships to your reviewers.

Start freenpm i @robit-one/reporter

Live todayCoverage reporting and the dashboard.NextThe pull request agent.

Phase 2 previewillustrative pull request
robit reviewed #2418Allow partial refunds on shipped orders
09:16
416 / 418 testschanged files 42%project 71%

Why it failed

services/refund.ts:88 now returns closed after a partial capture. Two refund tests still expect shipped.

Top gap

services/refund.ts:88–104core42%

Test plan · from .robit/specs/Checkout.md

  • Partial refund on a shipped order keeps status shipped.core
  • Refund total never exceeds the captured amount.core
  • Receipt email renders the correct currency symbol.
Spec driftspecs/Checkout.md step 4 may no longer be accurate.
Awaiting reviewer

The product line

AI writes code fast. Robit runs the whole Product Factory.

01

Start from any request

A transcript, a ticket, a sketch, a half-formed idea. Robit refines whatever you have into an implementation-ready spec.

02

Spec to tested PR

A ready spec becomes a pull request, built and tested against a coverage goal before it opens.

03

Verified out

Every PR is checked against your tests and knowledge. A person signs off, and verified behavior becomes your source of truth.

The standard

100% coverage isn't a goal. It's the gate.

When tests cost almost nothing, "good enough" stops being a tradeoff. It's a choice not to look. We believe every pull request should meet 100%, and that every exception should be written down, with a name on it. That's the standard Robit is built toward.

90% is good enough

10% of a 10k-line service is 1,000 lines running in production with no verification. Name which 1,000.

Tests are too expensive to write

Not anymore. An agent writes them as fast as the code. Incident response is the expensive part.

Phase 2 · how the agent decides

Your repo is the spec.

Plain Markdown scenarios in .robit/ sit beside the code. On every pull request the agent reads them with the evidence your CI already produces, and hands a person the decision.

Evidence in

  • Pull request diffWhat changed, file by file
  • Test resultstodayWhat ran, what failed, how long
  • Changed-file coveragetodayWhich changed lines never ran
  • .robit/ scenariosnextWhat the product must do

Robit review

Reads the change against the specExplains, ranks, prompts, plans, and flags drift. Proposes; never merges.
.robit/
  robit.md          # guide + scope
  specs/
    Checkout.md
    Refunds.md

Human decision

A reviewer approves the plan and chooses what shipsOnly steps a person promotes become part of .robit/.

No .robit/ folder yet? The agent still runs on the diff, tests, and coverage. The spec grows as reviewers promote steps.

One agent · six outputs

Understand

What happened in this pull request?

Failure explanations

Each failing test explained in plain language against the code that changed.

Coverage gap list

Changed files ranked by severity, linked to the uncovered lines and functions.

Act

What should the reviewer do next?

Fix prompts

A scoped prompt per gap, ready to paste into Claude Code, Codex, or Cursor.

Manual test plan

A checklist built from the diff and your .robit/ scenarios. Reviewers edit it.

Learn

What should the repository remember?

Spec drift warnings

Scenarios in .robit/ that this change may have made inaccurate.

Automation candidates

Manual steps with no matching end-to-end test, ordered by value.

One pull request · #2418 · 09:14 → 09:44

From diff to a human decision.

  1. 01Available today

    Evidence arrives

    The reporter sends results and coverage from the CI you already run. The project average looks healthy. The lines this pull request changed do not.

    robit commented on #241809:16

    416 / 418  ·  1m 42s

    checkout/refund.test.ts › partial refund leaves order shipped

    checkout/refund.test.ts › refund total never exceeds capture

  2. 02Coming next

    Robit reviews

    The agent will explain each failure against the diff, rank the uncovered changed lines, and put the ones behind core scenarios first, each with a scoped fix prompt.

    • services/refund.ts:88–104core42%
    • services/capture.ts:12–40core67%
    • utils/currency.ts:3–99%

    Two of these back steps your team marked core — flows that must never break, written down once in .robit/. Those rank first, automatically.

  3. 03Coming next

    A human verifies

    Coverage says the code ran, not that it is right. A reviewer steps through the drafted plan, edits it, and marks each step.

    Manual test plan · #2418@dana · 2 of 3 pass

    • ✕Partial refund on a shipped order keeps status shipped.core
    • ✓Refund total never exceeds the captured amount.core
    • ✓Receipt email renders the correct currency symbol.

    Step 1 fails by hand, too. The fix goes in before merge.

  4. 04Coming next

    The repository learns

    The reviewer promotes the step that caught the bug. It is committed to the branch, credited to them, and every future pull request is checked against it.

    robit · merged09:44

    421 / 421  ·  1m 51s  ·  changed files 94%

    .robit/specs/Checkout.md +1 core step

    Promoted by @dana

    .robit/specs/Checkout.md
      ## Refunds
      - [core] Refund total never exceeds the captured amount.
    + - [core] Partial refund leaves the order shipped, not closed.

Human in the loop

Robit suggests.
Your team decides what ships.

  • No auto-commits. The agent will never write to .robit/ on its own.
  • Every promotion is a person. Promoted steps will be committed to the branch and credited to whoever approved them.
  • Plans are drafts. Reviewers edit, reject, or rewrite any step before it counts.

Promote to spec?

Partial refund leaves the order shipped, not closed.

file
.robit/specs/Checkout.md
tag
core
commit
feat/checkout · as @dana

What you can use now

Start with the evidence. The agent builds on it.

Available today

  • Reporter@robit-one/reporter for Vitest, Playwright, Jest, Mocha, and Deno. One import.
  • Run ingestionResults, durations, and coverage flow from your existing CI.
  • Coverage dashboardPer suite, per branch, per run. See where a pull request stands before merge.
  • RunsOn for Fly.ioA GitHub App that runs your Actions jobs on Fly.io machines. Cheaper and faster than GitHub runners, and placed next to your production servers for more speed and scale.

Coming next · Phase 2

  • Agent analysisFailure explanations and ranked gaps against the diff.
  • Plans and promptsManual test plans and scoped fix prompts.
  • Spec drift and promotionDrift warnings and human-approved steps committed to .robit/.

Install the reporter now and your history is already in place when the agent arrives.

What it costs you to try

One import. Nothing to host.

Keep your runner

Vitest, Playwright, Jest, Mocha, or Deno, and the tests you have.

No infra

No second runner or webhook to host.

Scoped tokens

One per project, revocable any time.

Your CI, unchanged

Anything that sets standard CI variables.

// vitest.config.ts
import { defineConfig } from 'vitest/config'
import { RobitReporter } from '@robit-one/reporter/vitest'

export default defineConfig({
  test: {
    reporters: [
      'default',
      new RobitReporter({
        token: process.env.ROBIT_TOKEN,
        suite: 'unit',
      }),
    ],
  },
})

Questions

Before you install it

Do I have to rewrite my tests?

No. Robit reads the results your existing suites already produce. One import in your config, one line of options. If you remove it, your tests run exactly as they did before.

What does Robit see?

Test names, pass/fail/skip counts, durations, and the coverage summary your runner emits. Branch, commit and environment come from CI variables. Source code is not uploaded by the reporter.

Does 100% coverage actually mean anything?

On its own, no — it means every line ran. That is the point of pairing it with .robit/ specs: coverage proves the code executed, the specs say which behaviour a human still has to confirm.

Will the agent commit to my repo?

Only when a person promotes a step. When the agent ships, promoted steps will be committed to the pull request branch and credited to the reviewer who approved them. Nothing is written to .robit/ without that approval.

Point it at one repo. Watch the next pull request.

Free to try. No infra to run. Works in your CI today.

Start freenpm i @robit-one/reporter