Agile Analysis with AI

About Course

Turn what you want software to do into examples and tests that guide development with AI. Learn to clarify business rules, define strong contracts, and establish expected behavior before generating code—so your team can catch misunderstandings earlier and build with greater confidence.

MAKE EXPECTATIONS SOMETHING WE CAN EXAMINE TOGETHER

One of my favorite moments in development is when a simple example reveals that we’ve been imagining different things. We can all agree that a requirement sounds reasonable and still disagree about what the software should actually do. Working through examples gives us a way to discover those differences while they’re still easy to resolve.

AI can be a wonderful partner in that conversation. It can suggest another case, point out an ambiguity, or help us express an expectation as a test. Our job is to decide whether those examples capture the behavior we need—and whether the tests would tell us if that behavior were wrong.

In Agile Analysis with AI, we’ll explore how to make that understanding explicit. We’ll move between the user’s experience and the responsibilities inside the software, use examples to clarify business rules, and turn agreed expectations into tests before asking AI to implement them.

This is a development skill I want every explorer to have: being able to say what success looks like clearly enough that people can discuss it and tests can check it. It gives our collaboration with AI a direction and a way to recognize progress.

WHAT THIS CAN CHANGE FOR YOUR TEAM

As a developer, you’ll have a way to guide implementation with behavior you’ve already considered and reviewed. Instead of trying to assess a large amount of generated code all at once, you can work through a small, coherent behavior with clear expectations about what it must do.

If you’re investing in your team’s development, this shared understanding matters. Discovering an ambiguous rule before implementation can save a difficult conversation after delivery. Tests that express agreed behavior also give the team something concrete to revisit as requirements change. The aim is less avoidable rework, more focused verification, and software that remains easier to change.

Tests still need our judgment. We’ll ask what mistake each assertion would catch, whether a test is coupled to implementation, and what could still go wrong even when the tests pass.

WHAT WE EXPLORE

Outside-In and Inside-Out Development
What does someone need from the software, and what responsibilities will make that possible? We’ll explore these complementary perspectives and distinguish understanding the problem from designing a solution. Moving between them helps us keep user intent and internal behavior connected without committing to implementation too soon.

OOAD Revised for AI
We’ll revisit object-oriented analysis and design through Specification by Example. Concrete cases help us identify entities, assign responsibilities, and clarify how objects should behave. We’ll use AI to explore examples and challenge assumptions while we decide what belongs in the model.

Behavior-Driven Development with AI
How do we turn a conversation about a feature into expectations everyone can examine? We’ll use Given–When–Then examples to make conditions, actions, and outcomes explicit. We’ll discuss choosing cases that introduce meaningful distinctions, including boundaries and failures, and expressing behavior without prescribing its implementation.

Test-First Development with AI
We’ll bring those examples into executable tests and review them before generating production code. The increment can be a small set of tests specifying one coherent behavior. We’ll explore strong interface contracts, confirming that tests fail for the intended reason, and using Red–Green–Refactor to implement and improve the solution incrementally. The tests guide what we build while giving us regression protection as the design evolves.

THE LEARNING EXPERIENCE

I teach through examples, diagrams, questions, and conversation. We’ll examine requirements that appear clear until we try to specify them, compare possible assertions, and discuss how AI can help us find gaps in our thinking.

Bring the questions you’re encountering in your own development. Together, we’ll practice asking, “What would demonstrate this behavior?” and “What mistake would this assertion keep us from making?” These are small questions with a useful effect on how we build.

WHO IT’S FOR

This course is for software developers who want to clarify behavior before implementation and work with AI at the speed of understanding. Developers serving as technical leads or architects will find ways to help their teams discuss requirements, review tests, and establish stronger contracts. Attending together helps a team develop a common language for what “working” means.

FORMAT AND MATERIALS

Four hours of live online instruction, including discussion, brief exercises, and breaks. Take it as a standalone private team course or as the second course in the AI Developer Essentials curriculum.

You’ll receive a PDF of the course slides, with substantive key points, examples, diagrams, and AI micro-habits to revisit after class. Extended coding labs are a separate, optional offering under development.

YOUR INSTRUCTOR

I’m David Scott Bernstein, author of Beyond Legacy Code and founder of The Passionate Programmer and To Be Agile. I’ve trained more than 10,000 professional developers in Extreme Programming, software design, test-first development, and writing changeable code.

I’ve valued test-first development for years because it helps me think about behavior before implementation. I’m excited to share how that practice can help us collaborate with AI—and how AI can help us examine our expectations more carefully.

LET’S TALK ABOUT YOUR TEAM

If your team is generating code faster than it can confidently verify it, I’d enjoy hearing about your experience. We can explore how clearer examples, stronger contracts, and test-first practices might help, and whether this course or the full curriculum would be useful for you.

Schedule a conversation with me: https://passprog.com/schedule-a-call/

Show More

What Will You Learn?

  • • Use outside-in and inside-out perspectives to connect user needs with software responsibilities.
  • • Clarify entities, behaviors, and business rules through Specification by Example.
  • • Express expected behavior with Given–When–Then examples, including relevant boundaries and failures.
  • • Select assertions that catch meaningful mistakes without unnecessarily coupling tests to implementation.
  • • Define interface contracts and review behavioral tests before asking AI to generate code.
  • • Use a small, coherent set of tests to guide incremental implementation and refactoring.
  • • Confirm that tests fail for the intended reason and identify questions that passing tests leave unanswered.

Want to receive push notifications for all major on-site activities?

✕