Statement-based PR review

Encode the rules your reviewers already enforce.

CrossCheck turns natural-language standards into pass/fail checks on every PR — running in our managed cloud, against your codebase.

Only takes a few clicks to set up · 14-day Pro trial · No credit card required

feat: add events_session aggregation
+7 −0
000CrossCheck
5 checks
  • All new tables have a Great Expectations test suite
    Data quality
    queued
  • Every public function has a docstring
    API conventions
    queued
  • Public API changes are recorded in CHANGELOG.md
    API conventions
    queued
  • No secrets, tokens, or .env values in source
    Security
    queued
  • Migrations are reversible (down() implemented)
    Data quality
    queued
The problem

Generic AI reviewers comment on style. Your team's bar is higher.

Repo-specific rules

The standards that actually matter — migration shape, logging conventions, ownership of public APIs — never make it into a generic reviewer's prompt.

Per-statement evidence

Every check passes or fails with a line-numbered reference, not a paragraph of vibes. You can act on a CrossCheck result without reading the diff yourself.

Runs on every PR, automatically

Install the CrossCheck GitHub App once. Every PR is reviewed automatically in our managed cloud — no CI workflow to maintain, no API keys to manage.

How it works

From plain English to a check on the PR.

Three steps. No prompt engineering, no glue code, no per-repo plumbing — reviews run in the CrossCheck-managed cloud.

01

Write a statement

Describe a rule in plain English. Group statements into Check Groups and attach them to repos.

02

Reviews run in our cloud

Install the CrossCheck GitHub App. Every PR kicks off a fresh, isolated review; the agent proves each statement true against the diff.

03

Pass / fail, on the PR

Results post back as a check group: pass, fail, or needs review, with line references and evidence. Optionally auto-approve when everything passes.

Statements

What does “a good PR” mean in your repo?

Whatever it is, you can encode it. Statements are natural-language rules the agent must prove true on every PR.

All new tables have a Great Expectations test suite
Data quality
Every public function has a docstring
API conventions
API changes are recorded in CHANGELOG.md
API conventions
No secrets or tokens committed to source
Security
Migrations are reversible (down() implemented)
Data quality
New endpoints have OpenAPI specs
API conventions
All new tables have a Great Expectations test suite
Data quality
Every public function has a docstring
API conventions
API changes are recorded in CHANGELOG.md
API conventions
No secrets or tokens committed to source
Security
Migrations are reversible (down() implemented)
Data quality
New endpoints have OpenAPI specs
API conventions
Pydantic models declare types for every field
Type safety
React components render under StrictMode
Frontend hygiene
Logs include request_id and tenant_id
Observability
No new try/except without an explicit reason
Error handling
PII columns are tagged in the data catalog
Compliance
Dependency bumps are pinned to exact versions
Supply chain
Pydantic models declare types for every field
Type safety
React components render under StrictMode
Frontend hygiene
Logs include request_id and tenant_id
Observability
No new try/except without an explicit reason
Error handling
PII columns are tagged in the data catalog
Compliance
Dependency bumps are pinned to exact versions
Supply chain
Run viewer

What you actually get back, on every PR.

Per-statement results, grouped, ranked by issues, with line-numbered evidence. Try the failing row — it expands into the source.

Data quality
2 checks
101
  • All new tables have a Great Expectations test suite
    94%
    Fail

    Migration 0042 introduces table `events_session` with no matching expectation suite under tests/great_expectations/.

    1-- Add events_session table for per-session aggregation
    2CREATE TABLE events_session (
    3 session_id UUID PRIMARY KEY,
    4 user_id UUID NOT NULL REFERENCES users(id),
    5 started_at TIMESTAMPTZ NOT NULL,
    6 ended_at TIMESTAMPTZ,
    7 event_count INTEGER NOT NULL DEFAULT 0,
    8 properties JSONB
    9);
    10
    11CREATE INDEX events_session_user_id_idx ON events_session (user_id);
    12CREATE INDEX events_session_started_at_idx ON events_session (started_at);
    13
  • Migrations are reversible (down() implemented)
    96%
    Pass
API conventions
2 checks
011
  • Every new public function has a docstring
    99%
    Pass
  • Public API changes are recorded in CHANGELOG.md
    71%
    Needs review

    PublicSearchClient.search() signature changed; CHANGELOG.md was not updated. May be intentional if pre-1.0.

Security
1 check
001
  • No secrets, tokens, or .env values in source
    97%
    Pass
Extensibility

Tools are data, not code.

Wire up MCP servers, custom skills, or the built-in repo toolset from the admin UI. Pick a review depth per repo; CrossCheck owns the model + cost story. No deploy required.

Three review depths — Fast / Standard / Deep — pick the cost-vs-thoroughness tradeoff per repo.

Built-in tools for navigating your repo — reading files, searching, running commands in an isolated checkout.

Plug in MCP servers for org-specific knowledge — Linear, Slack, your own.

Skills let you bundle instructions + tools and reuse them across check groups.

FAQ

Things people ask before they sign up.

In the CrossCheck-managed cloud. Each PR spawns a fresh, isolated review that checks out your code, evaluates the statements, and exits — nothing persists between runs. Install the CrossCheck GitHub App once; there's no CI workflow to maintain.

Doors to manual and cross check

Cut the “is this up to standard?” question out of code review.

Encode your team’s standards as statements. Ship the action. Get pass/fail with evidence on every PR.

14-day Pro trial. No credit card required.

CrossCheck — Statement-based AI code review for GitHub