Your architecture docs, enforced on every pull request.

Striff reads the documents already in your repository, turns the sentences that make claims about the code into rules, and checks every pull request against them. When a change contradicts what your team wrote down, it says so before the merge, and quotes the line.

Free on public repos Nothing to configure One check beside your CI

A language model reads your docs and turns their sentences into rules. Each rule is a logical formula, checked against a formal model of your code before and after the pull request. Here is what that looks like:

Striff / architectural-review acme/checkout-service Example Java

One of the 42 rules Striff checked in this repository’s own docs no longer holds. Nothing was configured. Striff read the repository’s documents, turned their sentences into rules, and checked them against both revisions.

1broken 41held
Never import from legacy/ in new code; use the equivalents in core/. AGENTS.md:18 Nothing in checkout depends on legacy Agent instructions CartService now imports legacy.pricing.PriceCalculator Broken by this PR The rule held before this pull request and is broken after it.
Only the billing module talks to the Stripe SDK; everything else goes through PaymentGateway. docs/adr/0007-payments.md:12 Only billing depends on com.stripe Vendor boundary Held The rule held before this pull request and still holds after it.
The domain layer never depends on infrastructure. ARCHITECTURE.md:42 Nothing in domain depends on infrastructure Layering Held The rule held before this pull request and still holds after it.
Neurosymbolic · formal model checking Why this is rigorous

A language model reads each sentence in your docs and proposes the rule it states. The rule is compiled into a formula in first-order logic, and a parser turns the code before and after the pull request into finite models of its types, members and references. Every verdict is formal model checking in the logical sense: does the model satisfy the formula?

A rule is broken by the pull request when , and held when nothing in the pull request breaks it. The language model reads and proposes; the program decides.

Works with Java Python C# TypeScript

The problem

Nobody re-reads the docs on every pull request.

Coding agents read your architecture docs as context, then write code that quietly contradicts them, and no reviewer re-reads those documents on every change to catch it. Left unchecked, each merge drifts a little further from what your team agreed, until every change costs more than it should and nobody wants to touch the core. Striff catches the contradiction on the pull request, while it is still a one-line fix.

Why coding agents make architecture review matter more10 min read AI didn't make engineering discipline obsolete. It made it the whole job.

Every verdict is computed, not generated.

Striff is neurosymbolic: a language model reads your docs and proposes rules, and a program decides what is true. A parser turns your code before and after the pull request into a formal model of its types, members and references, resolved the way a compiler does, and each rule becomes a formula in first-order logic. Every verdict is formal model checking: does the model satisfy the formula? The language model only reads the prose and explains the results, and nothing is needed beyond the documents your repository already has.

01 How a finding is produced

  1. 01 Parse Deterministic

    The code before and after the pull request becomes a structural model of types, members, references and packages — resolved the way a compiler would, not by matching text.

  2. 02 Read Language model

    Your documents go to a language model, which proposes candidate rules from prose. The only step that reads English.

  3. 03 Ground and compile Deterministic

    A proposed rule that names a class or package your code does not contain is dropped. The rest become formulas over the model.

  4. 04 Evaluate Deterministic

    Each formula is checked against the model of the code before and after the change. A rule is held when nothing in the pull request breaks it, and only a violation the change introduced is attributed to it.

  5. 05 Narrate Language model

    The model ranks and explains what the evaluation already found. It cannot originate a finding, rename one, or turn “could not answer” into a pass.

How we keep the model honest7 min read Every Striff finding comes with a receipt

02 What your reviewer sees

Review Summary

This PR moves repair-history setup into the incremental path. NodeWorker stops referencing RepairScheduler and the table lookups it used, and now depends on SchemaRefresher. RepairHistory drops a public newSession overload that 11 components reach for.

Top Review Items

  • 📄 Doc conflict: NodeWorker no longer depends on RepairScheduler, which core.impl/README.md line 136 says it calls. It did at the base revision.

Documented Rules 63 rules checked · 62 held · 1 violated

  • Calls RepairScheduler.putConfigurations() to keep jobs up to date NodeWorker depends on RepairScheduler Violated core.impl/README.md:136
  • Maintains a dedicated NodeWorker background thread per Cassandra node. NodeWorkerManager depends on NodeWorker Held core.impl/README.md:131
  • On each scheduling cycle, yields RepairGroup tasks (one per replica set) TableRepairJob depends on RepairGroup Held core.impl/README.md:50
  • It acquires the distributed lock then lazily creates and yields RepairTask instances via an inner RepairTaskIterator. RepairGroup depends on RepairTask Held core.impl/README.md:58

4 of 63 shown

The check also carries the architecture diagram of this change, shown below.

The diagram

Every pull request gets a structural diff diagram.

The classes a change touched, what each one gained and lost, and how they connect at both revisions, so you can see the shape of a change you didn’t write. Green was added, red was removed and blue changed.

The diagram engine is open source: striff-lib on GitHub MIT What this pull request broke, and why it mattered7 min read Your architecture docs matter more than ever. Now every pull request is checked against them.
Ericsson/ecchronos PR #1786 Java 1 rule broken
Striff / architectural-review
Striff's focused diagram of Ericsson/ecchronos PR #1786: IncrementalRepairJob leading to RepairGroup and on to IncrementalRepairTask and VnodeRepairTask, beside NodeWorkerManager, with added members in green, removed ones in red and changed ones in blue
Architecture diagram of this PR
Rule
The README no longer matches the code

