MCPInstall

typescript-react-reviewer

Expert code reviewer for TypeScript + React 19 applications. Use when reviewing React code, identifying anti-patterns, evaluating state management, or assessing code maintainability. Triggers: code review requests, PR reviews, React architecture evaluation, identifying code smells, TypeScript type safety checks, useEffect abuse detection, state management review.

Installs
9K
Last 24h
—
Trending rank
—
Security
Pass

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/dotneet/claude-code-marketplace --skill typescript-react-reviewer
  1. 01

    Install

    Run the command in your project. The CLI asks which agents to install for.

  2. 02

    Describe the task

    Ask your agent for something this skill covers. It loads typescript-react-reviewer automatically when relevant.

  3. 03

    Review the result

    The agent follows the SKILL.md steps, scripts and references bundled with the skill.

Security audits

Independent scans of the skill's instructions and bundled files.

Gen Agent Trust Hub PassSAFE ·The TypeScript + React 19 Code Review Expert skill is a comprehensive collection of instructional markdown files providing guidance on identifying React anti-patterns, utilizing React 19 hooks correctly, and maintaining TypeScript safety. No malicious patterns, obfuscation, or data exfiltration vectors were detected.
Socket PassNo alerts
Snyk PassLOW ·Risk: LOW · No issues
Runlayer PassNONE ·4 files scanned · No issues
ZeroLeaks PassNONE ·Score: 93/100 · 2 sections analyzed

SKILL.md

The instructions your agent reads when the skill is triggered.

TypeScript + React 19 Code Review Expert

Expert code reviewer with deep knowledge of React 19's new features, TypeScript best practices, state management patterns, and common anti-patterns.

Review Priority Levels

🚫 Critical (Block Merge)

These issues cause bugs, memory leaks, or architectural problems:

IssueWhy It's Critical
useEffect for derived stateExtra render cycle, sync bugs
Missing cleanup in useEffectMemory leaks
Direct state mutation (.push(), .splice())Silent update failures
Conditional hook callsBreaks Rules of Hooks
key={index} in dynamic listsState corruption on reorder
any type without justificationType safety bypass
useFormStatus in same component as <form>Always returns false (React 19 bug)
Promise created inside render with use()Infinite loop

⚠️ High Priority

IssueImpact
Incomplete dependency arraysStale closures, missing updates
Props typed as anyRuntime errors
Unjustified useMemo/useCallbackUnnecessary complexity
Missing Error BoundariesPoor error UX
Controlled input initialized with undefinedReact warning

📝 Architecture/Style

IssueRecommendation
Component > 300 linesSplit into smaller components
Prop drilling > 2-3 levelsUse composition or context
State far from usageColocate state
Custom hooks without use prefixFollow naming convention

Quick Detection Patterns

useEffect Abuse (Most Common Anti-Pattern)

// ❌ WRONG: Derived state in useEffect
const [firstName, setFirstName] = useState('');
const [fullName, setFullName] = useState('');
useEffect(() => {
  setFullName(firstName + ' ' + lastName);
}, [firstName, lastName]);

// ✅ CORRECT: Compute during render
const fullName = firstName + ' ' + lastName;
// ❌ WRONG: Event logic in useEffect
useEffect(() => {
  if (product.isInCart) showNotification('Added!');
}, [product]);

// ✅ CORRECT: Logic in event handler
function handleAddToCart() {
  addToCart(product);
  showNotification('Added!');
}

React 19 Hook Mistakes

// ❌ WRONG: useFormStatus in form component (always returns false)
function Form() {
  const { pending } = useFormStatus();
  return <form action={submit}><button disabled={pending}>Send</button></form>;
}

// ✅ CORRECT: useFormStatus in child component
function SubmitButton() {
  const { pending } = useFormStatus();
  return <button type="submit" disabled={pending}>Send</button>;
}
function Form() {
  return <form action={submit}><SubmitButton /></form>;
}
// ❌ WRONG: Promise created in render (infinite loop)
function Component() {
  const data = use(fetch('/api/data')); // New promise every render!
}

// ✅ CORRECT: Promise from props or state
function Component({ dataPromise }: { dataPromise: Promise<Data> }) {
  const data = use(dataPromise);
}

State Mutation Detection

// ❌ WRONG: Mutations (no re-render)
items.push(newItem);
setItems(items);

arr[i] = newValue;
setArr(arr);

// ✅ CORRECT: Immutable updates
setItems([...items, newItem]);
setArr(arr.map((x, idx) => idx === i ? newValue : x));

TypeScript Red Flags

// ❌ Red flags to catch
const data: any = response;           // Unsafe any
const items = arr[10];                // Missing undefined check
const App: React.FC<Props> = () => {}; // Discouraged pattern

