Release Notes

This course site is updated during the semester, and every meaningful update is published as a numbered release so you can see exactly what changed and when. The current version is shown in the footer of every page.

New entries appear at the top.

v2.12.10 (2026-10-22)

Diagrams that were missing now appear, and the belief-versus-truth figure in Finding and Validating the Problem is clearer about evidence.

Missing diagrams. Three diagrams showed only a caption over an empty box: the issue tree in Finding and Validating the Problem, and the diagrams in Specs: Designing the Build and Anatomy of an Application. All three now appear.
Belief-versus-truth figure. The shading inside the circles now matches the evidence bar: lighter means more evidence. The bar now runs the full height of the circles, with its mark on the dashed “enough evidence to act” line.
Two regions renamed. Founded Bet and Unfounded Hunch are now Correct Assumption and Wrong Assumption. Both rest on the same thin evidence, so from the inside they look the same, and only a test tells you which one you hold.
Evidence from building. The figure and the text now say that some evidence comes only from building a small version and putting it in front of customers.

v2.12.9 (2026-10-20)

The sprint rubric now says what a demo shows for each kind of work, how goals that depend on other people are graded, and exactly what the retro costs.

Goals that need someone else to say yes. Signing design partners, getting a customer to pay, or reaching signups is graded on the asks you made and can show: who you asked, when, what you asked for, and what they said. A no or a “not yet” costs no points when the ask is on record and your retro says what you learned. Selling and outreach now has its own row in the table of what output means.
What your demo shows. A new table on the Assessments page says what “working” means for each kind of sprint, from clicking through a product feature to opening your notes for research or showing your deck, asks, and pipeline for selling. Keep real names, emails, and phone numbers off the screen; open the copies in your repo with names removed instead.
Review. Any answer in your retro can respond to something specific in the report. Each question left unanswered costs 1 point, a retro that responds to nothing specific loses 2, and an empty retro earns at most half.
Sprint reports. The “How hard it was” line now says what difficulty did to your score.
Demo length. The sprint steps now say 2 to 3 minutes, matching the rubric.
These changes only raise scores, so Sprints 1 and 2 were regraded under them for the whole class. No score went down.

v2.12.8 (2026-10-20)

The Claude Code figure now describes its parts as layers, and the demo rules say how to share your Loom.

Directing the Agent. The Claude Code figure and its caption call its three parts layers instead of rings: the model, the built-in harness, and your harness as the outer layer.
Assessments. The demo rules, the deliverables table, and the rubric now say to make sure Professor Murff can see your video: in Loom’s Share settings, set it to “Anyone with the link” or share it with scott.murff@byu.edu. A video he cannot open is not graded until it is shared.

v2.12.7 (2026-10-20)

The three-ring figure in Directing the Agent names its permission step precisely.

Directing the Agent. The box between the model and its tools is now called the tool-call permission check, and the caption says what acts there: your PreToolUse hooks, then your permission rules, then the permission mode or a prompt to you.

v2.12.6 (2026-10-20)

The Claude Code map in Directing the Agent is clearer about settings and plugins.

Directing the Agent. In the three-ring figure, settings.json now lists permission rules, hooks, model, and effort. Plugins appear as a package from a marketplace that installs parts of your harness, drawn outside the rings with a dashed arrow.

v2.12.5 (2026-10-20)

Directing the Agent opens with a new map of Claude Code.

Directing the Agent. A new figure at the top of the chapter shows Claude Code as three rings: the model, the built-in harness, and your harness. Your harness is split into what the model reads (CLAUDE.md, rules files, output styles, auto memory, skills), what adds tools (MCP connections, subagents, workflows), and what the harness applies (settings.json: permission rules, hooks, the model, plugins). Plugins install parts of your harness.
New sections in Directing the Agent. Rules files (.claude/rules/, including rules that load only for matching files, and how they differ from permission rules), output styles, and workflows.

v2.12.4 (2026-10-19)

Testing the Design has a new quote on watching users.

Testing the Design. “What is Usability Testing?” now includes a post from Garry Tan, president and CEO of Y Combinator, on watching people use your software without saying anything, and a note on how his ten users fit the five-user rule.

v2.12.3 (2026-10-17)

The demo length scale now starts with Sprint 3.

Demo length. Aim for 2 to 3 minutes. A demo up to 3:30 loses no points. From Sprint 3, each started 30 seconds past 3:30 costs 1 point (3:31 to 4:00 is minus 1, 4:01 to 4:30 minus 2, 4:31 to 5:00 minus 3). Sprint 2 demos are not scored for length. Details are under “Demo length” on the Assessments page.

v2.12.2 (2026-10-17)

The fixed cap on routine work is removed.

No 15-of-20 cap. Routine work you comfortably finish no longer has a fixed cap on Output. Output is still weighed by how hard the work was for you, and an ambitious goal you partly reach and account for in your retro can still earn full marks. This applies from Sprint 2, whose grades are not yet released.

v2.12.1 (2026-10-16)

Sprint demos can now run longer.

Demo length. Aim for 2 to 3 minutes instead of 60 to 90 seconds. A demo up to 3:30 loses no points. From Sprint 4, each started 30 seconds past 3:30 costs 1 point. In Sprints 2 and 3, a demo past 3:30 loses at most 1 point. Sprint 6 aims for 3 to 4 minutes, with the line at 4:30. Details are under “Demo length” on the Assessments page.
Learn buttons. The setup link in the prompt they copy now points to “Update your course skills”.

v2.12.0 (2026-10-16)

Sprint reports can now open the exact passage that teaches each skill, and the practice exam is ready for /learn.

