OpenCodeReview: Deterministic AI Code Review for CI

Problem and target customer

Why this exists

Customer problem

General-purpose code review agents miss changed files, produce unstable findings across runs, and place comments at incorrect code locations, eroding developer trust in automated review.

Who pays

Engineering organizations maintaining large repositories that need repeatable, line-accurate code review quality across pull requests and CI without noisy broad-recall output.

Business model

Self-hosted core for adoption; paid managed review runner priced by repository or review volume, with artifact retention, policy packs, and organization-level analytics.

Editorial note

OpenCodeReview is a precision-oriented review system for teams that are dissatisfied with broad, noisy agent reviews. It narrows the model context to changed files and matched rules, then returns findings with a file, line, severity, and rule reference that a developer can triage.

The commercial service runs the review pipeline for teams that do not want to operate workers, model credentials, artifact storage, and policy configuration. Pricing can follow repositories or review volume, with retained findings and organization analytics as paid operational features rather than requirements for the core reviewer.

The MVP should focus on GitHub pull requests and a local CLI path. Its first proof is placement precision and useful signal on real changesets, not a promise to replace human review or catch every defect.

Choose your next step

What do you need next?

Evaluate the operating tradeoffs quickly, or inspect how to build the MVP.

Evaluate this ideaSee the cost and deployment preview

Compare the three operating paths at the default workload before opening the full calculator.

See cost preview Build this ideaInspect the build blueprint

Review MVP scope, workflow, states, data rules, architecture, and acceptance criteria.

Open blueprint

Evaluation preview

What would it take to run?

Directional infrastructure estimates for the current 200 pull-request reviews assumption. Open the full calculator when you are ready to change it.

Open full cost and deployment

ManagedSelected

$6.6-$28/ month

Managed app, database, and worker capacity for the beta workload.

Lowest operating effort

Lean self-hosted

$6.6-$18/ month

A lower fixed-cost deployment with more setup and maintenance.

Lowest baseline cost

More control

$22-$83/ month

More control over service placement and operational capacity.

Most separation and control

Build blueprint

Build the first paid use case

Product goal

Who it serves and what it must change

Target user: Platform engineers and maintainers of large repositories who need repeatable, line-accurate code review in pull requests and CI.
Problem: General-purpose review agents miss changed files, produce unstable findings, and place comments at incorrect code locations.
Measurable outcome: Findings land on the correct file and line at least 80% of the time with fewer than 15% false positives across 50 merged pull requests.

MVP scope

What ships now and what waits

Included

Git diff extraction and changed-file detection
Rule matching and file bundling for LLM context
LLM tool-use review producing structured line-level findings
GitHub pull request comment publication
CLI invocation for local pre-push review

Excluded

Trend analytics and historical finding dashboards
Multi-repository cross-review correlation
Hosted managed execution service
Custom rule authoring UI

UX and user flow

Screens, actions, and states

Repository connection

Connect a GitHub repository and configure the model endpoint.

Connect repoSet API keySelect model

Pull request review view

Display the diff with highlighted changed lines alongside findings.

Browse diffView findingsFilter by severity

Finding detail

Show a single finding with file, line, rule reference, and suggested fix.

Read findingSee rule contextDismiss false positive

Rule configuration

List and enable review rules for the connected repository.

Enable ruleDisable ruleView rule scope

Primary flow

Connect repository and configure model endpoint
Open a pull request to trigger review
Review findings positioned on changed lines
Triage or dismiss findings and publish comments

Loading, empty, and error states

Pending review
Review in progress
Findings ready
Findings published
Review failed

Core entity outline

Entities and business rules

Repository

Represents a connected Git repository with provider metadata.

Fields: id, provider, url, default_branch, created_at
Relations: has many PullRequests, has many ReviewRules

PullRequest

Represents a PR under review with diff metadata.

Fields: id, repository_id, number, base_sha, head_sha, status
Relations: belongs to Repository, has many ChangedFiles, has one ReviewSession

ChangedFile

Represents a file in the diff with path and hunk data.

