Skip to content

Cohort Session 3 Build Run and Loops

github-actions[bot] edited this page Oct 2, 2026 · 2 revisions

Session 3 · Build, run and the loops

How is it built in proven slices, run in production, and kept honest by the eight loops?

Part of the Cohort Kit. Ninety minutes. The session that turns the spec into a plan: by the end the room has a bolt order for the first slice, knows which loops close by themselves and which three nobody is waiting on, and has the evidence pack for the P1 to P2 hand-off written out.

Pre-reading (about 40 minutes)

Bring. The spec from session 2's homework, with the reviewer's mark on the one thing that could not be built as written.

You will leave with. A bolt plan for the first slice, a named owner for each of the three loops that does not close itself, and the P1 to P2 evidence pack as a checklist.

Run-sheet

Minutes Block Do this Material
0–10 Recap What is a bolt? What closes the trust loop? Which three loops need an owner? What crosses the P1 to P2 hand-off? —
10–35 The idea The loop map on screen: ask the room which loops the team already runs, under other names. Then the Day 30 episode, where the first bolt ships by four in the afternoon, and the evidence page, so the room sees what "done" looks like Loop map · Day 30 · the first bolt · The evidence pack
35–65 Exercise Pairs do D1 · ordering bolts by dependency on the team's spec, then D4 · a bolt that cannot be built alone. Then B2 · chained probability on the candidate's own step count, so the room feels why short chains matter before anyone proposes a long one D1, D4 · B2 · Sprint-to-bolt planner
65–80 Decision The room fixes the first three bolts, in order, each with the check that proves it; names an owner for the drift, cost and learning loops; and ticks the P1 to P2 evidence pack against what actually exists The minimum artefact set · Templates · engineering
80–90 Close Homework named. One sentence each: which loop does your team currently not run, and who should own it? —

Facilitator notes

  • A bolt is not a small story. The test is "can it be built alone and proven alone". The room will propose bolts that depend on two others; D4 exists to catch that. Draw the dependency arrows on the board.
  • B2 lands hardest on the architects. Four steps at 90% is 66% end to end. If the candidate's design has six model calls in a row, this is where somebody says so. Let them.
  • The three loops nobody is waiting on are drift, cost and learning. Every team has an owner for the build loop and none for these. Names on the board, not roles.
  • Ten-minute version: the loop map with the room naming what it already does, then D1 on the spec.

Homework

The bolt plan for the first slice, in the engineering lead's template, with the proof for each bolt written before the bolt. If the team has a repository, the first bolt is opened as a ticket with the proof in its description.

Next

Session 4 · Methods decoded — where AI-DLC, AIDD, BMAD and spec-driven development actually sit, and how much process each change needs. Back to Session 2.

🗺️ Navigate

🏠 Wiki Home

▶ Start

▶ Start here · 55 lessons, on the site ↗

  1. Getting started · 2
  2. Agentic PDLC fundamentals · 9
  3. Methods decoded · 7
  4. Running delivery · 13
  5. By role · 9
  6. Teams and organisation · 4
  7. Practice · 4
  8. Interviews and careers · 7

📗 Method and reference

The method
The Agentic PDLC
The Eight Loops
Gates & Governance
The Evidence Pack

The journey · end to end
Product manager
Solution architect
Engineering lead
QA lead
DevOps & platform

The method · by role
Product manager
Solution architect
Engineering lead
QA lead
DevOps and platform
Sponsor

How to
Run an NFR workshop
Design an agent on paper
Build, buy or borrow
Cut sprints into bolts
Review by risk band
Prove the bar
Control the token bill
Hold the security boundary
Run a missing-control postmortem

Reference
Mental Models
Glossary
Formulas & Calculators
Decision Trees
Scenario Library
Exercises & Answers
Anti-Patterns
Sources & Confidence
Where do I find…?


📚 Course and labs

The course companion · Labs

The 16 modules
  1. Agentic Foundations
  2. LLM Intuition and the AWS Bridge
  3. Amazon Bedrock Essentials
  4. Amazon Bedrock Agents
  5. Agent Builder, Knowledge Bases and Guardrails
  6. The Agent Loop: No Framework to Strands
  7. Strands Foundations: Tools, Memory and MCP
  8. Multi-Agent Patterns with Strands
  9. LangChain and LangGraph
  10. LLM Memory Mechanics
  11. RAG, OpenSearch and LiteLLM
  12. Amazon Bedrock AgentCore
  13. A2A and A2UI: Agent Interoperability
  14. Agentic QA and Evaluation
  15. End-to-End Production Pipeline
  16. Agentic Product Lifecycle

Learning paths · Field guide
Study Plans


🎓 Cohort kit

Cohort Kit · Session template

Eight sessions
  1. Kick-off
  2. Frame and spec
  3. Build, run and the loops
  4. Methods decoded
  5. Plan and review
  6. Prove and ship
  7. Govern and scale
  8. Practice and roles

💬 Community and maintenance

Living notes
Error Index
Community Answers
Field Notes
Model & Region Notes
Cost Log
Scoreboard 🧪

The project
Roadmap
Editing this wiki
Maintainer Runbook


📦 Elsewhere

📘 The manual · live
🛫 Ninety Days, the simulator
🧰 The workbench
👔 For leadership
🧠 Mental models
Templates · Prompts
Frameworks & acronyms
The repository · Setup

Pinned discussions
Discussion map — where to post what
Exercise & lab index
Simulator Arena — get a lab graded
Pitch an idea
All discussions →

Clone this wiki locally