Striff logo

Architectural review for pull requests in the age of AI coding.

Striff gives reviewers a system-level view of every pull request so teams can gauge PR impact in a single view.

GitHub pull request review Java, Python, TypeScript Inline architecture notes Metrics and risk signals
Install Chrome extension See how it works
Striff diagram overview
PR diff legend Added Modified Removed Languages Java Python TypeScript CSharp soon GoLang soon

Review the PR the way your system was designed: as moving components, boundaries, dependencies, and risk hotspots instead of isolated files.

For reviewers

Start with system change, then drill into files only where needed.

For AI-heavy teams

Keep agent-generated code aligned with architecture, not just syntax.

For engineering leads

Surface coupling, drift, and risky boundaries before they become cleanup work.

Why Striff

File diffs tell you what changed. They rarely tell you what the change means.

AI-assisted coding increases pull request volume and makes it easier for architecture drift to slip past line-by-line review. Striff gives teams a structural view first so they can judge blast radius, coupling shifts, and boundary risk before diving into files.

Research published at ICCQ 2021, in cooperation with IEEE Computer Society

Without Striff

File diff shows what lines changed.

With Striff

Striff shows what moved structurally: dependencies, boundaries, and blast radius.

Without Striff

Conventional review starts deep in files.

With Striff

Striff starts at the system layer and lets reviewers drill in only where risk appears.

Without Striff

AI-generated PRs can look tidy line-by-line.

With Striff

Striff exposes architecture drift, coupling shifts, and the parts of the system most likely to need attention.

What you get

A review view built for architectural judgment.

Striff is not just a diagram generator. It brings structural change, metrics, and review guidance into one review view your team can use in seconds.

Diff Lens

Structural diffs instead of file noise

Review the shape of the change first: new dependencies, moved boundaries, changed classes, and the surrounding impact.

Review Engine

AI review grounded in deterministic signals

AI review is grounded in architecture-aware signals so comments are tied to real structural risk, not generic code-review advice.

Inline Context

Notes attached where the risk lives

Review comments are rendered into the SVG itself so the architectural issue stays attached to the component or package it affects.

Workflow Fit

Built for real review flows

Analyze GitHub pull requests or code snapshots, revisit saved results later, and keep the experience fast enough for active review.

Step 1

Input

Generate the diagram

Start from a pull request or two code snapshots and generate a structural view of the system changes.

Step 2

Analysis

Spot impact and risk

Scan added, modified, and removed components, then use metrics and relationship changes to find the blast radius fast.

Step 3

Decision

Act on the right questions

Use inline review notes and risk signals to focus the conversation on coupling, drift, and boundary risk before merge.

Product paths

Use Striff wherever your team reviews change.

Use Striff in the review flow that fits your team: inside GitHub, in automated checks, through your own integrations, or in a private environment.

For Reviewers

Chrome extension for pull request review

Open structural diffs and review notes inside GitHub instead of switching between tabs, screenshots, and comments.

Install extension

For Teams

GitHub Check for architecture-aware merge gates

Post architectural review signals directly into PR checks and move toward policy-based enforcement on risky changes.

See GitHub Check

For Developers

API and OSS library for deeper integration

Generate Striffs from GitHub pull requests, uploaded code snapshots, or your own Java-based automation.

Explore the library

For Enterprises

Private deployment for internal codebases

Run Striff inside your own environment for private repositories, stricter data controls, and internal review workflows.

Contact us

How to read a Striff

Learn the diagram once, read every review faster.

A Striff turns changed files into a system-level diff. Open each section to see how change colors, structure, metrics, and review notes make large pull requests easier to understand.

