use-case-modeling

Model actor-goal use cases with preconditions, triggers, paths, and durable postconditions.

4|Updated May 16, 2026
One-click install
npx skills add https://github.com/machenjie/rd-skills --skill use-case-modeling
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: use-case-modeling
Source: https://github.com/machenjie/rd-skills/tree/main/src/foundation/capabilities/use-case-modeling
Command: npx skills add https://github.com/machenjie/rd-skills --skill use-case-modeling

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It eliminates ambiguity between stakeholder goals and implementation by converting actor-centered goals into precisely specified, testable behavioral contracts with clear preconditions, triggers, alternate paths, and durable postconditions.

Core Features & Use Cases

  • Fully-dressed use case specification: Define an actor-goal interaction with explicit scope, preconditions, trigger, main path, alternate paths, failure paths, and postconditions.
  • Durable, testable postconditions: Express outcomes as system state changes, emitted events, or externally observable side effects rather than UI text.
  • Traceability through business-rule linkage: Require named business rules referenced by ID so designs and tests can be verified against authoritative rules.
  • Risk-aware modeling: Model external systems as actors with trust-boundary preconditions and failure handling, including idempotency and state preservation.

Example use case: a billing workflow where a customer subscribes successfully through the main path but also needs explicit modeling for webhook duplicates, coupon validation failures, and payment timeouts to ensure acceptance criteria and recovery behavior are unambiguous.

Quick Start

Use this skill to model a complete, actor-goal use case for your change by describing the primary actor, their goal, the entry preconditions, the trigger, and what durable system state or events must exist when the use case succeeds or fails.

Frequently Asked Questions about use-case-modeling

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

FAQPage Schema
How do I write use case acceptance criteria based on durable system state instead of UI messages?

Express use case acceptance criteria as durable postconditions like system state changes, emitted events, or externally observable side effects rather than relying on transient UI text. This ensures outcomes remain testable and unambiguous across implementation changes.

How do I model alternate paths and failure handling for external system interactions?

Model external systems as actors with explicit trust-boundary preconditions and dedicated failure paths. This risk-aware approach handles webhook duplicates, payment timeouts, and state preservation by enforcing idempotency and complete recovery behavior for every external interaction.

What is a fully-dressed use case template for defining actor-goal behavior?

A fully-dressed use case template specifies an actor-goal interaction with explicit scope, preconditions, triggers, main paths, alternate paths, failure paths, and durable postconditions. It converts stakeholder goals into precisely specified, testable behavioral contracts.

How do I link business rules to use case paths for traceability?

Reference named business rules by ID directly within your use case specification. This enforces traceability so designs and tests can be verified against authoritative rules and guarantees that behavioral paths satisfy named rule constraints.

Does use case modeling work for billing workflows with coupon validation and payment timeouts?

Use case modeling handles billing workflows by specifying a main path for successful subscription while explicitly modeling alternate paths for coupon validation failures and payment timeouts, ensuring acceptance criteria and recovery behavior remain unambiguous.

When should I not use UI text as a use case postcondition?

Avoid using UI text as a postcondition when acceptance criteria must be derived directly from durable behavioral guarantees. Relying on UI messages creates brittle tests; instead, specify state changes or emitted events to ensure complete, testable outcomes for every path.