Is AI code integrity just another name for code scanning?

No. Scan is one evidence layer that deterministically catches structural agent defects. AI code integrity is the broader outcome. It provides evidence that a change fulfilled its original intent. Claim Check is the capstone that freezes the intent, binds each obligation to evidence, and returns the verdict.

What is Shipmoor Claim Check?

Claim Check turns a prompt or ticket into atomic obligations, binds those obligations to real evidence, and evaluates them on a deterministic floor. It returns READY only when the required claims are decided and satisfied; a witnessed failure is BLOCKED, and missing evidence is surfaced as INCONCLUSIVE with the exact next action.

Can an AI reviewer approve the change?

No. Shipmoor's bring-your-own judge handles only the residue that deterministic checks cannot bind. It can block by citing a concrete divergence or abstain. It can never hand out a pass; the evidence and deterministic floor decide the verdict.

How do Scan, Test Evidence, and Code Review relate to Claim Check?

They are specialized evidence producers. Scan checks structural defects. Test Evidence verifies that tests ran and were not quietly reduced or weakened. Code Review is an advisory reading pass. Claim Check composes those signals with builds, tests, and obligation-specific checks to decide the completion claim.

Where does Shipmoor run?

On your machine or in your CI runner. Shipmoor hosts no model and uploads no source. Full Claim Check mode uses the coding agent and provider relationship you already control; its deterministic floor can run model-free in CI.

AI code integrity

Your agent says done. Can the change prove it?

AI code integrity is not another opinion on a diff. It is the evidence that an agent-generated change did what was asked. Shipmoor Claim Check freezes the original intent, turns it into atomic obligations, and binds each one to real checks before returning a reproducible verdict.

AI code integrity is the discipline of deciding whether an agent-generated change earned its completion claim, using evidence rather than the authoring agent’s confidence.

Shipmoor Claim Check is the capstone. Scan, Test Evidence, advisory Code Review, builds, tests, and obligation-specific checks each contribute evidence; the deterministic floor returns a reproducible verdict and keeps anything unresolved explicit.

Start a 30-day trial Start a 30-day trial Explore Claim Check Explore Claim Check

Local verification
No source upload
No Shipmoor-hosted model

Frozen intent
Builds and tests
Test Evidence
Deterministic Scan
Advisory Code Review
VSA attestation

$ shipmoor claim-check --intent-prompt "add retry handling to failed webhooks" --agent claude --diff main..HEAD . Claim Check is BLOCKED. Coverage is 100 percent. One obligation is verified and one has diverged.  Verification results: build green, tests green, scan green  Judge block for AC-02: retry stops after the first failure  Location: src/webhooks/retry.ts:47  fix packet: add a check proving retries continue to the configured limit $ shipmoor claim-check --agent claude --diff main..HEAD . Claim Check is READY. Coverage is 100 percent. Both obligations are verified.  Floor pass for AC-01: failed webhooks enter the retry path  Floor pass for AC-02: retries continue to the configured limitWrote attestation to .shipmoor/claim-check.vsa.json

Claim Check blocks a change with concrete witnesses, then verifies the corrected change against the same obligations.

Defining AI code integrity

AI code integrity is the discipline of deciding whether an agent-generated change earned its claim. The decision is grounded in four properties:

Intent-bound

The original prompt or ticket becomes a frozen, reviewable contract. The target cannot quietly move after the code is written.
Evidence-based

Builds, tests, structural scans, bound checks, and advisory review contribute evidence. Confidence and plausible summaries do not.
Reproducible

The deterministic floor evaluates the same committed obligations and evidence under the same policy, producing an attested verdict.
Honest about gaps

If a required obligation cannot be decided, it remains INCONCLUSIVE with the exact action needed to settle it. Unknown never becomes passed.

AI code integrity is the outcome. Claim Check is Shipmoor's mechanism for reaching it.

Why the agent era changes the integrity problem

Coding agents can produce more code than a team can carefully inspect. That speed exposes a deeper weakness: review reads what changed, but rarely proves that the change fulfilled the task it was given.

The claim gap A diff can look reasonable and compile while still solving only part of the requested task, or a nearby problem instead.
Verification theater A green suite is weak evidence if tests did not run, were deleted, or were quietly weakened to make the change pass.
Review overload Humans and LLMs form opinions from diffs under time pressure. Neither opinion is a deterministic proof of acceptance criteria.
Self-validation The agent that wrote the change should not be the final authority on whether its own completion claim is true.

The bottleneck is no longer producing a plausible change. It is producing enough evidence to trust that change in production.

The evidence layers behind the verdict

No single check can establish code integrity. Shipmoor composes specialized layers, keeps each one in its proper lane, and makes Claim Check responsible for the final claim.

01
Structural integrity with Scan