Your builder profile, explained. A new section on the Assessments page describes the profile in your sprint reports: six areas from 0 to 100, filled by your sprint work and the exams. The syllabus, Chapter 1, the Schedule and Builder Resources now point to it.
Highlighted passages. A link from your sprint report opens the chapter with the passages for that skill highlighted, and a bar at the bottom steps through them. Chapters 5 and 5b are tagged so far.
Practice exam. Practice Version A is available to /learn, which can also take a concept id, for example /learn DE02.
Questions about your sprint report. Reply to the Canvas comment your report came with. The Assessments page now says so.
Exam question types. The Assessments page now describes the three kinds of exam question the same way everywhere: know it, use it, predict it.
Chapter 2. A paragraph explains which settings file wins when two disagree.
Plainer writing. The book was edited throughout to say things directly, and a few headings were renamed. Old links to them still work.
Fixes and polish. The Schedule uses class numbers for each axis, old mentions of drills and quizzes are gone, and the Peer Code Review is turned in on Canvas.

v2.11.3 (2026-10-14)

Both exams now give full credit at 80% correct, and the final exam’s format is set.

Exam scoring. On the midterm and the final, points = 25 × (your percent correct ÷ 80%), up to 25. Scoring 80% or higher earns all 25 points.
Final exam format. The final is 84 questions in two hours. 72 count toward your score, weighted by axis: Agentic Workflow 16, Application Architecture 14, AI Systems 11, Discovery 11, Launch and Learn 11, and Design 9. The other 12 are unscored trial questions.
Results by axis. Each exam reports a result for each axis: Developing (below 50%), Proficient (50% to 79%), or Strong (80% and up).
Midterm question count corrected. The midterm is 36 questions. The Assessments page had said 40.
Schedule. The exam table on the Schedule page matches these changes.

v2.11.2 (2026-10-14)

Chapter 2 now explains every permission mode, lists the slash commands to know by name, and shows how to message your other sessions.

Chapter 2: Blast Radius. The permission modes table adds Don’t ask, and names the flag that starts Bypass permissions, --dangerously-skip-permissions. A new paragraph explains how auto mode decides: a second model reviews each action before it runs, and a boundary you state only in the chat can be lost when the conversation is compacted, so write a rule for any boundary that must hold. Another paragraph explains what still protects you in bypass mode and says to use it only in a container or virtual machine.
Chapter 2: Slash Commands. The table is now the commands to know by name, grouped by task: managing the conversation, setting up, controlling what Claude can do, extending Claude, working away from the keyboard, and checking work. New entries: /resume, /rename, /usage, /model, /effort, /btw, /exit, /add-dir, /sandbox, /skills, /plugin, /diff, /list-agents, /remote-control, and /voice.
Chapter 2: Your phone and your voice. How Remote Control lets you follow and reply to a session from the Claude mobile app while it runs on your computer, and how /voice lets you speak your prompts.
Chapter 2: Messaging your other sessions. A new subsection in Delegation and Parallel Work on how parallel sessions pass messages to each other, what /list-agents shows, and what a message can and cannot do.
Key Concepts for Chapter 2 add entries for auto mode, --dangerously-skip-permissions, and messaging your other sessions.
Four new references in the bibliography: the Claude Code documentation pages on permission modes, Remote Control, voice dictation, and messaging your other sessions.

v2.11.1 (2026-10-14)

Chapter 2’s section on reaching systems outside your repo now covers three routes an agent can use.

Chapter 2: Reach Beyond the Repo: CLI Tools, MCP, and APIs. A table compares the three routes (a CLI tool the agent runs in the terminal, an MCP server, and a direct API call the agent writes with your key), with an example of each, what each is good for, and what each costs. The section says which to try first, defines a connector as the Claude app’s name for an MCP server, and explains that a plugin is a package of skills, slash commands, subagents, hooks, and MCP servers, which is a way to install building blocks and not a fourth route.
Key Concepts for Chapter 2 add entries for the three routes, CLI, connector, and plugin.
Two new references in the bibliography: Anthropic’s introduction of the Model Context Protocol and the Claude Code plugins overview.

v2.11.0 (2026-10-12)

The left sidebar now has a Weeks view that walks through the course one class at a time.

Topics | Weeks switch in the sidebar. Weeks lists each class with its date and axis, the chapters to read for it, and what is assigned or due that week. The current week is open and marked “This week”, and it moves forward on its own each Monday. Topics is the chapter order you have used so far. The site opens on Weeks, and it remembers whichever view you choose.
Previous and next follow your view. In Weeks, the links at the bottom of a chapter go to the next reading in class order (for example, Anatomy of an Application leads to The Browser, Developer Tools, and Claude in Chrome, both read in week 7).
Learn in Claude buttons now sit on the sections that teach a core idea, and were removed from introductions, Key Concepts lists, tool tours, setup steps, and exercises. The syllabus now says that /learn tutors you on the section’s core idea.

v2.10.0 (2026-10-10)

A new Architecture appendix on the browser, and new sections in Chapters 1, 2, and 7 on hooks, the terminal, interfaces, and how requests cross the internet.

