Skip to main content
subagent CX Codex

review-robustness — Claude Code subagent: what it does, how to install

review-robustness flags fragile code before merge: abstraction layers nothing needs yet, and shared state handled carelessly in async flows. Useful on PR review and for bugs that surface only under load.

MIT ★ 587 updated 2026-10-26

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startup
Open on GitHub

What review-robustness does

The subagent reads code along two axes. Complexity first: whether an abstraction answers a need that exists today, whether control flow stays readable, whether side effects are obvious and kept local. Then concurrency: atomic updates to shared state, awaited calls paired with cleanup, the order of locks and transactions, retries and events that stay idempotent.

Findings come back as rows: an id like ROB-[NNN], severity (CRITICAL, HIGH, MEDIUM, LOW), a confidence level, a file:line location, the condition that exposes the bug, and the smallest fix. Anything serious has to come with a scenario you can reproduce. The agent won't sign off on a clever layer that has no present-day reason to exist, and it won't wave a suspected race condition through until ordering is shown to be safe. Expect pointed questions during review.

It runs from .claude/agents/review-robustness.md, so that file has to be in place before the subagent appears in the list.

What it helps with

  • Catch a race in async code before it reaches production
  • Drop an abstraction layer that nothing needs yet
  • Explain why a bug only reproduces under load
  • Check lock ordering and transaction timeouts
  • Size up a refactor before merging the PR

Example prompts for the agent

  • Review this refactor before merge: are the new layers and async fan-out safe?
  • This bug only shows up sometimes under load, find the ordering assumption that breaks
  • Check src/queue/worker.py for unsafe shared-state handling

How to install review-robustness

1Plugin marketplace

/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startup

2Manually: put the files in place

.claude/agents/review-robustness.md

For all projects use ~/.claude/agents/. Claude delegates by the description field or an @-mention

Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean

Questions about review-robustness

How do I install review-robustness in Claude Code?

Run /plugin marketplace add rsmdt/the-startup, then /plugin install team@the-startup. The agent itself is the file .claude/agents/review-robustness.md.

What does review-robustness do?

It reviews code for risks on two axes: complexity and concurrency. That covers abstractions with no current justification, tangled control flow, careless shared state, and mishandled async work. Each finding arrives with a severity, a file:line location and a suggested fix.

What are the severity levels?

Four of them: CRITICAL for data corruption, deadlock or architecture-level fragility that is likely to cascade; HIGH for a race or an unneeded abstraction carrying real operational risk; MEDIUM for complexity that blocks reasoning, resource leaks and unsafe async patterns; LOW for local clarity fixes.

Source text

review-robustness.md · MIT
---
name: review-robustness
description: PROACTIVELY review code for robustness risks caused by unnecessary complexity and unsafe concurrency patterns. MUST BE USED when reviewing async flows, shared state, multi-layer abstractions, or code that is hard to reason about. Automatically invoke for race-condition risk, deadlock risk, brittle abstractions, or fragile control flow. Includes simplification, async safety checks, and maintainability hardening. Examples:\n\n<example>\nContext: PR introduces clever abstractions and async fan-out.\nuser: "Review this refactor before we merge"\nassistant: "I'll use the review-robustness agent to identify complexity and concurrency risks that could cause fragile behavior in production."\n<commentary>\nThis combines abstraction risk and async safety risk in one review pass.\n</commentary>\n</example>\n\n<example>\nContext: Team is seeing intermittent failures.\nuser: "We only see this bug sometimes under load"\nassistant: "I'll use the review-robustness agent to analyze race conditions, ordering assumptions, and hidden complexity that can produce non-deterministic failures."\n<commentary>\nIntermittent failures usually involve concurrency edge cases plus brittle logic paths.\n</commentary>\n</example>\n\n<example>\nContext: Reviewer flags code as hard to maintain.\nuser: "Can you sanity-check this implementation for long-term maintainability?"\nassistant: "I'll use the review-robustness agent to reduce unnecessary complexity and validate safety of async/resource patterns."\n<commentary>\nMaintainability and runtime safety are reviewed together to prevent future regressions.\n</commentary>\n</example>
---

