// tools

Interactive code intelligence tools — analyzers, scanners, and reference tools we're building to measure and improve code quality.→ View full roadmap

def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[0]
left = [x for x in arr[1:] if x <= pivot]
right = [x for x in arr[1:] if x > pivot]
return quick_sort(left) + [pivot] + quick_sort(right)
InteractiveIQ 87

Code IQ Analyzer

Live

Multi-dimensional intelligence scoring — cyclomatic complexity, cognitive complexity, documentation density, error handling coverage, type safety, and structural hygiene. Paste any snippet and get a composite Code IQ score with full visual breakdown.

Static AnalysisComplexityPythonTypeScriptRust
def process_data(items):
results = []
for i, item in enumerate(items):
# TODO: dedup this block
temp = transform(item)
temp = validate(temp)
results.append(temp)
Interactive$2,450

Tech Debt Calculator

Live

Estimate technical debt from code patterns: duplicated blocks, dead code, overly long functions, high cyclomatic complexity, and missing error handling. Outputs a dollar-value remediation estimate and prioritized refactor queue.

Quality MetricDebt AnalysisPythonJavaScriptTypeScript
import parseGraph from './parser'
import detectCycles from './analysis'
import render from './force'
// src/utils → src/analysis → src/parser → src/utils
const cycles = detectCycles(graph)
render(graph, highlight: cycles)
Interactive13→19

Dependency Graph Visualizer

Live

Parse a codebase's import graph and render an interactive dependency map. Highlights circular dependencies, orphan modules, and tightly coupled clusters. Supports Python, JS/TS, Rust, Go.

ArchitectureGraphPythonTypeScriptRustGo
def legacy_parse(src):
return src.split(',')
# dead-code: legacy_parse never imported
# orphan: format_bytes (0 refs)
# unreachable: stmt after return in cleanup
# stale: from utils import old_util
# deletion queue: 6 findings, −214 LOC
Interactive−214 LOC

Dead Code Detector

Live

Detect unused exports, orphan functions and types, unreachable statements, statically dead branches, and stale imports across Python, JavaScript, and TypeScript. Runs a transitive dead-code cascade and outputs a risk-ranked deletion queue with per-item LOC cost.

Static AnalysisDead CodePythonJavaScriptTypeScript
$ git log --numstat --date=short
# @@@a1b2c3 | ada | 2026-09-28 | fix cache eviction
42 7 src/store/cache.ts
11 3 src/api/client.ts
# cache.ts: 3 commits, 3 authors, 67% fixes
# entropy 1.58 bits · recent weight 2.71
# risk 91 · critical · change next
Interactiverisk 91

Code Churn Forecaster

Live

Paste a git log and rank every file by change risk — commit activity, recency-weighted activity, churn volume, author entropy, and fix ratio blended into a 0–100 score with a risk heatmap and a click-to-expand ranked table. Static heuristics over past change patterns: it predicts instability, not defects.

PredictiveGit HistoryRisk HeatmapPythonTypeScript
def slugify(title):
slug = title.lower().strip()
for ch in slug:
if not ch.isalnum():
slug = slug.replace(ch, '-')
return slug
# py → js: function slugify(title) …
Interactivepy → js

Language Transpiler

Live

Rewrite a documented subset of Python into JavaScript and back — def/function, indentation/braces, if/elif/else, range and for..of loops, builtins, and operators. Unsupported constructs are left verbatim and flagged per line in an annotations panel; a static rewrite table, not a compiler.

TranspilerCode TransformPythonJavaScript
# refactor: inline variable 'tax'
def compute_total(prices):
total = 0
- tax = total * 0.08
- grand = total + tax
+ grand = total + (total * 0.08)
# 2 changes · 1 warning · diff preview
Interactiveinline

Refactoring Assistant

Live

Apply deterministic refactorings — rename symbol, inline variable, extract function, convert to arrow function, replace var with let — to a pasted snippet and preview a line-level diff. Scope-unaware heuristics with honest warnings; no parser, no network.

CodemodRefactorDiff PreviewPythonJavaScriptTypeScript
$ git diff --staged
# +94 −12 across 5 files
# src/api/client.ts: add retry + backoff
feat(api): add retry with backoff
- client.ts +18 −4: retry, jitter
- config.ts +6 −1: retry opts
# rule: "new export in prod path" → feat
Interactivefeat(api)

Commit Message Generator

Live

Paste a git diff and get a Conventional Commits message — inferred type and scope, an imperative summary, grouped body bullets, and a breaking-change footer. Deterministic diff parsing with per-rule reasoning shown; review before you commit.

Git UtilityConventional CommitsDiff ParsingGitDeveloper Tools
$ stylecheck greet.ts --target prettier
# indentation: 2 spaces ✓
# quotes: 6 single / 2 double ✗
# trailing-comma: 1 array missing ✗
# line-length: longest 93 > 80 ✗
# score 74 · grade drifting
# 3 warnings · 0 errors · copy report
Interactivescore 74

Code Formatter Comparator

Live

Paste a source file and check it against Prettier, Black, gofmt, or rustfmt conventions. Twelve deterministic text rules produce a per-rule findings list with line numbers, a 0–100 consistency score, and a rule-by-rule comparison of how the four formatters differ.

Style AnalysisFormattersPythonJavaScriptGoRust
app.get('/users/:id', (req, res) => …)
# express.route: app.get( → fastify.get(
# express.res-status: res.status(200) → reply.code(200)
# express.request-property: req.params → request.params
# MANUAL REVIEW: app.listen is async in Fastify
# MANUAL REVIEW: app.use needs register / plugin design
# coverage 50% · rule-table coverage, not correctness
Interactive50%

API Migration Mapper

Live

Rule-based rewrites for Express 4 → Fastify and React class → hooks, plus a custom rename table. Every change gets a line-numbered finding; anything outside the rule tables goes to a MANUAL REVIEW list and is never rewritten. No parser or type checker — a review aid, not a migration tool.

Version UpgradeMigrationExpressReactJavaScriptTypeScript
# input: 2,000 random ints · seed 1337
A insertion sort median 1.240 ms
B merge sort median 0.600 ms
# checksums agree (n=2000)
# A exponent 1.86 ≈ quadratic
# B exponent 1.09 ≈ linear
# array ops: only indexed access, post-copy blind
Interactive2.07×

Algorithm Benchmark Runner

Live

Run two JavaScript implementations on one seeded input and compare wall-clock statistics, a Proxy-counted array-access total, and a growth exponent fitted across a size ladder. Warm-up passes, a sink checksum and inputs prepared outside the timer answer the four classic microbenchmark lies; this-tab-only and “estimate, not proof” limits are printed on the page.

BenchmarkingComplexityperformance.nowJavaScriptNo Backend

// more-tools-coming

We're building a full suite of code intelligence tools. Next on the list:Big-O Analyzer and Regex Builder.

Check the Tools Roadmap →for the complete build plan across Code Analysis, Code Transformation, Benchmarking & Performance, and Code Reference categories.