New appendix: The Browser, Developer Tools, and Claude in Chrome. What the browser does with HTML, CSS, and JavaScript; where an app keeps data (page memory, browser storage, or the database, and which to use); the five developer tools panels and the question each answers; and how to connect Claude in Chrome to Claude Code, what it can do, and what to watch. Assigned with Chapter 7 on Mon, Oct 26.
Chapter 7: How a Request Crosses the Internet. IP addresses, domains, and DNS; the parts of a URL; one request from browser to server and back, with the real text of the request; HTTPS; localhost and ports.
Chapter 1: a figure of one tool call that shows each step as a new request carrying the whole conversation; a clearer definition of the harness; a new section on ways to tell a computer what to do (CLI, GUI, API, natural language), with a figure of where each sits on your computer; and a section on the terminal, the shell, and shell scripts.
Chapter 2: hooks. A figure of when hooks fire and how one hook runs, step by step, and a close-up of PreToolUse. The running example is now a hook that blocks a commit until the changes are reviewed. New patterns for reminding Claude to update help docs, and a rule for when a hook should block and when it should only remind. The advice-versus-enforcement example now uses git push. The continuous integration figure uses standard terms.
Chapter 9: the trunk-based development figure now shows a team of two pushing to GitHub, including a rejected push and how it is resolved.
Appendix A3: working across several folders and sessions, in the terminal and the desktop app.

v2.9.0 (2026-10-10)

New appendix on Codex in the terminal and the ChatGPT desktop app, and scorecards comparing each CLI in VS Code with its desktop app.

New appendix, “Codex in the Terminal and the ChatGPT Desktop App.” The Codex desktop app is now Codex mode inside the ChatGPT desktop app. The appendix covers what the CLI and the app share, which commands work in each, what the app adds (worktrees, a review pane, a built-in browser, scheduled tasks), what only the CLI does, and how to move a chat between them.
New scorecards: the CLI in VS Code or the desktop app? Both the Claude Code and the Codex appendices now score the two setups on 12 everyday jobs, such as finding files, reviewing changes, previewing your app, and running several agents at once, and explain which setup does each job better.
“Claude Code and Other Coding Agents” links each desktop app row to its comparison.
Chapter 2: a new figure shows the four steps of one CI run (push, install packages, build, run tests) and why CI becomes the slowest step when an agent writes the code, with a table defining each term.

v2.8.2 (2026-10-10)

The coding agents appendix now scores how much harness each agent has.

New section, “How much harness does each one have?”: a 35-item checklist, grouped under the harness jobs from Chapter 1, scores Claude Code, Codex, Copilot CLI, and Antigravity CLI. A summary of what the scores show, and a panel with the full checklist and its limits, sit beside it.

v2.8.1 (2026-10-10)

The coding agents appendix now lists every command and every built-in tool for all four agents, and Computer Setup recommends VS Code extensions.

“Claude Code and Other Coding Agents”: the command tables now include every command from Claude Code, Codex, Copilot CLI, and Antigravity CLI, grouped by what each one does, so you can see which tools lack a command. A new table lists the tools each agent can call (such as Read, Edit, and Bash in Claude Code), which are the names permission rules and hooks match on.
New section, “Claude Code in the VS Code terminal,” in the terminal and desktop app appendix: what you gain by running claude inside VS Code, how your VS Code extensions help, and three things to know, including that text you select in the editor is sent with your prompt even from .env.
Computer Setup: a table of recommended VS Code extensions (ESLint, Prettier, Tailwind CSS IntelliSense, GitLens, and Python), with why each helps when you build with Claude Code.
Chapter 2, permission rules: explains why the Read(./.env) deny rule also matters in VS Code.

v2.8.0 (2026-10-10)

Two new appendices: one compares Claude Code with three other coding agents, and one compares Claude Code in the terminal with the desktop app.

New appendix, “Claude Code and Other Coding Agents.” Tables map what you learn in this course to Codex (OpenAI), Copilot CLI (GitHub), and Antigravity CLI (Google): what each costs, features, where files live, commands, and keys. It also shows how one repo can work with all four, and what changes for hooks and undo in each tool.
New appendix, “Claude Code in the Terminal and the Desktop App.” What the two share, what the desktop app adds (diff view, app preview, parallel sessions), what only the terminal does, and how to move a session between them.
Computer Setup, optional agents: Gemini CLI is replaced by Antigravity CLI, which took its place for personal Google accounts on June 18, 2026. Copilot CLI is listed with Copilot Student, which is free for verified students, and Codex now installs with OpenAI’s install script.
Chapter 1: the harness has a more concrete definition: the software that builds each request, sends it to the model, and carries out the tool calls. The figure matches.
Wording: Claude Code on the web is now called a cloud session, Anthropic’s current name, in Chapters 1 and 2.

v2.7.2 (2026-10-10)

Chapter 1’s tool-call figure now shows that each step is a new request.

One tool call, step by step: after a tool runs, Claude Code sends a new request with the whole conversation so far plus the result. The model keeps nothing between requests, and the loop ends when it replies without a tool call.
Wording: the model takes in text and images and writes text back, and every way of using Claude (web, mobile, desktop, and Claude Code) runs the same models.

v2.7.1 (2026-10-10)

The Learn in Claude button now works even if your repo does not have the /learn skill yet.

The button copies a short prompt instead of a /learn command. Paste it into Claude Code: if /learn is missing, Claude installs it from the builder template first, then starts the lesson.

v2.7.0 (2026-10-10)

Two new Design chapters: Design Fundamentals, read with class 5, and Specs, read with class 6.

New Chapter 5b, “Design Fundamentals,” required reading for class 5 (Mon, Oct 12). It covers how UI, UX, and product design differ; the Double Diamond; fidelity on two axes and what AI changed about it; design tools, including Figma and Claude Design; Norman’s design principles; information architecture; how people perceive a screen; visual fundamentals; and Nielsen’s usability heuristics.
New Chapter 6b, “Specs: Designing the Build,” required reading for class 6 (Mon, Oct 19). The spec material that was in Chapter 2 now lives here, in the Design section, along with the Agent Team Kit’s spec skills. A spec with user stories and acceptance criteria now counts as Design evidence.
Chapter 1 explains why there is no Build axis among the builder skills.
Chapter 3 adds disruptive innovation (Christensen), with the performance-over-time chart.
A Learn in Claude button now sits beside each section heading. It replaces the /learn boxes at the end of each section. Click it to copy the /learn command for that section, then paste it into Claude Code. The syllabus explains how it works.
The builder template adds /eli5, a picture explainer of how something works. /learn offers it when a picture would help.
Key Concepts lists are rewritten to match what each chapter now covers.
Agent Team Kit lessons added in Chapters 2, 5, 9, and 12.

