Code Review & Refactoring

Review a diff for correctness and risk, and act on feedback you receive

Measure technical debt in business terms and decide what to fix first

Review pull requests and local branches with parallel reviewers and validated findings

Handle code review feedback with technical rigor and verify before claiming success

Review code in React, Vue, Rust, Go, Python and over twenty other stacks

Walk through code or text files one at a time to explain or show your changes

Check code review feedback for accuracy before applying suggested changes

Review local git diffs or pull requests for correctness, security and maintainability

Audit a TypeScript codebase and adopt typed Result error handling with TaggedError

Apply shared coding standards and patterns to TypeScript, JavaScript, React and Node

Migrate a TypeScript codebase from better-result 2.x to the 3.0 API

Auto-format and lint code on every file edit with automatic fixes

Write idiomatic Python that follows PEP 8 with type hints and clear structure

Refactor research scripts into documented, reproducible workflows for sharing

Turn performance findings into evidence-backed recommendations and decisions

Manage performance baselines and compare results across versions

Run sequential benchmarks with fixed run lengths to confirm regressions

Map entrypoints and hot code paths before profiling performance issues

Log structured performance investigation notes and evidence as you go

Profile CPU and memory hot paths and produce flame graphs

Generate performance hypotheses from git history and code evidence

Run controlled performance experiments to test each hypothesis

Set up ESLint 9 flat config with neostandard and migrate from legacy eslintrc

Design generic types, type guards and utility types and fix TypeScript compiler errors

Review code logging patterns and recommend evlog adoption for entry points

Profile and tune application performance across backend and frontend layers

Review system designs and code changes for architectural integrity and scalability

Refactor code for clarity, SOLID design and maintainability

Rank technical debt by maintenance cost, delivery impact and risk

Combine static analysis with model-assisted review for security and correctness

Review code for security flaws, performance problems and production reliability

Refactor code toward clean code and SOLID design for better maintainability

Rank technical debt by maintenance cost, delivery impact and risk

Combine code, architecture, security, performance and testing reviews into one assessment

Map the most important functions in a codebase before making changes

Coordinate parallel code, security and performance reviewers and merge their results

Plan and run migrations across frameworks, languages and APIs with compatibility checks

Plan incremental dependency upgrades with breaking-change analysis and regression tests

Modernize legacy systems incrementally with the strangler fig pattern

Scaffold TypeScript projects with build tools, type checks and tests

Modernize legacy codebases incrementally and cut technical debt safely

Cut Python memory use with generators, efficient structures and leak fixes

Speed up grid searches and batch jobs across CPU cores with joblib

Optimize app performance with tracing, load tests and Core Web Vitals monitoring

Combine static analysis with model-assisted review for security and correctness

Coordinate parallel code, security and performance reviewers and merge their results

Convert sequential Python loops into multiprocessing, threading or asyncio code

Balance work across workers with dynamic partitioning and work stealing

Review uncommitted changes, date ranges or branches for bugs and regressions first