Fields: id, pull_request_id, path, additions, deletions, hunks
Relations: belongs to PullRequest, has many Findings

ReviewRule

Represents a rule matched against changed files to constrain LLM context.

Fields: id, repository_id, name, pattern, language, severity
Relations: belongs to Repository, has many Findings

Finding

Represents a line-level review issue produced by the LLM or deterministic check.

Fields: id, changed_file_id, rule_id, line, severity, message, suggestion
Relations: belongs to ChangedFile, belongs to ReviewRule

Business rules

Only files present in the git diff enter the review scope
Deterministic rule checks execute before LLM review
Each finding must reference a changed file and a specific line number
Findings without a valid line mapping are discarded
LLM context is bounded to matched files and their bundled related files

Architecture and data flow

Components, integrations, and controls

Diff extractor

Clone or fetch the repository and compute the changed file set from the pull request diff.

Rule matcher

Match changed files against configured rules and bundle related files for LLM context.

LLM review agent

Invoke the configured model endpoint with constrained context and return structured findings.

Finding publisher

Map findings to diff hunks and post line-level comments to the Git provider.

Integrations

GitHub pull request API for diff retrieval and comment publication
OpenAI-compatible model endpoint for LLM review calls
Anthropic-compatible model endpoint as alternative provider
Git CLI for local diff extraction

Data flow

Pull request event triggers diff extraction
Diff extractor passes changed files to rule matcher
Rule matcher bundles context and invokes LLM review agent
LLM agent returns structured findings to finding publisher
Finding publisher posts line-level comments to the pull request

Failure handling

If the LLM endpoint times out, deterministic findings are still published with a retry flag
If a finding cannot be mapped to a line, it is logged and excluded from publication
If the diff is empty, the review session completes with zero findings

Security

Model API keys stored as encrypted environment variables
Repository access scoped to read-only clone and comment write
No source code retained beyond the review session unless artifact storage is enabled

Rate limits

LLM calls capped at a configurable concurrency per review session
GitHub API calls respect provider rate limits with exponential backoff

Deliverables and acceptance

Definition of done for the MVP

Deliverables

Review workspace UI with diff and findings display
Backend runner with diff extraction, rule matching, and LLM review
GitHub pull request integration for comment publication
CLI entry point for local pre-push review

Acceptance criteria

Given a pull request with 10 changed files, the tool detects all 10 and passes only those to the rule matcher
Given a matched rule and changed file, the LLM agent receives context bounded to that file and its bundled related files
Given a finding with file and line, the publisher posts a comment at the correct line in the GitHub pull request
Given an LLM timeout, deterministic findings are published and the session is marked for retry
Given an empty diff, the review session completes with zero findings and no error

Recommended stack

Enough technology for the first version

Frontend / Workspace

Lovable

Build a review workspace UI showing diffs, findings, and rule references without hand-coding React components.

Automation / Glue

Make

Optional webhook routing between GitHub pull request events and the review runner, bounded to event dispatch only.

Backend / Runner

Railway

Host the review execution service that clones repos, runs rule matching, invokes the LLM, and publishes findings.

Why this is sufficient

Lovable accelerates the review workspace UI for diff and findings display. Make handles optional webhook glue between Git providers and the runner. Railway provides a repeatable container environment for repository inspection, LLM calls, and comment publication.

Not required for the MVP

Trend analytics dashboardsHosted pricing or billing portalCustom rule authoring interfaceMulti-provider SSO

Next stepTurn the blueprint into an execution plan

Copy the build prompt, model the operating cost, and choose where to deploy.

Build and ship

Execution

Build, price, and deploy the MVP

Once the blueprint is clear, use the prompt, cost model, and deployment options to start building.

Build prompt

Copy this into a builder

Lovable

Build prompt

Your build prompt is ready

Open the prompt pack whenever you are ready to take this blueprint into your builder.

Based on the blueprintReady for your builderFollow-up steps included

Cost calculator

Model the MVP operating cost

A technical run-cost estimate for the first production version. Team, acquisition, payment fees, and business COGS are excluded.

