简体中文
English
Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is XP123?
XP123 is the personal essay site of Bill Wake, an independent consultant and teacher who has worked in Extreme Programming (XP) and Agile software development for many years. The site collects his writing on XP, Agile, Lean, Scrum and closely related practices, and it reads more like a long-running practitioner's notebook than a company blog or course platform.
What you'll find there
The material is organized around the working habits of software teams rather than around news or product marketing:
- Core practice overviews — starting points for Test-Driven Development (TDD), refactoring, user stories and related techniques.
- Story and planning material — articles such as "INVEST in Good Stories" and "Twenty Ways to Split Stories," aimed at people who need to break work down and write it clearly.
- Concise summaries — "XP on One Page" and "Scrum on a Page" for readers who want the shape of a method before committing to a book.
- Testing and design resources — including set-based design, coaching and testing topics.
- Reviews — mostly book reviews across a range of subjects.
- Comics and a charts gallery, plus a Twitch stream with a varying schedule.
Who it suits
XP123 is most useful to developers, testers, coaches and Scrum Masters who already have some exposure to Agile and want practical, opinionated explanations of specific practices. If you are brand new to Agile, the one-page summaries are a reasonable entry point, but the site assumes you can handle jargon and jump between topics. If you are looking for structured training, certification or a defined curriculum, this is not that; it is a body of essays you navigate by interest.
A practical way to use it
Pick one problem you currently have — say, stories that keep growing too large — and read the matching essay rather than browsing everything. "Twenty Ways to Split Stories" is a good test case: read it, then try two or three of the suggested splits on your actual backlog and see which ones your team can apply without arguing about definitions. That read-then-apply loop is how the site is designed to be used.
For broader context, Bill Wake's non-Agile writing lives at billwake.com, and his job aids material has moved to jobaids.info.
How do I get started with XP123's resources on Extreme Programming?
Start with the Start Here section, then follow whichever track matches your role. XP123 is XP123, Bill Wake's long-running essay collection on Extreme Programming, Agile, Lean and Scrum. It is an article archive, not a course or a tool, so "getting started" means picking a reading path rather than signing up for anything.
Pick your entry point
The site names four reader roles — customer, programmer, tester, coach — and a Start Here page that points to overview pages for each. Choose the one closest to your daily work:
- Programmer: Test-Driven Development (TDD) and Refactoring overviews.
- Customer or product person: User Stories.
- Tester: the testing material linked from the resources list.
- Coach or lead: the coaching resources, plus the one-page XP and Scrum summaries.
A practical first hour
- Read "XP on One Page" for the whole-picture view of Extreme Programming.
- Read "Scrum on a Page" if your team uses Scrum rather than XP, so you can see where the two overlap.
- Read "INVEST in Good Stories" — the acronym (Independent, Negotiable, Valuable, Estimable, Small, Testable) is a checklist you can apply to your backlog the same day.
- Skim "Twenty Ways to Split Stories" when a story is too big to finish in one iteration.
Those four pieces give you vocabulary and two immediately usable techniques. Everything else on the site is depth.
If you learn better by watching
Wake streams on Twitch on a varying schedule, announced on Mastodon, typically weekday mornings US Eastern time, and archives old episodes. The current project is a breadboard for learning about compilers — useful if you want to see TDD and refactoring habits applied to something other than a business app, though it is not an XP tutorial as such.
Where the site stops and other sources begin
XP123 is strongest on TDD, refactoring, story splitting and coaching heuristics, and weakest as a structured curriculum: there is no ordered syllabus, and some material has migrated elsewhere over the years. Wake's own books — Extreme Programming Explored and Refactoring Workbook — are the natural next step if you want a sequenced treatment, and his review pages cover books on related topics. For the canonical XP description, go to Extreme Programming; for the wider Agile canon, Agile Manifesto; for Scrum specifically, Scrum Guides.
Decision criterion
If you have a concrete problem this week — a story that won't split, a test suite you avoid running, a refactoring you keep postponing — search XP123 for that topic first and read the one relevant essay. If you are trying to understand XP as a whole before changing anything, read the two one-page summaries and then a book.
What are the most popular articles on XP123 and what topics do they cover?
The most popular articles on XP123 cluster around practical Agile and Extreme Programming techniques, especially practices a working team can apply the same week. The page's own "Most Popular Articles" list points to a mix of test-driven development, story writing and splitting, refactoring, Scrum, and coaching resources.
What the popular pieces cover
- Test-driven development (TDD): "TDD is an Alchemy Trick: Points and Partitions" and the "Test-First Challenge" address how to break work into testable pieces and practice test-first habits. The linked TDD and testing resource pages collect further material.
- User stories: "INVEST in Good Stories" covers the familiar quality checklist (Independent, Negotiable, Valuable, Estimable, Small, Testable), while "Twenty Ways to Split Stories" offers concrete options for breaking large stories into smaller ones.
- Refactoring: a dedicated resource page gathers refactoring material, a natural fit given Bill Wake's Refactoring Workbook and Refactoring in Ruby.
- Scrum and Agile overviews: "XP on One Page" and "Scrum on a Page" are one-page summaries, and "Scrum from Hell" reads as a cautionary or humorous take on Scrum gone wrong.
- Design and engineering approaches: "Set-Based Concurrent Engineering" and a "Set-Based Design" resource cover delaying commitment while exploring options.
- Coaching and team practice: a coaching resource page and "Job Aids" (now hosted externally) support people teaching or facilitating these practices.
- Comics and games: a comics series and a games section show the site's lighter, explanatory side.
Who gets the most from these
A developer or Scrum team member who wants a short, concrete technique will find the story-splitting and INVEST pieces immediately usable. A coach or lead is more likely to start with the coaching resources, the one-page XP and Scrum summaries, or "Scrum from Hell" as a discussion prompt. Someone studying TDD benefits from pairing the alchemy-trick article with the test-first challenge.
The trade-off is depth versus breadth: these are essays and one-page summaries, not a structured course. They are best used to grab a technique or a framing, then applied in your own codebase.
If you are new to the site, read "XP on One Page" first for orientation, then pick one practice area—TDD or user stories—and work through its linked resources.
What books and reviews does Bill Wake recommend on XP123?
XP123 hosts Bill Wake's own reviews, mostly of books, rather than a formal recommendation list. The site points readers to that reviews section directly, and Wake notes that buying a book through his link earns him a small Amazon credit—so treat the reviews as personal commentary, not neutral buying advice.
What the site actually offers
- A reviews hub, described as covering "a variety of topics," with books as the main focus.
- A "Start Here" path for overview material: comics, test-driven development (TDD), refactoring, and user stories.
- A "Most Popular Articles" list that functions as a de facto reading order: "TDD is an Alchemy Trick," "INVEST in Good Stories," "Twenty Ways to Split Stories," "XP on One Page," "Scrum on a Page," "Set-Based Concurrent Engineering," "Scrum from Hell," and the "Test-First Challenge."
- Resource collections on refactoring, TDD, set-based design, coaching, and testing.
Books Wake wrote, not just reviewed
The page identifies him as the author of Extreme Programming Explored, Refactoring Workbook, Design Patterns in Java (with Steve Metsker), and Refactoring in Ruby (with Kevin Rutherford). These are the clearest XP-adjacent titles tied to the site's author, though the page doesn't rank or recommend them against alternatives.
How to use this
If you want Wake's XP thinking in book form, start with Extreme Programming Explored. If you want his opinions on other people's books, go to the reviews section and read the specific title you're considering—his notes are short and practical rather than exhaustive. A reasonable next step is to read "XP on One Page" first as a free orientation, then decide whether a full book is worth the time.
For broader Agile reading beyond this site, Martin Fowler and Agile Manifesto cover foundational material Wake references but doesn't host.
How can I use XP123's materials to improve my team's agile practices?
XP123 is best treated as a practitioner's essay archive, not a training program. Bill Wake's writing on XP, Agile, Lean, and Scrum is most useful when you pull one specific practice into a team conversation and adapt it, rather than trying to adopt the whole site as a method.
Where to start, by team problem
| If your team struggles with... | Go to | What to do with it |
|---|---|---|
| Vague or oversized backlog items | User Stories, especially "INVEST in Good Stories" and "Twenty Ways to Split Stories" | Bring two or three real stories to a refinement session and split them using the listed techniques |
| Weak testing habits | Test-Driven Development (TDD), "TDD is an Alchemy Trick," and the Test-First Challenge | Run the challenge as a lunch-and-learn; compare how each person's design evolved |
| Messy code slowing delivery | Refactoring resources | Pair a refactoring exercise with a real, small cleanup in your codebase |
| Planning or process confusion | "XP on One Page," "Scrum on a Page" | Use these as one-page references in onboarding or a team charter discussion |
| Coordination across many teams | Set-Based Design and Set-Based Concurrent Engineering | Read as a set of decision-delay ideas, then test one on your next architecture choice |
A realistic way to use it
Pick one item per iteration. For example, a team with long, unpredictable stories could spend thirty minutes in refinement applying the story-splitting patterns to the three largest items in the backlog, then check at the end of the iteration whether cycle time improved. Bill Wake's own framing is that of an independent consultant and teacher who has worked across finance, biotech, and publishing; the essays reflect that kind of field experience, so they read as arguments and heuristics rather than prescriptive checklists.
Two caveats. The material spans decades, so some references and examples are dated; translate the ideas to your current tooling rather than copying them literally. And the reviews section is mostly book reviews with an affiliate arrangement noted on the site, so treat those as opinionated recommendations, not neutral evaluations.
Useful companions
For the practices referenced most often on the site, pair the essays with the primary sources: JUnit for test tooling, Martin Fowler for refactoring and design writing, and Scrum Guides for the canonical Scrum definition. Wake's other sites, billwake.com and jobaids.info, cover non-agile posts and job-aid creation respectively.
If you want a single next step: choose the one row in the table above that matches your team's most painful problem, read the linked material this week, and try it on live work in the next iteration.
What are some practical techniques for splitting user stories from XP123?
XP123's most directly useful page for this is Bill Wake's essay "Twenty Ways to Split Stories," which treats story splitting as a routine planning skill rather than a one-off trick. The site also hosts "INVEST in Good Stories," the checklist that explains what a well-split story should look like once you're done: Independent, Negotiable, Valuable, Estimable, Small, and Testable.
Techniques the site covers
Wake's list is organized around the idea that you split along one dimension at a time, and each dimension tends to suit a particular kind of work:
- By workflow step — build the "happy path" first, then add validation, error handling, or approval stages as separate stories.
- By business rule — one story per rule or per variation, so each rule can be prioritized and tested on its own.
- By data variation — start with one input type, format, or record type, then extend.
- By interface or channel — web first, then mobile, then API, or the reverse if the API is the real risk.
- By operations — create, read, update, delete as separate slices, often with "create" first because it unblocks demo data.
- By acceptance criteria — move a single criterion out into its own story when it's substantial enough to stand alone.
- Spikes and simplifications — a research story to reduce uncertainty, or a deliberately crude version that ships value now and gets refined later.
How to choose
The trade-off is between stories that are small enough to finish inside an iteration and stories that still deliver something a customer would recognize as progress. Splitting by technical layer ("database story," "UI story") usually produces pieces that are individually estimable but not independently valuable, which is exactly what INVEST warns against. Splitting by workflow step, business rule, or data variation tends to keep each slice demonstrable.
A practical test: after splitting, ask whether the first slice could be shown to the customer and whether they'd accept it as done. If not, the cut is probably in the wrong place.
Where to start
Read "Twenty Ways to Split Stories" alongside "INVEST in Good Stories" on XP123, and use INVEST as the acceptance check on whatever split you produce. For a broader framing of the practices these techniques sit inside, the site's "XP on One Page" and "Scrum on a Page" summaries are quick orientation reads. Bill Wake's related book-length treatment is Extreme Programming Explored, and his later writing on refactoring and design patterns appears on billwake.com.
User reviews (0)