RubyCritic alternativeadd AI review, keep the metrics
RubyCritic grades your Ruby code for complexity, duplication, and smells - a static health report, not a reviewer. It is worth keeping for exactly that. This page is about the layer it does not cover: an AI pass that reasons about the change itself, on pull requests.
Verdict
The short version
RubyCritic is a well-loved open source gem: it wraps established Ruby static analysis to grade files, classes, and methods from A to F, tracking complexity, duplication, and smells. As a map of where your codebase hurts, it is genuinely useful.
Its limits are structural, not bugs. It measures what the code looks like, not what the code does. A callback that breaks an invariant, a method that leaks credentials into logs, a refactor that lowers complexity and introduces a race - RubyCritic scores all of them politely.
CodeCritic adds the missing layer: AI reasoning on the pull request diff, with the context files and policies you choose, explained in plain language and posted where the team reviews - PR comments from the GitHub Action, or results over the REST API.
The honest positioning: keep RubyCritic for structural health over time, and add AI review for correctness and security on every change. One measures the codebase; the other reads the change.
Comparison
CodeCritic vs RubyCritic
Different categories by design - this table maps the division of labor.
| Feature | CodeCritic | RubyCritic |
|---|---|---|
| Category | AI review on the pull request diff | Static analysis report |
| Output | Findings with explanations and suggested fixes | Grades, complexity and duplication metrics, smell lists |
| Determinism | Probabilistic - findings need triage | Deterministic - same input, same report |
| Scope | The change under review, plus context files | The whole codebase's structural health |
| Where it runs | GitHub Action, web paste, REST API, editor extensions | CLI and CI |
| Keep both? | Yes - it complements the metrics | Yes - keep it for structural health |
Based on public docs and pricing pages as of October 2026 - verify against vendor pages before you buy.
Where RubyCritic is strong
Reasons it should stay in your toolchain.
- A-F grades make structural hot spots visible at a glance, which is great for planning refactors.
- Tracks complexity and duplication over time, so decay is a number instead of a feeling.
- Free and open source, with no service dependency and trivial CI integration.
- Built on established Ruby static analysis, so the smells it reports are well understood.
Where CodeCritic adds the layer
What the AI pass sees that metrics do not.
- Reasoning about the change: broken invariants, auth gaps, and Rails-specific risks like N+1 queries and unsafe strong params.
- Plain-language findings with suggested fixes, posted as PR comments where the team already discusses the merge.
- Review policies encode team standards - path excludes, security bars, test rules - applied to every diff.
- Review without a repo: paste a diff in the browser or call the REST API from your own tooling.
When the metrics alone are enough
Said plainly, because sometimes they are.
- You only need structural health signals - complexity, duplication, churn hot spots - tracked over time.
- Determinism is a hard requirement for your gate: same commit, same report, every run.
- The codebase is small enough that grades and review discipline keep it honest on their own.
How the two layers divide the work
Run RubyCritic on a schedule or in CI as the structural dashboard: it tells you which files are accumulating complexity and which refactors would pay off. Its value compounds over months, not per pull request.
Run AI review on every pull request as the reasoning layer: it reads the diff the way a careful reviewer would and explains what could go wrong. Pilot it in report-only mode on one repository and judge the signal before you let it comment on everything.
FAQ
Common questions
Keep the grades, add the reviewer
Run CodeCritic free on a private Ruby repo in report-only mode and see what the AI pass catches beyond static metrics.