Rynko
Rynko
Sign InGet Started
Demo — rynko-review

Three-layer code review
in one API call.

ESLint, tests, and security scans produce data. Rynko Flow enforces rules on that data. AI Judge evaluates what rules can't express. One gate, one HTTP call, one audit trail.

View on GitHubTry it yourself

The three-layer pipeline

Each layer catches what the previous one can't. If Layer 1 fails, Layers 2 and 3 are skipped — no wasted LLM cost.

Layer 1
Deterministic Tools
ESLint, test runner, coverage reporter, npm audit. These produce structured data — error counts, pass/fail, coverage percentages.
Runs locally in your CI
Milliseconds execution
Zero cost — your own tools
Layer 2
Flow Business Rules
Expression-based rules enforce thresholds on the tool data. No lint errors, coverage above 80%, PR not too large — all deterministic.
11 rules in this demo
~10ms evaluation
Update rules without deploys
Layer 3
AI Judge
LLM evaluates the diff against criteria rules can't express — SRP, error handling patterns, naming conventions, security practices.
5 criteria in this demo
2-5 second evaluation
No LLM API key needed

Layer 2 — 11 Business Rules

These rules run on every submission. They enforce team standards on the structured data produced by your CI tools.

No lint errors

!lint || lint.errors === 0

Lint warnings under threshold

!lint || lint.warnings <= 10

All tests must pass

!tests || tests.failed === 0

Test coverage >= 80%

!tests || !tests.coverage || tests.coverage >= 80

No high/critical vulnerabilities

!security || security.high === 0

PR title is descriptive

!pr.is_pr || pr.title.length >= 10

PR is not work-in-progress

!pr.is_pr || !pr.title.toLowerCase().startsWith("wip")

PR description required

!pr.is_pr || pr.description.length > 20

File count limit (<= 20)

pr.files_changed <= 20

Line count limit (<= 500)

pr.additions + pr.deletions <= 500

No .env files committed

!files || !files.some(f => f.includes(".env"))

Layer 3 — 5 AI Judge Criteria

These criteria are evaluated by an LLM against the actual diff. Each returns pass/fail with a confidence score and reasoning.

1.

Functions should follow the Single Responsibility Principle — each function does one thing well

2.

Error handling should use specific error types, not generic catch-all blocks

3.

New code should follow the existing naming conventions in the codebase

4.

Database queries should use parameterized inputs, not string concatenation

5.

Public API endpoints should validate input and return appropriate error codes

Persona: "senior code reviewer specializing in code quality, security, and maintainability"

On fail: Route to human review (not hard-reject)

Get started in 3 commands

Clone the repo, set up the gate, run a review. That's it.

1
Set your Rynko API key
free tier works
export RYNKO_API_KEY=rk_...
2
Create the code-review gate
one-time setup
node setup-gate.mjs
Creates gate with 11 deterministic rules + 5 AI Judge criteria
3
Run a review
node cli.mjs
Collects diff, runs tools, submits to Flow, returns combined verdict

What you get back

One API call returns a structured response with results from all three layers.

Flow Gate Response — code-review
schema: pass
rules: pass
ai_judge: fail
{
  "success": false,
  "runId": "run_8f2a3c...",
  "status": "pending_approval",
  "validation_id": "val_4f546e...",
  "layers": {
    "schema": "pass",
    "business_rules": "pass",
    "ai_judge": "fail"
  },
  "aiJudgeVerdict": {
    "criteria": [
      { "criterion": "SRP", "verdict": "pass", "confidence": 0.95 },
      { "criterion": "Error handling", "verdict": "fail", "confidence": 0.88,
        "reasoning": "Generic catch(err) on line 42 — use AppError" },
      { "criterion": "Naming conventions", "verdict": "pass", "confidence": 0.91 },
      { "criterion": "Parameterized queries", "verdict": "pass", "confidence": 0.97 },
      { "criterion": "Input validation", "verdict": "pass", "confidence": 0.85 }
    ],
    "overall": "fail",
    "summary": "4 of 5 criteria passed"
  }
}
AI Judge failed with aiJudgeOnFail: "review" → routed to human approval instead of hard-rejecting

Drop into any CI pipeline

GitHub Actions, GitLab CI, or any CI that runs Node.js.

.github/workflows/code-review.yml
name: Code Review
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - run: npm ci
      - run: node tools/rynko-review/cli.mjs --ci
    env:
      RYNKO_API_KEY: ${{ secrets.RYNKO_API_KEY }}

One gate

Schema + rules + AI Judge all configured in one place

Full audit trail

Every review logged with payload, verdicts, and reviewer decisions

Update without deploys

Change rules and criteria in the dashboard — no CI changes needed

Build your own review pipeline.

The code-review demo is just one gate. Create gates for any validation use case — invoices, contracts, content, orders.

Start freeRead the docs

No credit card required · 500 free runs/month · AI Judge on paid tiers