v2.6.0 (2026-10-10)

Chapter 9 is now two chapters, and every chapter has been reread and clarified for readers who are new to the material.

Chapter 9 is split in two. Chapter 9, “Version Control, Environments, and Deploys,” covers Git, pull requests, environments, and deploys. The new Chapter 9b, “Tests and Tech Debt,” covers tests and technical debt. The class 8 reading list in the practice outlines includes both.
Every chapter was reread and clarified for readers seeing the ideas for the first time, including the eval example in Chapter 11 and the tests section.
Chapter 1 adds “The model and the harness”: you, the harness, and the files on your computer, with the model running on Anthropic’s servers. A new iceberg figure shows what each Claude app can reach, and the description of what the chatbot can access is corrected.
New figures: the opportunity solution tree, five forces and blue ocean on the value stick, product-led versus sales-led growth, break-even blocks, Build-Measure-Learn as one round of usability testing, and Duarte’s “what is” and “what could be.”
Rebuilt figures: the builder axes hexagon, the history of product management (dates corrected, with 2025 and full-stack product builders added), the rider and the elephant (the two paths labeled reason and emotion), Olsen’s product-market fit pyramid and the importance versus satisfaction chart, the journey map, the persona (now with a licensed photo), the value proposition canvas, and the logic of value figures.

v2.5.0 (2026-10-10)

The textbook chapters have been rewritten and now include figures throughout.

Chapters 1 through 15 are revised. Agentic Workflow (1 and 2), Discovery (3 and 4), Design (5 and 6), Application Architecture (7 through 9), AI Systems (10 and 11), and Launch and Learn (12 through 15) are each rebuilt around a small set of first-principles models, with each running example introduced before it is used.
About 35 new figures across the chapters, including the agent loop, blast radius, the evidence ladder, how a request travels from the browser to the database and back, environments and feature flags, and keep, change, or kill.
Chapter 7 explains what an API is, how the code in a React app works, and what the files in a Next.js project are for.
Chapter 9 adds sections on environments, staging, feature flags, who merges a pull request, and tests, with a sample test file explained line by line.
Chapter 11 shows an eval worked end to end: an email sorter run once with its real outputs, then run again after one change to the prompt.
Each section ends with a copyable /learn line you can paste into Claude Code to study that section further.
The six builder skills are redefined. AI Systems is now how the models work; prompts, tool use, and evals are part of Agentic Workflow. The builder hexagon is redrawn to match and shown on the syllabus, the schedule, and Chapter 1.
The sprint assignments link each course skill to its file in the builder template repo.
Builder Resources adds Sebastian Raschka’s Build a Large Language Model (From Scratch) book and videos, and Andrej Karpathy’s GPT from scratch.

v2.4.9 (2026-10-03)

Correction: the final exam late fee starts at 2:00 PM on Wed, Dec 9, not 1:00 PM as v2.4.8 said. Both exams now follow the same rule: the window closes at 9:00 PM on its last day, and the $5 late fee starts at 2:00 PM that day.

v2.4.8 (2026-10-03)

The midterm and final exam windows are set, and both are shorter than first posted.

Midterm: Tue, Oct 20, 8:00 AM to Thu, Oct 22, 9:00 PM, in the testing center. It was Oct 20 to 26. The testing center charges a $5 late fee after 2:00 PM on Thursday.
Final: Tue, Dec 8, 8:00 AM to Wed, Dec 9, 9:00 PM, in the testing center. It was Dec 14 to 17 and is now before the last day of class, not during finals week. The testing center charges a $5 late fee after 1:00 PM on Wednesday.
The final has 90 questions, 15 per axis, instead of 60. More questions per axis make your six-sided score profile more reliable. Plan on up to two and a half hours.

v2.4.7 (2026-10-02)

Sprint 1 grades are posted. Open Sprint 1 in Canvas and read the comment on your submission: it has a PDF with your feedback, what was reviewed, and what to do before your next sprint.
The Sprint 2 plan is due Saturday, October 3, at 11:59 PM, this one time, because Sprint 1 grades came out late.

v2.4.6 (2026-09-30)

Wrap-ups are due on or before the Monday each sprint ends, by 11:59 PM. Sprint 6 is the exception: its wrap-up is due Thursday, December 10. Plans are due the first Wednesday of each sprint.

v2.4.5 (2026-09-30)

Wrap-up deliverables are due on or before the last day of the sprint, by 11:59 PM. You do not have to wait for the last day: if your sprint’s work is done early, run /sprint-review and submit then.

v2.4.4 (2026-09-30)

“Shipped” is now Output, and it no longer has to reach anyone.

Output is what you finished this sprint, in whatever form the work takes: code, research, a design, a model, copy, a deck, an automation. It does not have to be public, launched, or used by anyone; plenty of valuable work is never shown to anyone else. It only has to be real, finished, and checkable by the course, privately: in your repo, shared with Professor Murff, summarized by /sprint-review, or shown working in your demo. See What output means for different work.
The four deliverables are now Plan, Output, Review, and Demo, in the turn-in table, the rubric, and on Canvas.
Sprint 1 is graded generously. Work that was local-only, private, or not yet in anyone’s hands counts in full.