core.impl/README.md says NodeWorker calls RepairScheduler. After this PR, it doesn’t.

Held on this change 7

  • When the RepairGroup is executed it will generate one VnodeRepairTask per token range to repair. RepairGroup depends on VnodeRepairTask Held docs/ARCHITECTURE.md:287
  • When the RepairGroup is executed it will generate one IncrementalRepairTask. RepairGroup depends on IncrementalRepairTask Held docs/ARCHITECTURE.md:287
  • Maintains a dedicated NodeWorker background thread per Cassandra node. NodeWorkerManager depends on NodeWorker Held core.impl/README.md:131

+ 4 more held

For engineering managers

What your senior engineers decided, checked on every pull request.

Keeping a system coherent while people and agents change it every day is the part nobody owns. Striff makes it part of every pull request: reviews that do not wait on your seniors, documents that stay true, and a view of where the code is drifting from them.

Get started

Start with public repos. Scale to your team.

Nothing to learn and no workflow to change: Striff shows up as one more check on the PRs your team already opens. Start free on public repos, add private repos when you're ready.

Free

$0 forever

Public repositories

Your documented rules checked on every public pull request, with a diagram of each change, plus the browser extension for any public PR you visit.

Starter

$29 /mo · 5 repos

One team's private repos

Your documented rules checked on every private pull request, with a diagram of each change, for one team’s repositories.

Team $59/mo · Scale $149/mo →

Enterprise

Talk to us

Self-hosted & 50+ repos

Private deployment, SSO, and audit workflows for organizations that need full control.

Free Chrome extension

See what any GitHub pull request really touches.

Reviewing an unfamiliar change means holding somebody else’s dependency graph in your head. The extension draws it in a tab beside Files changed, so you see what a change touches before you approve it. The same load checks the rules that repository states in its own documents, and a Findings button opens them beside the diagram.

  • An interactive dependency diagram of any public pull request
  • Its documented rules checked, one click from the diagram
  • Comment straight from the diagram
  • Works on repositories you do not own

Use the extension for one pull request, on demand, in any public repository, including ones you do not own. Use the GitHub App to check every pull request your team opens, post the result where the whole team reviews, and keep the history that becomes your dashboard.

Add to Chrome

FAQ

Common questions

How does Striff know what my architecture is supposed to look like?

You already wrote it down. Striff catalogues the documents in your repository that make claims about the code, turns those sentences into rules, and checks them against the code your pull request produces, quoting the sentence and linking the file it came from. Nothing is configured and no rule format is invented: your documentation is the rulebook. A rule can be as plain as where a class lives or as sharp as “the domain module must not depend on infrastructure”. Alongside the rules, every pull request gets a diagram of what changed and review notes on the components it touched. If your docs make no checkable claim about the code, Striff invents no rules of its own: you still get the diagram and the review notes.

What languages does Striff support?

The diagram runs on Java, TypeScript, Python and C#. Striff parses source into a full structural model with its own parser, not regex or text matching, so references, inheritance and dependencies resolve the way a compiler sees them. Documented rules are further along on some of those than others: Java and C# are production-ready, Python extracts rules from your docs but cannot yet answer all of them, and TypeScript is still being proven out. We would rather say that here than have you install and find out. Go is coming.

Is it just an LLM wrapper?

No, and the architecture is the answer. Every verdict is produced by deterministic analysis of the structure your change actually creates: the parser builds a model of both revisions, each documented rule is a query over that model, and a rule is held when nothing in the pull request breaks it. The model is fact-gated, which means it can rank findings, explain them and write the summary of what your PR did structurally, but it cannot originate one, rename one, or turn "could not answer" into a pass. That last constraint is why a rule Striff cannot answer from the code is left out of the results instead of quietly counted as green.

Will it slow down or block my pull requests?

No. Striff runs as a GitHub Check next to your CI and posts its results when the analysis finishes, typically within a few minutes. It never blocks a merge unless you choose to make the check required.

What do I need to set up?

Just install the GitHub App. It works on public and private repos alike and posts checks automatically on every PR, with no per-developer setup. Plans start at $29/month, based on how many repos actually get reviewed each month, not how many you connect. To try Striff on somebody else’s public pull request first, use the browser extension.

Do I need to install anything to use the browser extension?

No. The extension runs in your browser on any public pull request you visit, so you can point it at somebody else’s repository without touching it, and it is free on every public pull request, with no account. The analysis itself runs on Striff’s servers. A free GitHub token raises GitHub’s rate limits: on a public pull request it is only sent to GitHub; on a private repository or a very large pull request, Striff’s servers use it to fetch the code themselves.

Does the extension check documented rules too?

Yes. One load brings up the diagram and checks the rules that repository’s own documents state. When it finishes, a “Findings” button with the rule count on it opens the full list beside the diagram. Same pipeline as the GitHub App, on a repository you do not have to own.

Is my source code sent to a third party or stored?

Your code is parsed on Striff's servers in memory and not persisted. The AI explanation layer works from the structural model (component names, relationships, metrics, and doc excerpts), not your raw source files. For teams that need full control, self-hosted deployment is available on the Enterprise plan.

Code is cheap now. Changing it isn't.

Every unchecked merge makes the next change a little more expensive. The cost compounds quietly, and nobody can point at the day it started. Striff starts checking on your next pull request.