review-react-codebase-red-flags

Reviews React and TypeScript codebases for maintainability red flags and produces severity-ranked audit reports.

Updated Apr 28, 2026
One-click install
npx skills add https://github.com/GregM1991/skills --skill review-react-codebase-red-flags-gregm1991
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: review-react-codebase-red-flags
Source: https://github.com/GregM1991/skills/tree/main/skills/review-react-codebase-red-flags
Command: npx skills add https://github.com/GregM1991/skills --skill review-react-codebase-red-flags-gregm1991

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? React codebases accumulate hidden maintainability risks—god components, state misuse, TypeScript drift, broken memoization—that compound until refactors become dangerous. This Skill audits a codebase for these red flags and produces an evidence-backed report with prioritized, incremental fixes. ## Core Features & Use Cases - Systematic red-flag scanning: Covers dependencies, folder organization, components, props, state and context, TypeScript hygiene, hooks, rendering, and error handling. - Severity-ranked audit report: Classifies findings as High, Medium, or Low with file paths, concrete evidence, impact explanation, and the smallest safe next step. - Refactor guidance: Recommends incremental corrections such as splitting god components by responsibility, isolating third-party libraries behind adapters, and fixing context re-render storms. - Use Case: Before planning a major refactor, run this audit on a legacy React app to identify which files carry the highest correctness and change-amplification risk, then sequence fixes by severity. ## Quick Start Ask the AI to review your React codebase for maintainability red flags and return a severity-ranked audit report with file-level evidence.

Frequently Asked Questions about review-react-codebase-red-flags

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I audit a React codebase for code smells?▼

Run a structured review that scans dependencies, folder structure, components, state management, TypeScript usage, hooks, and error handling. Inspect representative files behind each suspected pattern, then report findings by severity with file paths, evidence, and the smallest safe fix.

What are common React maintainability red flags?▼

Common red flags include god components, derived values stored in state, one massive Context causing re-render storms, array index keys, any types and disabled exhaustive-deps lint rules, empty catch blocks, and missing error boundaries or loading states.

How do I find unnecessary dependencies in a React project?▼

Check for libraries doing what vanilla JavaScript handles, heavy packages where lighter alternatives exist, and third-party APIs imported directly throughout app code instead of behind local adapters. Inspect actual call sites before recommending removal.

When should I split a large React component?▼

Split when a named responsibility or seam becomes clearer, not by line count alone. God components that mix data fetching, state orchestration, and rendering are prime candidates; extract presenters, predicates, or policy helpers as separate modules.

Does this review approach work with any React project structure?▼

Yes. The review first maps the project's own conventions—package scripts, lint config, TypeScript config, and routing structure—then judges consistency against those conventions rather than imposing one canonical React structure.

When should I not add memoization in React?▼

Avoid memoizing everything. Memoize only when identity affects child renders, context provider values, expensive calculations, or hook dependency stability. Default object, array, or function values that break memoization should be fixed at the source instead.