The free deterministic scanner catches phantom imports, hallucinated APIs, placeholder bodies, swallowed errors, and other high-confidence agent defects.
02
Test credibility with Test Evidence

Test Evidence checks that tests really ran and passed, and detects when tests were deleted, reduced, or weakened to manufacture a green result.
03
Reading level risk with Code Review

Your own agent performs an in-depth advisory review for correctness, architecture, security, readability, and performance. It can advise, never approve.
04
Intent fulfillment with Claim Check

Claim Check binds the frozen acceptance obligations to the available evidence, applies the deterministic floor, and issues the attested verdict.

What each verification layer can prove and what it cannot prove

The category is broader than scanning. Each layer answers a different question; Claim Check composes their evidence without pretending any one signal is sufficient.

Layer	What it checks	What it misses
Linter or type checker	Syntax, types, style, and known local anti-patterns	Whether the requested behavior was implemented and the completion claim is earned
Test suite	Behavior covered by the tests that actually execute	Uncovered obligations and whether tests were removed or weakened to force green
Human or AI review	Reading-level risks across correctness, architecture, security, readability, and performance	A deterministic, reproducible decision against the original acceptance criteria
Shipmoor Scan	High-confidence structural defects in agent-generated changes	Business intent, complete acceptance coverage, and runtime behavior outside its rules
Shipmoor Claim Check	Whether frozen obligations are satisfied by bound build, test, Scan, review, and authored-check evidence	Nothing silently: a required obligation without decisive evidence remains INCONCLUSIVE with a concrete next action

AI advises. Evidence decides.

Move verification into the agent loop

Traditional review asks a reviewer to reconstruct intent and audit every supporting signal after the agent is finished. Claim Check turns that work into an explicit loop before the change is declared ready.

Opinion-led review

Reconstruct the ticket from the diff and the agent's summary
Trust that the build and tests genuinely ran
Check that tests were not deleted or weakened
Decide by inspection whether every acceptance criterion was met

Evidence-led verification

Freeze the prompt or ticket into atomic obligations.
Collect build, test, Scan, review, and bound-check evidence.
Let the deterministic floor decide what the evidence proves.
Return witnesses for failures and exact actions for unresolved claims.

The agent can use the fix packet, rerun the same obligations, and continue until the evidence earns READY.

How Shipmoor verifies an agent change

Start with the free structural layer, add Test Evidence for test credibility, then use Claim Check to decide whether the entire change did what was asked. All of it runs locally or in your CI environment.

# Free structural preflight
$ shipmoor scan --changed

# Verify the test run and detect weakened tests
$ shipmoor test-evidence --agent claude

# Gate the change against its original intent
$ shipmoor claim-check --intent-prompt "add retry handling" --agent claude .

The verification layer:

Freezes the prompt or ticket and derives a reviewable contract of atomic obligations.
Binds obligations to your build, tests, deterministic Scan, advisory Code Review, and authored checks.
Requires bound checks to fail at base and pass at head; a check that was already green proves nothing.
Lets the bring-your-own judge block with a concrete divergence or abstain; it can never award a pass.
Returns a fix packet for every blocker or unresolved obligation, then verifies the next round against the same contract.
Writes the verdict and evidence digests to a Verification Summary Attestation (VSA).

The toolchain is the oracle. The model is an adviser. The deterministic floor owns the verdict.

A neutral verifier across every coding agent

Shipmoor does not write the code it judges. It verifies output from the agents you already use, with your own toolchain and your own model relationship. Shipmoor hosts no model and uploads no source.

Cursor
Claude Code
Codex
Copilot
Aider

From one developer loop to an engineering control

Use the same evidence model at each level without claiming that a scan alone proves the change.

Developer loop

Run Claim Check before the agent calls the task done.
Feed its fix packet back into the same agent loop.
Keep the acceptance contract with the code.

CI gate

Run the deterministic, model-free floor against the committed contract.
Reproduce the evidence and verdict without a model secret.
Retain the VSA as a reviewable verification record.

Team and enterprise plans are coming soon

Share policy and baselines across repositories.
Add managed PR gates, audit, and governance controls.
Keep developer evidence and organizational policy connected.

Your agent says done. Evidence decides.

Start a 30-day Shipmoor IC trial for the full Claim Check loop, Test Evidence, advisory Code Review, Agent Skills, and the agent harness. Or install the Community CLI and use the deterministic Scan for free.

Start a 30-day trial Start a 30-day trial Install the free CLI Install the free CLI

AI code integrity questions FAQs

How the category, Claim Check, and Shipmoor's evidence layers fit together.

Your agent says done. Can the change prove it?

Intent-bound

Evidence-based

Reproducible

Honest about gaps

Structural integrity with Scan

Test credibility with Test Evidence

Reading level risk with Code Review

Intent fulfillment with Claim Check