v2.4.3 (2026-09-30)

How to change your plan mid-sprint.

To change your plan, run /sprint-plan again. During a sprint, it asks whether you want to change your current plan. Tell it what is changing and why; it updates the plan, adds a dated note under Changes, and commits it. There is nothing to resubmit on Canvas: your plan link always shows the current file. Refresh your course skills to get this version.

v2.4.2 (2026-09-30)

Your retro is now part of /sprint-review.

/sprint-review asks your retro questions. After it shows you the report on your sprint, it asks five short questions: did you hit the goal, what did the report show you, why did the plan change if it did, how hard was it really, and what will you change next sprint. Answer in your own words; it saves your answers exactly as you write them with the report in sprints/sprint-N-review.md, then commits it. There is nothing separate to write. Refresh your course skills to get this version.

v2.4.1 (2026-09-30)

How to turn in your plan, made plain.

Turn in your plan as a link. Commit and push sprints/sprint-N-plan.md, then paste its GitHub link into Sprint N Plan on Canvas. You do not paste the plan’s text, and you do not resubmit when the plan changes: the link always shows the current file. If you already pasted your Sprint 2 plan’s text, that still counts.
The Wrap-up assignments name the Review category (the report plus your retro) and point to the Where the work lives section of your README.

v2.4.0 (2026-09-30)

Every sprint now has four deliverables with one name each, a clear place to turn each in, and a new place for your retro.

Four deliverables: Plan, Shipped, Review, Demo. The new What you turn in, and how table lists each one: what it is, where it lives, how you turn it in, when, and how many points. The rubric uses the same four names.
The end-of-sprint assignment is now called Sprint N Wrap-up (it was Sprint N Review). You submit your review file and your Loom there.
Your retro moves to the bottom of your review file. /sprint-review now leaves five prompts under Your retro: did you hit the goal, what did the report show you, why the plan changed if it did, how hard it actually was, and what you will change next sprint. Answer them there instead of at the end of your plan file. Sprint 1 retros stay where they are.
Refresh your course skills to get the new retro. Paste the prompt from your Sprint 1 feedback into Claude Code in your course repo folder.
What “retro” means is now defined on the assessments page: the part of the review you write, in response to the report.

v2.3.5 (2026-09-30)

How sprint feedback questions work, and a wording fix.

Questions about your sprint feedback go to Course Monitor. Send a direct message to the Course Monitor app in the course Slack saying what you think was missed. Professor Murff reviews every message sent there, and you will get a short reply confirming it arrived. Questions sent by email or anywhere else may be missed.
How difficulty is judged. From Sprint 2, “shipped” is weighed by how hard the work was for you, judged from the work itself.

v2.3.4 (2026-09-30)

One less setup step.

You no longer need to add the TA as a collaborator. Sharing your repo with Professor Murff (sdmurff) is enough. If you already added Nate, nothing needs to change.

v2.3.3 (2026-09-30)

What counts as an artifact, and one requirement removed.

Any real artifact counts, on any of the six axes. Go-to-market, user research, design, and workflow work count as much as code. Markdown, Word documents, slide decks, spreadsheets, PDFs, images, and live links are all fine, as long as the work is real and someone else can open it. See Any real artifact counts for examples by axis.
Interview notes and recordings. Commit notes and synthesis with names removed, and keep recordings out of the repo.
The five-of-six axis requirement is gone. Your sprints no longer need to cover a set number of axes. Work where your product needs you.

v2.3.2 (2026-09-30)

What counts as shipped, where your work can live, and how difficulty now counts.

Your work has to be checkable, and it can live anywhere. Shipped work can be in your course repo, in another repo listed in your README, or live at a link. Work nobody can check, anywhere, does not count as shipped.
You never have to share a company repo. Share it with Professor Murff and Nate if your team is comfortable with that. If not, list it under Where the work lives in your README and /sprint-review will summarize its commits (dates, messages, and file names, never code), or show the result through the live product, a store listing, or your Loom. See Confidential company work.
Your README has a new section, Where the work lives. List every repo and live link someone would need to check what you shipped. Refresh your builder template skills to get the updated /sprint-review, which also reads Codex sessions now.
From Sprint 2, “shipped” is weighed by how hard the work was for you. Ambitious work you partly complete and account for in your retro can still earn full marks. Routine work you comfortably finish earns up to 15 of 20. Your predicted difficulty is still not graded.

v2.3.1 (2026-09-30)

Two rules for sprint deliverables, both taking effect with Sprint 2.

A demo that is not a Loom scores 0. Record it on Loom and submit the Loom share link. Google Drive, YouTube, uploaded files, and other hosts do not count. Sprint 1 demos on other hosts were not marked down.
Canvas applies the late work policy automatically. Anything submitted after its deadline loses 10% per day, as the syllabus has always said, and is worth nothing after 10 days. Sprint 6 cannot be turned in late. Deadlines are 11:59:59 PM, so a submission in the last minute is on time.

v2.3.0 (2026-09-30)

From Sprint 2 on, each sprint is two Canvas assignments, the plan is graded for completion, and you can change your plan during the sprint.

