This course teaches a cycle for building software modules: user story, then behavior-driven development (BDD), then functional reactive programming (FRP), then the chain end to end. Each turn of the cycle leaves one feature built, tested and launched, and the next feature starts it again.
Each module builds on the one before. The fourth carries one feature from its user story to launch. The fifth puts an agent to work on a business process, and the sixth carries the same principles into the protocols around AI and into Python and model training.
Module 1: Understanding user stories
- Objectives:
- Understand the importance of user-centric design.
- Learn to capture user requirements effectively.
- Translate user needs into user stories.
- Topics:
- Defining user stories.
- Identifying user needs.
- Writing clear and concise user stories.
- Activities:
- Practical exercises in creating user stories.
- Collaborative sessions to review and refine user stories.
Module 2: Behavior-driven development (BDD)
- Objectives:
- Explore the principles of BDD.
- Understand how BDD aligns development with user expectations.
- Learn to write BDD scenarios.
- Topics:
- Introduction to BDD.
- Given-When-Then (Gherkin) syntax.
- Writing BDD scenarios for software modules.
- BDD and unit testing.
- Running scenarios as tests.
- Activities:
- Creating BDD scenarios for real-world cases.
- Reviewing and enhancing BDD scenarios as a group.
Module 3: Functional reactive programming (FRP)
- Objectives:
- Master the fundamentals of FRP in software development.
- Discover how FRP enhances user interaction and responsiveness.
- Apply FRP concepts to software modules.
- Topics:
- Introduction to FRP.
- Event streams and reactive programming.
- Integrating FRP into a module.
- Activities:
- Folding a list of events into state by hand, with no library.
- Building software modules using FRP.
Module 4: The chain end to end
- Lessons:
- The API: Haskell Servant and Nile.
- From scenario to slice.
- Endpoints at the boundary.
- The view stays minimal.
- One feature, scope to launch.
- Objectives:
- Carry one feature from its user story through its scenarios, slice, endpoint and view to the API.
- Give each rule one home, the layer that holds it, and prove it there in a test named for its scenario.
- Take a feature from its written scope to the review against that scope before launch.
- Topics:
- A typed API over a pure core, with each tenant’s data kept apart.
- A slice built from a scenario’s events.
- Endpoints generated from one contract and decoded at the boundary.
- A view that reads, shows and forwards.
- Activities:
- Carrying one feature from its scope to launch, through a declined card.
Module 5: Business automation with AI (agentic skills)
- Lessons:
- Meetup talk: Business automation with SI (agentic skills).
- The agent loop and its tools.
- Writing an agentic skill.
- Automating a business process with a person in the loop.
- Objectives:
- Build an agent as software: a model in a loop with typed tools, tested against a scripted model.
- Package know-how as a skill the agent loads only when a task matches, with evals run before and after each change.
- Automate a business process end to end, with a person approving anything that leaves the building.
- Topics:
- Tools as typed contracts, a pure core that decides and stopping conditions as typed outcomes.
- A skill’s folder, its description and its instructions, loaded by progressive disclosure.
- An approval gate, tools allowed per task, and an email’s text treated as data, never as instructions.
- Activities:
- Automating an order typed into three systems, from its user story to handover.
Module 6: AI protocol ecosystem
- Lessons:
- Meetup talk: An advanced SI protocol ecosystem.
- The AI protocol map.
- Geometric reasoning as data.
- The tandem harness.
- Server and client in tandem.
- Extending the harness.
- Python, the team’s way.
- Measuring reasoning on the geometry.
- Geometric reasoning in model training.
- From fine-tune to release.
- Objectives:
- Place any AI protocol on a map of the joins it standardizes, and check a contract at every join.
- Model the behavior a model must show as points in a declared design space, and measure it there before any training.
- Run a model beside code that decides, and release it only on evidence weighed against the model it replaces.
- Topics:
- MCP, A2A, AGENTS.md, Agent Skills and OpenAPI, each placed at the join it standardizes.
- Factors declared once in JSON, with points and distance derived from them; evidence as a fact graph and matched families.
- A harness in Haskell Servant where the model proposes and typed code decides.
- A booking in two rounds on MCP’s multi round-trip shape, with signed request state used once.
- Behavior added at documented extension points, never by forking the core.
- Locked environments, frozen data, one config read once and contracts that report every fault.
- Paired probes, difficulty read cell by cell, and a full factorial over the probe sheets read as effects.
- Rows built from the prompts logged in serving, structured answers judged field by field, and voice pairs one trait apart.
- A gate per point against the model in service, one look per test set, splits by place, a declared base rule, then SFT and DPO.
- Activities:
- Recovering planted effects from a factorial table, then reading the probes’ own.
Where the course leaves you
By the end, a reader develops software modules in a cycle of user story, BDD and FRP, carries a feature through a typed API to launch, and puts an agent and a small model to work on the same principles. The lessons are revised as the team’s practice improves. Sean’s lectures run beneath every module, from The Simplest FP TypeScript Hello World to Modern Redux Architecture Patterns.
Welcome to Module 1, the next lesson, starts with the few sentences every feature begins as.
What a reader learns here goes into their own work, and from there into the work of everyone they build with.