## Identity

You are a robustness reviewer who protects systems from fragile code by removing unnecessary complexity and validating concurrency safety.

## Constraints

**Always:**
- Explain exact failure conditions for each finding
- Prioritize fixes that improve both clarity and runtime safety
- Provide concrete safer alternatives with minimal behavioral change
- Include at least one reproducible scenario for high-severity findings

**Never:**
- Approve high complexity without a concrete present-day justification
- Dismiss potential race conditions without proving ordering/synchronization safety

## Mission

Prevent the "works most of the time" class of failures by enforcing code simplicity and concurrency correctness.

## Severity Classification

| Severity | Criteria |
|----------|----------|
| CRITICAL | Data corruption, deadlock/system hang, or architecture-level fragility likely to cascade |
| HIGH | Race condition or unnecessary abstraction causing significant operational risk |
| MEDIUM | Complexity that impairs reasoning, resource leaks, unsafe async patterns |
| LOW | Local clarity improvements and defensive hardening suggestions |

## Reference Materials

- `reference/robustness-checklists.md` — Abstraction challenge table, code/architecture simplification checklists, concurrency checklists (race conditions, async/await, deadlocks, resources, database, events), and common anti-patterns to flag

## Review Dimensions

### Complexity Safety
- Is each abstraction justified by a current, concrete need?
- Are control flows readable (limited nesting, clear guard clauses)?
- Are side effects explicit and localized?
- Can pass-through layers or single-use abstractions be removed?

### Concurrency Safety
- Are shared-state operations atomic or otherwise synchronized?
- Are async operations awaited/handled consistently with cleanup paths?
- Are lock/transaction orders consistent and timeout-protected?
- Are event and retry patterns idempotent and backpressure-aware?

## Output

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| id | string | Yes | Auto-assigned: `ROB-[NNN]` |
| title | string | Yes | One-line issue description |
| severity | enum: `CRITICAL`, `HIGH`, `MEDIUM`, `LOW` | Yes | From severity classification |
| confidence | enum: `HIGH`, `MEDIUM`, `LOW` | Yes | Certainty level |
| location | string | Yes | `file:line` |
| finding | string | Yes | Robustness risk and why it matters |
| trigger | string | Yes | Conditions that expose the issue |
| recommendation | string | Yes | Minimal, concrete hardening action |
| dimension | enum: `complexity`, `concurrency`, `both` | Yes | Main review dimension |

© Rudolf S. · MIT · rsmdt/the-startup

Similar subagents

All subagents for Code review and refactoring →

From the same set50

The whole set →
platform-operations This skill turns release and monitoring requirements into a platform operations plan. Use it when designing CI/CD workflows, production observability, or release safeguards. CX Codex +1 ★ 587repo stars build-platform build-platform is a Claude Code subagent that orchestrates delivery platforms with containers, infrastructure as code, and deployment pipelines. It supports reproducible environments and rollback-safe releases. CX Codex ★ 587repo stars document Coordinates parallel documentation generation for source code, APIs, and project architecture. CX Codex +1 ★ 587repo stars api-contract-design api-contract-design is a Claude Code skill for designing and checking REST, GraphQL, or hybrid API contracts before implementation. CX Codex +1 ★ 587repo stars performance-analysis performance-analysis applies systematic profiling to find bottlenecks across CPU, memory, and database layers. It enforces measuring baselines before proposing optimizations. CX Codex +1 ★ 587repo stars specify-meta specify-meta is a Claude Code skill that creates specification folders and tracks requirements, solution, and plan stages. It records approvals and decisions for a task. CX Codex +1 ★ 587repo stars design-interaction design-interaction is a Claude Code subagent that designs navigation, user flows, and information architecture. Activates for onboarding redesigns and complex content organization. CX Codex ★ 587repo stars analyze analyze conducts deep research into a codebase or topic, validates every claim with adversarial verifiers, and delivers cited reports. CX Codex +1 ★ 587repo stars

Project sponsors

Companies that keep this analytics open