bmad-review-edge-case-hunter

Trace control flow and state transitions to detect unhandled edge cases.

Updated May 13, 2026
One-click install
npx skills add https://github.com/Markuson/ivo_corr --skill bmad-review-edge-case-hunter-markuson
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: bmad-review-edge-case-hunter
Source: https://github.com/Markuson/ivo_corr/tree/main/.agents/skills/bmad-review-edge-case-hunter
Command: npx skills add https://github.com/Markuson/ivo_corr --skill bmad-review-edge-case-hunter-markuson

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the common oversight of missing boundary conditions and unhandled branching paths in code, specifications, or diffs by providing a mechanical, exhaustive review process.

Core Features & Use Cases

  • Exhaustive Path Tracing: Systematically walks through control flow, conditionals, and state transitions to identify missing guards.
  • Boundary Condition Detection: Identifies potential failures like off-by-one errors, null inputs, and arithmetic overflows.
  • Use Case: Use this during a pull request review to ensure that a new feature handles all possible error states and edge cases before it is merged into the production codebase.

Quick Start

Use the bmad-review-edge-case-hunter skill to analyze the provided code diff for any unhandled branching paths or boundary conditions.

Frequently Asked Questions about bmad-review-edge-case-hunter

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

FAQPage Schema
How do I find unhandled edge cases in a code diff?

To find unhandled edge cases in a code diff, you can mechanically trace control flow and state transitions to detect missing guards and boundary conditions like off-by-one errors. This process requires structured input content to generate a JSON array of execution failure findings.

What is exhaustive path analysis for software quality?

Exhaustive path analysis for software quality systematically walks through control flow, conditionals, and state transitions in code or specifications. It identifies missing error handling and boundary failures by mechanically tracing execution routes to ensure all branching paths are covered.

How do I detect boundary conditions like null inputs and arithmetic overflows during a code review?

Detect boundary conditions like null inputs and arithmetic overflows during a code review by applying mechanical path enumeration to your code. This identifies potential execution failures by systematically tracing loops and state transitions to expose missing guards in the logic.

Can I use this path analysis approach on software specifications instead of source code?

Yes, you can use this path analysis approach directly on software specifications. The process performs exhaustive path enumeration and boundary condition analysis on specifications to identify unhandled edge cases and missing error states before implementation begins.

What format does the input need to be for boundary condition detection?

The input format for boundary condition detection must be structured content, such as formatted code, specifications, or diffs. The analysis requires this structured input to mechanically trace control flow and output a JSON array of potential execution failures.