review-runtime-reliability-performance

Analyze pull request diffs for failure semantics, concurrency lifecycle, and performance scalability risks.

Updated Mar 3, 2026
One-click install
npx skills add https://github.com/D3Hunter/ai-engineer --skill review-runtime-reliability-performance
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: review-runtime-reliability-performance
Source: https://github.com/D3Hunter/ai-engineer/tree/main/skills/review-runtime-reliability-performance
Command: npx skills add https://github.com/D3Hunter/ai-engineer --skill review-runtime-reliability-performance

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Merging code changes with unaddressed failure semantics, concurrency lifecycle, or performance scalability gaps leads to production outages, data integrity issues, and system collapse under load. This Skill eliminates the risk of missing these critical issues during pull request review by providing a structured, static-analysis-first evaluation flow.

Core Features & Use Cases

  • Structured Failure Semantics Review: Evaluates error contracts, retry/timeout/cancellation behavior, and silent failure paths for API handlers, async workers, and external dependency calls.
  • Concurrency Lifecycle Safety Checks: Assesses synchronization discipline, cancellation safety, bounded parallelism, and graceful shutdown logic to prevent data races, deadlocks, and resource leaks.
  • Performance and Scaling Risk Assessment: Identifies algorithmic anti-patterns, N+1 access issues, tail latency risks, and overload collapse vulnerabilities before they reach production.
  • Use Case: When reviewing a PR that adds a new payment processing async worker, this Skill flags missing idempotency guarantees for retries, unbounded parallelism that could exhaust worker pools under high load, and lack of cancellation handling that leaves in-flight tasks running during deployment.

Quick Start

Use the review-runtime-reliability-performance skill to review the pull request diff at /your/repo/path for failure semantics, concurrency lifecycle, and performance risks, and output the findings to review-findings.json.

Frequently Asked Questions about review-runtime-reliability-performance

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

FAQPage Schema
How do I catch concurrency and reliability issues in a pull request before merge?

Static analysis of pull request diffs can catch concurrency and reliability issues before merge by evaluating synchronization discipline, error contracts, and cancellation safety against a structured checklist. This process generates severity-rated findings for engineering teams.

What is a static analysis checklist for failure semantics in async workers?

A failure semantics checklist for async workers evaluates error contracts, retry and timeout behavior, and silent failure paths. It ensures external dependency calls and API handlers handle cancellation safely and maintain idempotency guarantees during retries.

How do I find performance scalability and overload risks in code review?

Finding performance scalability risks in code review involves identifying algorithmic anti-patterns, N+1 access issues, and unbounded parallelism. Static analysis flags tail latency risks and overload collapse vulnerabilities in API handlers and dependency call paths.

Does static analysis work for reviewing bounded parallelism and graceful shutdown logic?

Static analysis works for reviewing bounded parallelism and graceful shutdown logic by assessing concurrency lifecycle safety in diff files. It identifies data races, deadlocks, and resource leaks without requiring a running environment.

What is the best way to output code review findings for runtime reliability to engineering teams?

The best way to output runtime reliability code review findings is a standardized JSON payload. This format captures severity-rated findings and actionable change requests for failure semantics, concurrency, and performance risks.

When do I need static analysis for N+1 access and tail latency risks?

You need static analysis for N+1 access and tail latency risks when reviewing pull requests that add API handlers or external dependency call paths. It prevents performance scalability gaps and overload collapse vulnerabilities from reaching production.