The plan is its own assignment. Run /sprint-plan, commit the file, and paste the four fields (Goal, Why this, Done looks like, Predicted difficulty) into that sprint’s Plan assignment on Canvas by the first Wednesday at 11:59 PM. On time with all four fields filled in earns all 10 points. Sprint 2’s plan is due Friday, Oct 2, since this changed partway through its first week.
You can change your plan. Edit the plan file and add a **Changes:** line with the date, what changed, and why. Changes cost nothing. Your work is read against the plan as it stands at the end, and your retro says how it changed.
The Review assignment is the other 40 points (90 for Sprint 6: shipped 50, review 20, demo 20). Submit two links: your sprints/sprint-N-review.md on GitHub and your Loom. Keep the Where to see it line in your README pointing at what you shipped.
The demo is 60 to 90 seconds, on Loom. This corrects v2.2.1, which said 60. A few seconds over is fine.
The schedule shows every plan due date, in the sprint table and on each sprint’s first class.

v2.2.1 (2026-09-30)

Starting with Sprint 2, the demo is shorter and has to be on Loom, and the Canvas submission is two links.

The demo is 60 seconds, on Loom. Down from 90 seconds. Record it on Loom and submit the Loom share link. Google Drive, YouTube, and uploaded video files are not accepted. The Sprint 6 demo is still three minutes.
Submit two links on Canvas. Your plan file on GitHub (sprints/sprint-N-plan.md) and your Loom demo. Sprint 1 asked for your repo URL instead.

v2.2.0 (2026-09-15)

Two new sections on how software actually gets built with agents, and diagrams throughout the book where chapters used to be text only.

New in Chapter 1: what makes an agent an agent. A chatbot and a coding agent run on the same model. What separates them is access: reading your files, running commands, executing code, and creating real deliverables. The new section sits right before the command line setup and explains why this course runs in a terminal instead of a browser tab.
New in Chapter 2: what this looks like at full scale. A walk through OpenAI’s internal “agentic software factory,” where a human defines the outcome and agents handle the code, the tests, the review, the deploy, and the incident response. Three things to take from it as a product manager: your job is the outcome, verification is the bottleneck once writing code gets cheap, and deciding which changes need a human is itself a design decision. You are running a small version of the same system.
The product loop is inverting. Chapter 1 now covers the shift from idea, spec, design, build to idea, build, play, design. You still write the spec, after you have learned something from a build instead of guessing beforehand.
Chapter 4 opens with the full process. Dan Olsen’s Lean Product Process shows which parts of product-market fit are the market’s to decide and which are yours. Chapter 4 is the market half; Chapters 5 and 6 are the product half.
Chapter 5 starts with the UX iceberg. Visual design is the only layer above the waterline, and it is the layer an agent is best at. Interaction design, information architecture, and conceptual design are underneath, and they are where usable and unusable products diverge.
A warning about AI-generated personas. Chapter 4’s persona section now shows a real worked example and names the failure mode: asking an agent for a persona before you have talked to anyone produces a plausible character with no information in it, and it will confirm whatever you already believed.
Chapter 11 starts with the autonomy spectrum. How much freedom to give a model, from a bare call you control completely to agents deciding their own steps. Your default should be a fixed process with a model call inside it.
Inbound marketing has a second audience. Chapter 12 now covers which sources models actually cite when buyers ask them instead of searching, and what that means for where you spend your effort.
Diagrams where there were none. Chapters 5, 7, 11, and 12 had no figures at all. They now have them, along with new diagrams in Chapters 1, 3, 4, and 9: the elements of value, a customer journey map, front-end and back-end architecture, and screenshots for the GitHub steps in Chapters 2 and 9.
Further reading. Added “Inside OpenAI’s Agentic Software Factory” from The Pragmatic Engineer.

v2.1.1 (2026-09-14)

The builder template is live, so you can create your repo and plan Sprint 1 today.

The builder template is on GitHub. Sprint 1 now links straight to it: byu-strategy/builder-template. Click Use this template, create your repo, and add Professor Murff (sdmurff) and the TA, Nate (nmccaul), as collaborators. It comes with /sprint-plan and /sprint-review already installed.
/sprint-plan reviews your whole plan before writing it. After you answer all four questions, it checks whether the plan is a reasonable two-week sprint: a specific goal, an end result someone else could check, an end result that actually matches the goal, and work that takes more than an afternoon and less than a semester. It raises anything it finds once, and then you decide.
The difficulty scale covers all five levels. Every rating from 1 to 5 now has a description, and each is worded as a prediction about the work ahead.
A setup prompt for Sprint 1. The Sprint 1 section has a prompt you paste into Claude Code. It walks you through creating your repo, adding collaborators, writing your context declaration, and committing your plan, and explains each step. The Sprint 1 plan is due Wednesday, September 16, 11:59 PM.
The template fits every role. Not everyone in this course ships software. The template’s README, CLAUDE.md, and spec now describe work in any role, and the context declaration asks which roles you have on your team. /sprint-plan reads your role and asks what shipped means for your kind of work.

v2.1.0 (2026-09-08)

Sprints are rewritten. Six sprints, two weeks each, and every one is the same assignment. Two new Claude Code skills plan and close them out.

