From Stories to Systems: Mastering Use-Case 2.0 for Agile and AI-Driven Development

Introduction

In the rapidly evolving landscape of software development, the tension between agility and structure has long been a central challenge. For decades, teams have oscillated between heavyweight documentation that ensures completeness but stifles speed, and lightweight user stories that promote velocity but often sacrifice context. As systems grow in complexity and the demand for rapid delivery intensifies, neither extreme alone suffices.

Enter Use-Case 2.0: a modern evolution of requirements engineering that bridges this gap. Born from the foundational principles of traditional use cases but reimagined through the lens of Agile methodologies like Scrum and Kanban, Use-Case 2.0 offers a lightweight yet scalable approach to capturing user needs. It integrates the simplicity of user stories with the comprehensive structure of use cases, providing teams with a clear roadmap from high-level goals to detailed implementation.

This case study explores how Use-Case 2.0 transforms requirement gathering, design, and development. By examining its core principles, practical applications, and synergy with emerging AI-assisted development tools, we demonstrate how this methodology enables teams to build the right system efficiently, ensuring value delivery at every increment.

---

The Evolution of Requirements Engineering

For almost thirty years, use cases have served as a cornerstone of requirements engineering, helping teams understand how users interact with systems to achieve their goals. They inspired many modern techniques, including user stories. But in recent years, something remarkable has happened—the inspiration has flowed in the other direction.

Use-Case 2.0 is the new generation of use-case-driven development—light, agile, and lean—inspired by user stories and the agile methodologies Scrum and Kanban. It represents a significant evolution from traditional use-case practices, combining the simplicity and focus of user stories with the comprehensive structure and scalability that use cases have always offered.

“Use-Case 2.0 has all the popular values from the past—not just supporting requirements, but also architecture, design, test, and user experience—and it is instrumental in business modeling and software reuse.”

What Makes Use-Case 2.0 Different?

Traditional use-case methodology involved creating detailed use case documents that captured system behavior, including brief descriptions, preconditions, postconditions, and actor interactions. While effective, this approach often became documentation-heavy and struggled to adapt to the fast-paced iteration of Agile development.

Use-Case 2.0 builds on this foundation while introducing several innovations:

• Agile Alignment: Seamless integration with Agile methodologies, making it easier for development teams to collaborate with stakeholders, decompose requirements, and iterate rapidly

• User Stories Integration: Incorporation of user stories as a lightweight way to capture user needs and build shared understanding

• Use-Case Slices: Breaking complex use cases into smaller, manageable units that can be independently implemented and tested

• Visual Models: Emphasis on flowcharts, activity diagrams, and sequence diagrams for comprehensive system understanding

• Iterative Development: Testing each component as it’s built, enabling early problem detection

At its heart, Use-Case 2.0 introduces a critical new concept: the use-case slice. A slice is a carefully selected part of a use case that can be worked on independently—it slices through not just requirements, but also design, implementation, test cases, and test results.

Figure 1: Visual representation of Use-Case 2.0 structure showing the relationship between actors, use cases, and slices.

---

The Six Principles of Use-Case 2.0

Ivar Jacobson, Ian Spence, and Kurt Bittner identified six fundamental principles that form the foundation of successful use-case adoption:

1. Keep It Simple by Telling Stories

Storytelling is the simplest and most effective way to communicate what a system should do. Use cases capture the goals of the system, and stories cover how to achieve those goals and handle problems that occur along the way. This enables requirements to be easily captured, shared, and understood.

2. Understand the Big Picture

Whether your system is large or small, understanding the whole picture is essential. Without this overview, teams cannot make correct decisions about scope, cost, or value. A use-case diagram provides a simple way to present an overview of a system’s requirements—showing all the ways the system can be used, who starts the interaction, and any other parties involved.

Figure 2: A sample use-case diagram illustrating actors and their interactions with the system.

3. Focus on Value

Value is generated only when a system is actually used. Rather than focusing on long lists of functions or features, use cases concentrate on how the system will be used to achieve specific goals for particular users. The basic flow describes the simplest way to achieve the goal, while alternative flows add options and error handling. Teams can ship the basic flow first and add alternatives later—this is additive by design.

4. Build the System in Slices

Most systems require extensive work before they become usable. It’s a mistake to try building such a system in one go. Instead, systems should be built in slices, each delivering clear value to users.

The recipe is simple:

1. Identify the most useful thing the system must do

2. Slice it into thinner, manageable slices

3. Define test cases representing acceptance of those slices

4. Choose the most central slice that travels through the entire concept

5. Estimate it as a team and start building

5. Deliver the System in Increments

Software systems evolve through multiple generations and releases. Each increment should provide a demonstrable or usable version of the system. Use-Case 2.0 supports this by slicing use cases into work items that can be assembled into increments and ultimately into releases.

6. Adapt to Meet the Team’s Needs

There’s no one-size-fits-all solution in software development. Different teams and situations require different styles and levels of detail. Use-Case 2.0 can be as light as desired—small, collaborative teams can use lightweight use-case narratives on simple index cards, while large distributed teams can use more detailed documents.

---

The Anatomy of Use-Case 2.0: Slices, Scenarios, and Tasks

Three key concepts define how Use-Case 2.0 works in practice:

Use-Case Slices are smaller, more manageable components of a use case. Instead of defining an entire use case in one document, Use-Case 2.0 breaks it into slices that are easier to design, develop, and test. Each slice represents specific functionality the system must perform to support a particular user task or goal.