// ✅ Preferred patterns
const data: ResponseType = response;
const items = arr[10]; // with noUncheckedIndexedAccess
const App = ({ prop }: Props) => {};  // Explicit props

Review Workflow

  1. Scan for critical issues first - Check for the patterns in "Critical (Block Merge)" section
  2. Check React 19 usage - See react19-patterns.md for new API patterns
  3. Evaluate state management - Is state colocated? Server state vs client state separation?
  4. Assess TypeScript safety - Generic components, discriminated unions, strict config
  5. Review for maintainability - Component size, hook design, folder structure

Reference Documents

For detailed patterns and examples:

  • react19-patterns.md - React 19 new hooks (useActionState, useOptimistic, use), Server/Client Component boundaries
  • antipatterns.md - Comprehensive anti-pattern catalog with fixes
  • checklist.md - Full code review checklist for thorough reviews

State Management Quick Guide

Data TypeSolution
Server/async dataTanStack Query (never copy to local state)
Simple global UI stateZustand (~1KB, no Provider)
Fine-grained derived stateJotai (~2.4KB)
Component-local stateuseState/useReducer
Form stateReact 19 useActionState

TanStack Query Anti-Pattern

// ❌ NEVER copy server data to local state
const { data } = useQuery({ queryKey: ['todos'], queryFn: fetchTodos });
const [todos, setTodos] = useState([]);
useEffect(() => setTodos(data), [data]);

// ✅ Query IS the source of truth
const { data: todos } = useQuery({ queryKey: ['todos'], queryFn: fetchTodos });

TypeScript Config Recommendations

{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitReturns": true,
    "exactOptionalPropertyTypes": true
  }
}

noUncheckedIndexedAccess is critical - it catches arr[i] returning undefined.

Immediate Red Flags

When reviewing, flag these immediately:

PatternProblemFix
eslint-disable react-hooks/exhaustive-depsHides stale closure bugsRefactor logic
Component defined inside componentRemounts every renderMove outside
useState(undefined) for inputsUncontrolled warningUse empty string
React.FC with genericsGeneric inference breaksUse explicit props
Barrel files (index.ts) in app codeBundle bloat, circular depsDirect imports

FAQ

What does the typescript-react-reviewer skill do?

Expert code reviewer for TypeScript + React 19 applications. Use when reviewing React code, identifying anti-patterns, evaluating state management, or assessing code maintainability. Triggers: code review requests, PR reviews, React architecture evaluation, identifying code smells, TypeScript type safety checks, useEffect abuse detection, state management review.

How do I install typescript-react-reviewer?

Run npx skills add https://github.com/dotneet/claude-code-marketplace --skill typescript-react-reviewer in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/typescript-react-reviewer/ (personal) or .claude/skills/typescript-react-reviewer/ (project).

Which AI agents can use typescript-react-reviewer?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is typescript-react-reviewer safe to install?

Security partners have reviewed it: Gen Agent Trust Hub passed; Socket passed; Snyk passed; Runlayer passed; ZeroLeaks passed. As with any skill, read the SKILL.md and bundled scripts before installing.

Who maintains typescript-react-reviewer?

It is published by dotneet in dotneet/claude-code-marketplace. It has 8,956 recorded installs.

More from dotneet/claude-code-marketplace

View all →

prompt-improver

dotneet/claude-code-marketplace

A skill for improving prompts by applying general LLM/agent best practices. When the user provides a prompt, this skill outputs an improved version, identifies missing information, and provides specific improvement points. Use when the user asks to "improve this prompt", "review this prompt", or "make this prompt better".

AI & Agents508 installs

code-modularization-evaluator

dotneet/claude-code-marketplace

Open the skill to read its SKILL.md instructions.

460 installs

perplexity-search

dotneet/claude-code-marketplace

Open the skill to read its SKILL.md instructions.

455 installs

google-calendar

dotneet/claude-code-marketplace

Open the skill to read its SKILL.md instructions.

call-cursor-agent

dotneet/claude-code-marketplace

Open the skill to read its SKILL.md instructions.

445 installs

context7

dotneet/claude-code-marketplace

Open the skill to read its SKILL.md instructions.

411 installs

Popular code quality & workflow skills

View category →

grill-me

mattpocock/skills

A relentless interview to sharpen a plan or design.

Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.

handoff

mattpocock/skills

Compact the current conversation into a handoff document for another agent to pick up.

domain-modeling

mattpocock/skills

Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a GLOSSARY.md, or recording or editing an ADR.

codebase-design

mattpocock/skills

Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

diagnosing-bugs

mattpocock/skills

Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.