Every sprint is now the same assignment. Same structure, same deliverables, same rubric, six times. What changes is what you decide to work on. The old sprints assumed everyone would be at the same stage at the same time: picking a problem in weeks 3 and 4, building an MVP in weeks 5 and 6. That is not how building works. You might spend two weeks on discovery, find out in week 7 that your idea is wrong, and go back to it. The assignment no longer assumes it knows where you are.
Two weeks each, all of them. Sprints used to run one, two, or three weeks depending on which one. Now every sprint is two weeks: Sept 14, Sept 28, Oct 12, Oct 26, Nov 9, and Nov 23.
New: /sprint-plan. Run it on day one. It asks what you are going to do, pushes back if the goal is vague or unmeasurable, and writes your plan file. Commit it that day; the timestamp is part of the grade.
New: /sprint-review. Run it at the end. It finds the Claude Code sessions from your sprint, asks you which projects belonged to it, and writes you a report: when you worked, where you got stuck and how you got unstuck, what took the longest, and which builder axis your work advanced. It reads only the projects you confirm, and nothing leaves your computer. Read it before you write your retro; it is usually more accurate about where two weeks went than memory is.
Predict your own difficulty. Each plan asks how hard you expect the work to be, 1 to 5, and each retro asks how hard it actually was. This is not graded in either direction. It is there so you can practice estimating.
The demo is 90 seconds. Down from five minutes, and it is the demo only. Show the thing working with real content. No slides, no intro. The reflection goes in your written retro.
No separate final project. Sprint 6 is the last sprint and the culmination, worth 100 points instead of 50, with a three-minute demo covering the semester.
“Shipped” no longer means only code. A landing page published at a URL, a pricing model your team can use, copy that is actually in use, an automation that runs, research written up and acted on, or analytics returning real data all count. The standard is that it is real and someone other than you can reach it, use it, or see it.
The portfolio is no longer required. Build one if you want it. Sprint 1 still asks for your company repo and a short declaration of what you are building, who it is for, and who your user is.
Confidential company work has an answer. If your team’s code or customers cannot be public, keep your repo private and add Professor Murff, deploy behind auth and give the graders an account, or use fake data. Nothing in this course has to be public.
Across your six sprints your work must touch at least five of the six axes. You choose when. The sprint review tags each one for you.
Fixes and polish. All submissions go to Canvas. The mid-semester survey is removed; the end-of-semester student ratings now carry the extra credit. Corrected a few chapter references left over from the reorganization.

v2.0.0 (2026-09-08)

The whole course is rebuilt around six builder skills, two weeks each. New chapters on how AI models work and how to put one inside your product. Quizzes are replaced by two testing center exams.

The book is now organized around the six Builder axes. Agentic Workflow, Discovery, Design, Application Architecture, AI Systems, and Launch and Learn, two weeks each across the semester. Every chapter, every drill, and both exams line up with one of the six, so when your baseline chart says an axis is weak you know exactly where to go. You will rate yourself on all six in week 1 and again in week 13 and see how the shape changed.
The order changed on purpose. Agentic Workflow comes first, so you ship something in week one that you do not fully understand, and Application Architecture comes in week seven, where you find out what you shipped. Every chapter has been renumbered to match the order you read them in.
New chapter, How Models Work. What a large language model actually does when it turns your prompt into text: supervised learning, neural networks, tokens, context windows, and prompting. If you have been treating the model as magic, this chapter explains the mechanism.
New chapter, Models in Your Product. Calling Claude from your own app: where the call lives and why your API key never goes in the browser, getting structured data back instead of prose you have to parse, streaming, what each call costs and how to price it before you ship, the ways model calls fail without raising an error, and how to build an eval so you know whether a change actually helped.
New chapter, Anatomy of an Application. Frontend, backend, database, and API, what each layer does and how they fit together, plus the tech stacks and languages this course uses and how to choose one for yourself.
New chapter, Interface and Flow. Frontend fundamentals, React, forms and state, responsive layout, and the platform decision between web, PWA, and native, all in one place.
Quizzes are replaced by two exams. Instead of ten in-class quizzes there is a midterm (Oct 20 to 26, covering the first six classes) and a final (Dec 14 to 17, cumulative). Both are in the testing center, on your own schedule within the window, closed book and proctored. Each is worth 5% of your grade, the same 50 points the quizzes were worth, so nothing else about grading changed. The final has ten questions per axis, so your score comes back as a six-sided profile you can compare against your own self assessment.
Why the exams are closed book. Nearly everything else you submit this semester is built with AI. These two sittings are the one place your own understanding is measured on its own. They are also deliberately low stakes: at 5% each, one bad exam is worth about two percent of your grade.
Updated learning outcomes. There are now five instead of four. The new one is about using AI coding agents well, including judgment about when to trust, verify, or override the tool, which is the most distinctive thing this course teaches and was not previously stated as an outcome.
A clearer syllabus. The course description now describes this course rather than the version taught under the old number, and names the real tools you will use. Required Materials leads with Claude Pro at $20 per month rather than requiring Max up front. The late work policy now covers testing center windows.
Fixes and polish. Growth and onboarding material moved out of the tech debt chapter into Going to Market where it belongs. Every chapter now opens with Why This Matters and closes with Key Concepts. Dates on the syllabus corrected to the Fall term.

v1.4.0 (2026-09-08)

A new Computer Setup chapter, a new Builder Resources page, and updated office hours.

New chapter, Computer Setup. Everything to get your machine ready before the first build session, in one checklist you can work through start to finish. It also explains which Claude plan to buy: Claude Pro at $20 per month is enough to start, and you upgrade to Claude Max at $100 per month only once you start hitting usage limits. The chapter links the Rollins Center Validation Grant, which reimburses up to $500 for customer discovery work and can offset the cost.
New page, Builder Resources. The books, docs, courses, and tools behind each of the builder axes: Discovery, Design, Application Architecture, AI Systems, Agentic Workflow, and Launch and Learn. Start-here items are called out on every axis so you know what to read first.
Thought Leaders now includes who to follow. The page carries the product management voices as before, plus the accounts worth following while you build and the ones worth following to understand where the field is heading. Duplicates were removed so each person appears once.
Office hours updated. Wednesdays 1:30 to 3:30 PM and Fridays 3:00 to 3:30 PM, in 587 TNRB. Wednesday 3:00 to 3:30 PM and all of Friday are by phone.
Fixes and polish. Clearer wording in the schedule and in the opening chapters.

v1.3.2 (2026-07-20)

Book citations now link to Google Books.