Estimated monthly total$6.6-$28

$3.3-$14 per 100 pull-request reviews

Pull-request reviews / month200 pull-request reviews

Selected pathEasiest

Pricing checkedAug 2, 2026

Cost breakdown

$6.6-$28 per month

Low and high values allow for usage variance and plan headroom.

Managed application stack

Managed app, database, and worker capacity for the beta workload.

400 pull-request reviews included, then $5-$20 per 400 pull-request reviews

$5-$25

Review model calls (GPT-5.4 mini)

Model analysis for bounded code context and structured findings.

200 pull-request reviews x 7K input + 1.2K output tokens

$1.6-$2.66

Included

Application hosting
Database and background processing
Required product modules

Not included

Labor
Marketing
Taxes and legal review
Enterprise compliance work

Pricing basis

The estimate combines the selected infrastructure path, required operating modules, selected optional modules, and usage above included monthly allowances. Taxes and regional uplifts are excluded.

Railway pricing OpenAI model pricing

Deployment options

Pick the operational tradeoff

Choose based on operating preference, not only the headline price.

EasiestRecommended

Railway

Run the web app, database, and background jobs with a small operational footprint.

$5-$25/month plus usage modules

Good fit

Managed beta
Fast deployment
Background jobs

Limitation

Service usage and background workloads can exceed the base plan.

Deploy on Railway

Cheapest

Vultr

Run the app, worker, and database on one small Vultr VPS with Docker Compose and explicit backups.

Varies by selected stack

Good fit

Hands-on operator
Small pilot
Low fixed cost

Limitation

You manage more setup, backups, monitoring, and upgrades.

Deploy on Vultr View the lean VPS guide

More control

DigitalOcean

Separate application, worker, data, storage, and backup responsibilities as the workload grows.

$10-$60/month plus usage modules

Good fit

Dedicated capacity
Custom services
Operator control

Limitation

Security updates, backups, observability, and scaling remain your responsibility.

Explore DigitalOcean View the separated cloud guide

Start building

Prototype, automate, then deploy

Recommended route

01Vibe-coding builderReview workspace UI

Build a split-pane interface that renders git diffs with highlighted changed lines and a findings panel listing line-level comments with severity badges and rule references.

Open Lovable 02AutomationPR webhook routing

Optionally route GitHub pull request webhook events to the Railway-hosted review runner and return publication status back to the workspace.

Open Make 03DeployReview execution runner

Deploy the backend service that clones the repository, extracts the diff, matches rules, invokes the LLM endpoint, positions findings, and publishes comments to the pull request.

Open Railway

OpenCodeReview: Deterministic AI Code Review for CI

Is this worth validating?

Build this if

Avoid this if

Validate first

Why this exists

Customer problem

Who pays

Business model

What do you need next?

What would it take to run?

Build the first paid use case

Who it serves and what it must change

What ships now and what waits

Included

Excluded

Screens, actions, and states

Primary flow

Loading, empty, and error states

Entities and business rules

Business rules

Components, integrations, and controls

Integrations

Data flow

Failure handling

Security

Rate limits

Definition of done for the MVP

Deliverables

Acceptance criteria

Enough technology for the first version

Lovable

Make

Railway

Why this is sufficient

Not required for the MVP

Build, price, and deploy the MVP

Copy this into a builder

Your build prompt is ready

Model the MVP operating cost

Usage assumptions

$6.6-$28 per month

Included

Not included

Pricing basis

Pick the operational tradeoff

Railway

Good fit

Limitation

Vultr

Good fit

Limitation

DigitalOcean

Good fit

Limitation

Prototype, automate, then deploy

Related ideas

BookToSkill: Turn Technical Documents into Agent Skills

Ego Lite: Isolated Browser Spaces for AI Agents

EnergyMatch — AI Daily Planner for Solopreneurs

AI Time Audit & Revenue Optimizer for Freelancers

Centsible: Gen Z Paycheck-to-Paycheck Budget Coach

MagnetIQ: AI-Powered Lead Magnet Generator & Quiz Optimizer