Scenarios represent the various paths users might take to complete tasks within a slice:

• Normal Path: The expected or standard sequence of operations (the “happy path”)

• Alternative Paths: Variations or different ways to achieve the same goal

• Exception Paths: Error or abnormal situations that may occur

Tasks are the specific actions users must perform within a scenario to achieve a goal. They represent the individual steps that make up a scenario.

For example, in an e-commerce platform’s “Browse Products” use-case slice:

• Normal Path: User searches, views results, selects product, adds to cart, proceeds to checkout

• Alternative Path: User selects a different payment method (PayPal instead of credit card)

• Exception Path: Payment is declined due to insufficient funds or incorrect billing address

 

Figure 3: Detailed breakdown of a use-case slice showing normal, alternative, and exception paths.

---

Use Cases vs. User Stories: Why Both Matter

This is where Use-Case 2.0 offers a compelling solution to a common Agile challenge.

A user story is a standalone item—it has no built-in relationship to other stories. A product backlog of 200 user stories becomes difficult to navigate without additional grouping mechanisms like epics or themes. Stories can lose context, and teams often write acceptance tests too late.

A use case is different. It groups all related stories under one goal, with:

• A clear goal (the use case itself)

• A step-by-step flow (the basic flow)

• Defined variations (alternative flows)

• Acceptance criteria (test cases)

When you look at a use case, you see the full picture of how a user achieves a specific goal, not just a single fragment.

Figure 4: Comparison chart highlighting the differences and complementary nature of user stories and use cases.

---

Use-Case 2.0 in Agile Practice: Real-World Examples

Use-Case 2.0 provides structure for Agile teams facing common challenges:

E-Commerce Platform: Use cases for an online shopping system include Browse Products, Search Products, Add to Cart, Proceed to Checkout, and Make Payment. The early use-case diagram reveals missing flows—like “Guest Checkout”—that can be added before sprint commitment, preventing cart abandonment issues in production.

Mobile Banking App: Documenting alternative flows like “invalid credentials → multi-factor fallback” catches security gaps early, avoiding costly post-launch patches and building user trust.

Ride-Sharing Service: Use-case slices drive MVP development—start with request, accept, and pay; then add ratings and complaints in later iterations. This enables fast value delivery with clear prioritization.

Healthcare Appointment Platform: Stakeholder review of use-case flows uncovers “no-show handling” requirements. Automated rescheduling can be added, potentially reducing missed appointments.

Figure 5: Example of an Agile team using use-case slices to plan sprints.

---

The AI Connection: Use-Case 2.0 Meets AI-Assisted Development

Use-Case 2.0 was originally developed in 2011, long before AI coding assistants existed. But its principles are proving to be a perfect match for AI-assisted development.

AI coding assistants work best with clear, structured specifications. A use case provides:

• A clear goal for the AI to understand

• A step-by-step flow for the AI to implement

• Defined variations for the AI to handle

• Acceptance criteria for the AI to satisfy

The four phases of AI-assisted development map naturally onto Use-Case 2.0’s principles:

• Inception → “Understand the big picture” — create business requirements and initial use-case diagrams

• Elaboration → “Focus on value” — write specifications with basic and alternative flows

• Construction → “Build the system in slices” — with AI, the unit of work can be the whole use case specification, not just a slice

• Transition → “Deliver the system in increments” — user acceptance testing confirms use cases fulfill stakeholder needs

Figure 6: Illustration of how AI assistants integrate with Use-Case 2.0 workflows.

---

Getting Started with Use-Case 2.0

You don’t need to adopt the full Use-Case 2.0 practice at once. Start with three things:

1. Draw a use-case diagram — Identify the actors and use cases for your system. This takes 30 minutes and gives you the big picture.

2. Write one use-case narrative — Pick the most important use case. Write the basic flow as a bulleted outline. List the alternative flows as names only initially.

3. Implement your first use case — Whether you use manual development or AI assistance, let the use case guide your implementation.

You can track use cases on a simple spreadsheet or on post-it notes. No special tooling is needed to get started with Use-Case 2.0.

---

Conclusion

Use-Case 2.0 is not a replacement for user stories—it’s a complement. Use cases give you the big picture and the structure. Test cases give you a clear definition of done. For manual development, slices give you right-sized work items.

The key insight is that use cases include the techniques provided by user stories while offering significantly more for larger systems, larger teams, and more complex developments. They are as lightweight as user stories but can scale in a smooth, structured way to incorporate as much detail as needed. Most importantly, they drive and connect many other aspects of software development.

In an era where AI is transforming how we build software, Use-Case 2.0 provides the structured, user-focused foundation that ensures we build the right system—not just a system that works. By embracing this evolved methodology, teams can achieve greater clarity, efficiency, and value delivery in their Agile journeys.

---

References

1. Use-Case 2.0: The Agile Evolution of Requirements Engineering: Comprehensive overview of Use-Case 2.0 principles and practices.

2. Integrating Use Cases with Agile Methodologies: Guide on combining use cases with Scrum and Kanban.

3. The Power of Use-Case Slices: Detailed explanation of slicing techniques in Use-Case 2.0.

4. AI-Assisted Development and Structured Requirements: Exploration of how AI tools benefit from structured use cases.

5. Visual Modeling in Agile Projects: Best practices for using diagrams in Agile environments.