agentsclimarketplace

Deliver edge cases

Skill product-on-purpose/pm-skills/skills/deliver-edge-cases

Documents edge cases, error states, boundary conditions, race conditions, and recovery paths for a feature - the systematic catalog of what can go wrong and the failure modes to design for. Use during specification to map the failure surface and ensure comprehensive coverage, or during QA planning to identify boundary and limit scenarios to test. Distinct from deliver-acceptance-criteria, which writes story-level Given/When/Then checks; this skill produces the whole-feature edge-case catalog.From its SKILL.md

Install
npx -y skills add product-on-purpose/pm-skills --skill deliver-edge-cases

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

What its file declares

Copied from the file, not written here

The file declares its own license as Apache-2.0. That is the author’s claim about this one file, and it is not the same thing as the license GitHub reports for the repository, which is listed with the other numbers below.

SKILL.md

4.2 KB, 737 tokens by cl100k_base, as published. Nobody here has run it

<!-- PM-Skills | https://github.com/product-on-purpose/pm-skills | Apache 2.0 -->

Edge Cases

An edge cases document systematically catalogs the unusual, boundary, and error scenarios for a feature. While happy-path flows are typically well-specified, edge cases often get discovered in production - causing bugs, poor user experience, and support burden. Documenting edge cases upfront ensures engineering handles them intentionally and QA knows what to test.

When to Use

  • When you need to enumerate failure modes, race conditions, timeouts, and boundary or limit scenarios - everything that can go wrong - and define a recovery path for each
  • During feature specification before engineering begins
  • When preparing QA test plans
  • After discovering production bugs to prevent similar issues
  • When reviewing PRDs or user stories for completeness
  • Before launch to ensure error states have been designed

When NOT to Use

  • You need story-scoped Given/When/Then checks for handoff -> use deliver-acceptance-criteria; this skill catalogs the whole feature's failure surface
  • The feature is not specified enough to enumerate inputs, states, and limits -> use deliver-prd first
  • A production incident already happened and you want the learning banked -> use iterate-lessons-log, then update this catalog with the new case
  • You need readiness coordination for a launch, not failure analysis -> use deliver-launch-checklist

Instructions

When asked to document edge cases, follow these steps:

  1. Define the Feature Scope Clearly describe what feature or flow you're analyzing. Edge cases are specific to context - the same input might be valid in one feature and invalid in another.

  2. Walk Through Input Validation Consider every user input: What if it's empty? Too long? Wrong format? Contains special characters? What are the minimum and maximum valid values?

  3. Explore Boundary Conditions Find the edges of acceptable ranges. If a field accepts 1-100, test 0, 1, 100, and 101. Consider pagination boundaries, timeout thresholds, and rate limits.

  4. Map Error States Identify what can go wrong: network failures, permission denied, resource not found, concurrent modifications, expired sessions. Document both the scenario and expected behavior.

  5. Consider Concurrency Issues What if two users act simultaneously? What if the user double-clicks? What if data changes between load and save? Race conditions often cause subtle bugs.

  6. Define Recovery Paths For each error, specify how users recover. What message do they see? Can they retry? Is data preserved? Good error handling turns frustration into confidence.

  7. Prioritize by Likelihood and Impact Not all edge cases need the same attention. High-likelihood + high-impact cases need robust handling; rare + low-impact cases might just need graceful failure.

Output Format

Use the template in references/TEMPLATE.md to structure the output. A complete edge-case catalog fills every template section: Feature Overview; Edge Case Categories; Error Messages; Recovery Paths; and Test Scenarios.

Quality Checklist

Before finalizing, verify:

  • All user inputs have validation edge cases documented
  • Boundary conditions are explicitly listed
  • Network/system failure scenarios are covered
  • Each error state has a defined user-facing message
  • Recovery paths are specified (not just error detection)
  • Edge cases are prioritized by likelihood and impact

Examples

See references/EXAMPLE.md for a completed example.

What ships with it: 5 files

18.8 KB alongside SKILL.md

references/

Gives 0 of the 12 instructions most plan spec skills give in 737 tokens

Counted across 1,360 of the 2,617 authors here whose files we hold, read 2026-09-06

  • Ask one question at a timein 73 of 1360
  • Write the spec using the templatein 22 of 1360
  • Ask clarifying questions if neededin 19 of 1360, across 18 files
  • Wait for user confirmation before proceedingin 19 of 1360
  • Save plans to the plans directoryin 17 of 1360, across 13 files
  • Check for product marketing context firstin 16 of 1360, across 5 files
  • Read the plan file completelyin 16 of 1360
  • Order tasks by dependencyin 16 of 1360
  • Gather context from the conversationin 15 of 1360, across 9 files
  • Explore the codebase instead of askingin 15 of 1360, across 13 files
  • Wait for explicit user approvalin 14 of 1360, across 13 files
  • Quiz the user on the breakdownin 13 of 1360, across 7 files

Said here and by no other author read

  • Define the feature scope
  • Walk through input validation
  • Explore boundary conditions
  • Map error states
  • Consider concurrency issues
  • Define recovery paths

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once. Length counted with cl100k_base; the agent that loads this file may tokenize it differently.

Keep looking

Skills are one crate of 325,949. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.