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:
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. 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. 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.
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 more·10 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
-
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.
-
02 Read Language model
Your documents go to a language model, which proposes candidate rules from prose. The only step that reads English.
-
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.
-
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.
-
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.
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:
NodeWorkerno longer depends onRepairScheduler, whichcore.impl/README.mdline 136 says it calls. It did at the base revision.
Documented Rules
- Calls
RepairScheduler.putConfigurations()to keep jobs up to dateNodeWorkerdepends onRepairSchedulerViolated core.impl/README.md:136 - Maintains a dedicated
NodeWorkerbackground thread per Cassandra node.NodeWorkerManagerdepends onNodeWorkerHeld core.impl/README.md:131 - On each scheduling cycle, yields
RepairGrouptasks (one per replica set)TableRepairJobdepends onRepairGroupHeld core.impl/README.md:50 - It acquires the distributed lock then lazily creates and yields
RepairTaskinstances via an innerRepairTaskIterator.RepairGroupdepends onRepairTaskHeld 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 mattered·7 min read Your architecture docs matter more than ever. Now every pull request is checked against them.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.
NodeWorker — A continuously-running background thread per node. It:
- Discovers all replicated tables for its node
- Fetches repair configurations per table
- Calls
RepairScheduler.putConfigurations()to keep jobs up to dateL136 - Loops on a configurable refresh interval
Documented Rules
| Rule | Source | This PR |
|---|---|---|
| NodeWorker depends on RepairScheduler | README.md | ❌ broken by this change |
| NodeWorkerManager depends on NodeWorker | README.md | ✅ holds |
Documented rules
Documented rules brokenRules from your own documentation that a pull request broke: true before the change, false after it. The check quotes the sentence and the line it came from. Rules already broken before a PR are counted separately and never charged to it.
Documented rules heldShare of documented-rule checks where the pull request kept the rule: nothing in it broke the rule. Checked is held plus broken plus already broken; rules Striff could not answer are left out rather than counted as a pass.
819 checked
Documented rules already brokenRules your documentation states that were already broken in the code Striff checked, not by the pull request that checked them. Reported so they are never mistaken for a pass, and never charged to that pull request.
PRs that broke no ruleShare of analyzed pull requests that broke none of your documented rules, over the last 6 months.
Pull requests
PRs analyzedTotal pull requests Striff checked across every active repo in this installation.
CoverageShare of GitHub PR-check webhook events (opened, updated, reopened) that completed analysis, over the last 6 months. Below 100% may mean PRs were skipped -- check billing status or repo connection.
Most-flagged repos over timeEvery repo that has been among a month's most-flagged at any point in the last 6 months, tracked month by month. A flag is a documented rule one of the repo's pull requests broke. A repo can show a lower or zero count in months it wasn't in that month's own top list.
PRs that broke a ruleThis month's recent pull requests that broke at least one documented rule, the most rules broken first -- click through to see each rule and the sentence it came from.
Jul 2026
- acme-corp/core-api #4092 rules broken
Introduce direct DB call from the notifications module
- acme-corp/core-api #4121 rule broken
Merge auth and billing request pipelines
- acme-corp/billing-service #4111 rule broken
Read ledger tables directly from the invoice webhook consumer
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
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
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.
Enterprise
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 ChromeFAQ
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.