Skip to content

Ship changes.
Keep promises.

Your code changes fast. What it’s supposed to do shouldn’t get lost along the way.

ShipCheck remembers the behavior your team depends on—and checks every pull request against it.

Start with GitHubSee how it works
GitHub-native You control the merge
Meet your repository’s second memory.
ShipCheck / verificationInteractive example
Update project permissions feature/update → main
#42
Protected behavior

Only project owners can update a project.

api/projects.tsbehavioral diff
requireProjectOwner(user, project);requireAuthenticatedUser(user);
Same scenario. Both revisions.

rejects updates from a non-owner

base PASSheadFAIL
Caught before the merge.

A signed-in user can now update someone else’s project.

Illustrative code & results
A few changed lines. A very different outcome.

Fits the way you already ship.

GitHub Pull requests Your tests Git history

The diff shows what changed.
ShipCheck shows what it means.

A missing check can be a new security hole. A small refactor can undo a hard-won fix. See the behavior behind the lines.

01 / THE CHANGE
− owner check

A few lines disappear.

The pull request looks simple. The permission check it removes is anything but.

02 / THE MEMORY
Owners only

An expectation remains.

Your protected behavior says only a project owner should be allowed to make updates.

03 / THE DECISION
Review required

You see the consequence.

Inspect the evidence, understand the risk, and decide what should happen next.

Illustrative authorization scenario. Verification depends on the evidence available.

Repository memory Always learning
01
AuthorizationOnly owners can update a project.Learned from your code
02
ReliabilityPayment retries must be idempotent.Learned from a past fix
03
ValidationExpired sessions are always rejected.Protected by your team
Illustrative behaviors. Built from code, history, and team decisions.

Don’t rediscover
the same lesson.
Remember it.

That bug you fixed last month? It taught your codebase something. ShipCheck helps make sure the next change doesn’t forget.

  • Discover what matters. Find important behavior already in your repository.
  • Make it a guardrail. Protect expectations with Behavior Guards and versioned Contracts.
  • Carry it forward. Check future changes against what your team has learned.
Explore behavioral memory

Confidence should
come with receipts.

Specialized agents investigate the code, contracts, and runtime behavior. Evidence policy determines what’s strong enough to count as proof.

Look under the hood
Missing proof stays inconclusive.
Uncertainty deserves to be visible.
Differential verificationEXAMPLE
base
$ test checkout.auth

PASS

rejects an unauthenticated request
head
$ test checkout.auth

PASS

rejects an unauthenticated request
Behavior preserved

Same scenario. Both revisions. Paired evidence.

Repository context Behavior Contracts Runtime evidence

Your next pull request
is a good place to start.

Start with GitHub
  1. 1

    Connect your repository

    Choose exactly which repositories ShipCheck can access through its GitHub App.

  2. 2

    Protect what matters

    Discover existing behavior and choose the expectations worth carrying forward.

  3. 3

    Review with context

    Open a pull request, inspect the evidence, and make an informed ship decision.

Glad you asked.

Want the technical version?

Read the docs
How is this different from an AI code reviewer?

ShipCheck combines repository-aware review with persistent behavioral memory. Behavior Guards capture what your software should keep doing; Behavior Contracts add evidence requirements and governance. Future changes are evaluated against those expectations, rather than reviewing every diff in isolation.

Do I need to write every behavior down?

No. ShipCheck can discover important behavior in your existing code and mine historical fixes for candidates. You decide which expectations to protect and how they should influence future ship decisions.

Does every result have runtime proof?

No. Available evidence depends on the repository and protected scenario. ShipCheck distinguishes runtime evidence from code or test presence, and keeps results inconclusive when the required proof is unavailable.

Will ShipCheck change my code automatically?

Scanning reads and analyzes repository context. Applying a suggested fix or regression test requires an explicit action from you. You keep control of repository changes and review decisions.

Give your codebase
a memory for what matters.

Know what changed. Remember why it matters. Ship with context.

Start with GitHub Your repositories. Your access. Your control.