Every book in the reference lists and the Works Cited page now links to its Google Books page, where you can preview it, buy it, or find it in a library. Each link was checked to open the correct English edition. The one book that previously had no link now has one, so every source in the book is clickable.

v1.3.1 (2026-07-20)

Every reference in the book is now a clickable link, plus three more cited sources in the economics appendix.

Clickable citations. Every entry in the reference lists and the Works Cited page now links straight to the source: the book’s page in an open library catalog, the publisher’s article page, or a permanent archive. One out-of-print book has no free record and stays as text.
The Logic of Value appendix now cites Marshall, Schumpeter, and Stewart for the economics it builds on (producer surplus, creative destruction, and economic value added).

v1.3.0 (2026-07-20)

Every borrowed idea in the book is now cited to a real source, plus a new appendix on the economics behind strategy and a clearer opening to the AIRE loop.

Citations across the whole book. Each chapter now credits the books and papers behind its ideas, with a linked reference list at the foot of the chapter and a new Works Cited page collecting the full bibliography (67 sources). Every entry was checked against an authoritative catalog.
New appendix, The Logic of Value. Derives the economics under the value stick, how producer surplus, profit, and return above the cost of capital are one idea measured at different levels of detail, with diagrams.
Product Strategy: a new section on creating value versus capturing it, with a value stick diagram showing where your margin sits between willingness to pay and willingness to sell.
Chapter 1: the AIRE loop is now framed as four plain questions (what do you want, what is true, what’s the best option, what happened), opening with the Cheshire Cat as President Monson retold it.
Fixes and polish: embedded tweets now show author handles correctly.

v1.2.0 (2026-07-20)

A large release: a new Product Strategy chapter, the course reorganized around the AIRE loop, two new reference pages, and the schedule and assessments updated to match the new structure.

New chapter, Product Strategy (in the Aim part): what game you are playing, where to play and how to win, moats, and the DHM test for a strong strategy.
The course is now organized into five parts around the AIRE loop: Foundations, Aim, Discover, Build, Grow, and a References section. Product Morality now sits in Aim (what is worth building), and Platform Strategy moves into Build.
Chapter 1 adds a table showing how the AIRE loop (Aim, Inform, Reason, Enact) maps to the parts of the course.
Two new reference pages: The Canon, which credits the sources behind each major principle and flags what has changed in the AI era, and a Thought Leaders page.
Attribution pass across the course: principles are now credited to their sources, with new frameworks from Jeff Dyer added to Problems Worth Solving, Building Your MVP, Go-to-Market, and Storytelling.
Schedule: the weekly practice table is rebuilt around the new parts. Product Strategy gets its own practice, and the readings and quiz schedule is updated. There are still ten quizzes; three weeks now pair two shorter chapters under one quiz.
Assessments: the quiz-to-chapter mapping matches the new chapters, and all sprint, peer, final, and survey dates are corrected to the Fall 2026 calendar.

v1.1.2 (2026-07-18)

New discovery and MVP tools, adapted with credit from Nile Hatch’s Expeditionary Innovation.

Problems Worth Solving: a “diverge before you converge” section on generating many candidate problems before narrowing.
Problem Discovery: the five kinds of pain (physical, functional, financial, emotional, social) as a probing checklist, and a “how many interviews is enough?” note on interviewing to saturation.
Validating Opportunities: the Access Test (can you actually reach these customers?) and a “harden your evidence” note on willingness-to-pay, the Ouch Factor, and false positives.
Building Your MVP: the $100 Test for feature prioritization, and how to test demand before building (smoke test and Wizard of Oz).

v1.1.1 (2026-07-18)

Small additions to the discovery and storytelling material.

Chapter 3 now has a “thinking in probabilities” note: hold beliefs about your customer as probabilities and seek evidence that would look different if you were wrong, which is why the Mom Test works.
A rider-and-elephant illustration was added to the Storytelling chapter and to Product Morality, to picture the two-part mind the analogy describes.

v1.1.0 (2026-07-18)

A large content release: a new chapter, a framework that connects every part of the course, and expanded discovery, storytelling, and grading material.

New chapter, Product Morality (in Grow the Business): how to aim a product well, moral foundations, a reflection test for habit-forming products, and Aristotle’s golden mean with a virtue table.
Chapter 1 now opens with “The Loop: How This Course Works”: the AIRE loop the course runs on (Aim, Inform, Reason, Enact), why the decision factors multiply, and how each class runs as a practice.
Chapter 3 now opens with “Discovery Is Truth-Seeking”: a belief-and-truth map with a new diagram, the six ways of knowing and why you triangulate, and how much evidence is enough before you commit.
Storytelling and the Final Demo is now a full chapter: building a story database, techniques that make a story effective, and a three-part structure for the final video.
New Playbook page, “Why This Class Works This Way,” explaining the course design, including why the class is graded on decisions and learning rather than outcomes.
Truth-seeking callbacks added to Validating Opportunities, Testing with Users, and Measuring What Matters.
Schedule: scrimmages (Practices 11 and 12) are now described; Wednesday office hours; updated TA and course-number information.
Navigation reorganized into solo-builder phases: Foundations, Discover, Build, Grow, Demo, Playbook.
Overview and Syllabus: refreshed grading summary, cross-listed course numbers, and AI-tool requirements updated to the Claude Max plan.
Fixes and polish: resources updated, version chip restyled.

v1.0.0 (2026-07-18)

The course site is now versioned. From here on, every published update to the schedule, assignments, or course content will be listed on this page with a version number and date.

Added this release notes page, linked from the version number in the site footer.
Established the initial baseline: course information, schedule, assessments, twelve topic chapters, and resources.