org.openapitoolscodegenjavaspringlanguagesutilsmodelAbstractJavaCodegenTest [+2](...)     toDefaultValueTest()toDefaultValueDateTimeLegacyTest()SpringCodegenTest [+1 +2](...)     generateFromContract(...) : Map<String, File>generateLocalTimeForTimeLocalFormat()testOneOfAndAllOf()AbstractJavaCodegen [+3](...)     toEnumValue(String, String) : StringtoDefaultValue(CodegenProperty, Schema) : StringprocessOpts()ModelUtils [+1 +7](...)     isComplexComposedSchema(Schema) : booleanisTimeLocalSchema(Schema) : booleanhasSelfReference(OpenAPI, Schema, Set<String>) : booleanunaliasSchema(OpenAPI, Schema, Map<String, String>) : SchemaisFreeFormObject(Schema, OpenAPI) : booleangetInterfaces(Schema) : List<Schema>isAllOfWithProperties(Schema) : booleanisObjectSchema(Schema) : booleanPet [+4 +3](...)     feedingTime : LocalTimegetFeedingTime() : LocalTimesetFeedingTime(LocalTime)toString() : Stringequals(Object) : booleanhashCode() : intfeedingTime(LocalTime) : PetFan-in gravityModelUtilsis a very large utility (WMC ~679)referenced by core code (AbstractJavaCodegen) andtests. That size makes it a coupling magnet: smallchanges toModelUtilswill ripple across manygenerators/tests in the short term (next release)and create substantial coordination cost over themedium term (few releases) as callers evolve.Tradeoff: centralizing parsing/validation logicreduces duplication today but increases the riskthat future API tweaks become high-impact changeevents that block parallel work and pressure teamsto copy-or-extend portions (copying will accelerateboundary erosion). Evidence: the changeset showsheavyModelUtilssurface area and explicit depsfromAbstractJavaCodegenand tests.Boundary driftSpringCodegenTestnow referencesAbstractJavaCodegenconstants (GENERATE_BUILDERS,GENERATE_CONSTRUCTOR_WITH_ALL_ARGS) and exercisesgenerator config bits from the Spring-focused testmodule. Tests reaching into core config create a usagepattern that developers will copy into productioncode over the medium term, causing package/layerboundary drift. Tradeoff: pulling core knobs intotests gives immediate coverage and convenience butnarrows future freedom to change core configurationwithout breaking consumers across language modules;consequence is that intended layering decisions becomeharder to reverse within one-to-two releases.Contract driftTheAbstractJavaCodegenTestchanges (EC increased)indicate test expectations have shifted alongsideAbstractJavaCodegenbehavior. When tests thatcompose with core classes change, it oftensignals a behavioral contract change rather thana pure refactor. Consequence: downstream languageimplementations and template consumers are likelyto need updates within the next release window,increasing short-term integration friction.Tradeoff: evolving the core contract can unlockimproved behavior but raises immediate upgrade workand client compatibility pressure.

Added marks new structure entering the system. Modified shows existing components whose internals changed. Removed makes deleted paths visible before they disappear into file diffs.

Install the plugin

Install Striff for GitHub pull request review

Use the Striff Chrome extension directly on GitHub pull requests to inspect structural change, dependency movement, and review notes where merge decisions actually happen.

Install Chrome extension View extension source

Native workflow

Open Striff directly inside the pull request

Review architectural change in GitHub instead of jumping between screenshots, tabs, and comments.

One review view

See structure, metrics, and notes in one place

Open a review panel built for architectural judgment, with diagrams, notes, and change context attached to the pull request.

Reviewer focus

Put reviewer attention on the riskiest changes first

The extension helps reviewers prioritize coupling drift, architectural spread, and high-impact components before merge.

Refactor API gateway routing module #19423
feature/gateway-refactor main
Checks
striff / architectural-review 3 structural changes · 2 coupling warnings · 1 review note
Passed
ci / build Passed
ci / test Passed
Coming Soon In development

Striff as a GitHub Check

Automatically post architectural review signals as a GitHub Check on every pull request. Reviewers see structural change, coupling warnings, and AI review notes directly in the PR checks panel.

  • Post Striff diagrams and review notes as PR check output
  • Gate merges on architectural risk thresholds
  • Works with GitHub Actions, no custom CI setup required