Rules

The rules that govern how we work

In 1999 Don Wells put the rules of Extreme Programming on a single web page, in five groups: planning, managing, designing, coding and testing. Obie went through all twenty-nine and asked the same question of each one. What does it look like when typing is nearly free and you have a team of agents at your side? Here are all twenty-nine, with 1999 next to 2026.

Planning

  1. 1
    1999

    User stories are written.

    2026

    Get your story straight.

    Before you commit to a project, write down your success criteria for it and post that somewhere that the rest of your team can refer to it. A lot of teams use Linear these days, and it has a native first-class Projects feature that we use at ZAR for this purpose. The point is to understand and document what you're going to build before you commit to delivering it.

    That's the only kind of “story” IMP cares about: the account you can give of what you're building and how you'll know it worked.

    Revisit this rule
  2. 2
    1999

    Release planning creates the release schedule.

    2026

    Call your shot every week.

    One big project, one demoable vertical slice by Friday.

    Long projects climb a hill. Until you reach the top, you're still turning unknowns into knowns, and nobody should pretend to know the date. At the top, whoever committed gives a forecast they believe. That's good management, and it's no deadline.

    Ryan Singer's Shape Up gave us the hill.

    Revisit this rule
  3. 3
    1999

    Make frequent small releases.

    2026

    Every green merge is a release, ideally.

    Shoot for fully automated and continuous release. Projects with high blast radius components may not fully achieve that goal. Given how the clankers can fix or roll back almost anything almost instantly, the risk of a bad release causing production incidents has never been lower.

    Essays Sebastian Scholl, “Stop Apologizing for Being the Bottleneck” extends

    Tools Review and merge

    Revisit this rule
  4. 4
    1999

    The project is divided into iterations.

    2026

    No timeboxes. A weekly showcase is the heartbeat.

    For eXtreme Programming (XP) purists, the only purpose of an iteration was to track velocity.

    Then Scrum came along with its sprints. They let teams expand the work to fit the deadline. We think that's exactly the wrong kind of way to enforce commitments in the age of AI.

    IMP has no timeboxed iterations. Work flows pull request by pull request, and every green merge is an increment (rule 3). Rework still happens, inside every pull request (rule 12). Once a week the whole company holds a showcase, and the rule is presenters can only show something that they've actually finished. Nothing in progress counts, and if it's product, you demo it in production. Each person or team picks one or two bigger things, and small tweaks don't count.

    Waterfall worked in phases of months. XP cut that to iterations of weeks. IMP drops the timebox entirely, but keeps a weekly heartbeat in place. Mostly because it's a nice ritual that gives people a chance to show off their best work and receive appreciation for it.

    Under no circumstances are bosses allowed to criticize or question decisions made by the team during the showcase.

    C. Northcote Parkinson explained why deadlines expand.

    Revisit this rule
  5. 5
    1999

    Iteration planning starts each iteration.

    2026

    The One Question starts each feature.

    What do we still need to learn before we can build this?

    Revisit this rule

Managing

  1. 6
    1999

    Give the team a dedicated open work space.

    2026

    Work in the open, with your agents.

    XP gave the team an open workspace. Most teams are remote now, so the open workspace is a shared chat space where people and agents work side by side in public channels.

    Ideally, everyone's local Claude Code sessions feed a shared knowledge graph. What's learned by one should be learned by all.

    Tools The agent itself

    Revisit this rule
  2. 7
    1999

    Set a sustainable pace.

    2026

    Set a sustainable attention budget.

    Human understanding goes to the new stuff.

    Revisit this rule
  3. 8
    1999

    A stand up meeting starts each day.

    2026

    Agents brief the team every day.

    Each morning the team's agents post a brief on what the whole team did, people and agents alike, so the brief covers more than the agents' own work. That's what autonomous agents are for.

    Revisit this rule
  4. 9
    1999

    The Project Velocity is measured.

    2026

    Throughput is measured, and labeled honestly.

    When you work with agents you ship in far smaller increments than you used to. That breaks how most teams measure. A dozen small PRs polishing a feature no user has seen yet get counted as a dozen bug fixes, and suddenly the dashboard says quality is collapsing.

    In IMP a fix means a defect in code that's live in production. Everything else is refinement, and it gets labeled that way: refine:.

    On flat-rate plans the bill is fixed, so dollars aren't worth tracking. Plan limits are. Watch how close you run to them, because hitting one stops your agents mid-work.

    Essays Agustín Calabrese, “One person, a coordinator and a flock: running Impatient Programming alone” extends

    Tools Measurement

    Revisit this rule
  5. 10
    1999

    Move people around.

    2026

    Move attention around.

    People rotate to the new work, and agents take over the maintenance.

    Revisit this rule
  6. 11
    1999

    Fix XP when it breaks.

Designing

  1. 12
    1999

    Simplicity.

    2026

    Simplicity: breathe in, breathe out.

    Simplicity is where breathing lives. Every pull request breathes. On the inhale, you let the agent sprawl until the universe reveals exactly what your new feature wants to be. On the exhale, you fold what you learned back into what already exists in the system, in the same PR.

    Agents add complexity by default, and the exhale is where simplicity happens. Technical debt is not tolerated.

    One pull request breathing in and out above the Contract
    Breathe in. The agent sprawls until the feature shows what it wants to be. Breathe out. You fold what you learned back into what already exists. Merge. Same pull request, with the Contract underneath the whole time.

    Essays Stephen Margheim, “Code Is Cheap Now. That's Why It Matters.” extends

    Tools Breathing out

    Revisit this rule
  2. 13
    1999

    Choose a system metaphor.

    2026

    Write the Contract.

    System metaphor was the XP practice teams found hardest to apply. The problem is that the metaphor lived in people's heads. Peter Naur saw the same problem in 1985, when he argued that a program's real value is the theory in its programmers' heads.

    In IMP the metaphor/mental model gets written down in the source code. We call it the Contract. It's the team's comprehensive description of what the software must do, in a form a team can collaborate on and maintain. More on the Contract.

    Ancestor: Peter Naur, “Programming as Theory Building” (1985).

    Essays Agustín Calabrese, “One person, a coordinator and a flock: running Impatient Programming alone” agrees

    Tools The Contract, Proof

    Revisit this rule
  3. 14
    1999

    Use CRC cards for design sessions.

    2026

    Use artifacts for design sessions.

    Now when we start a feature we open an editable artifact and talk through the design and architecture decisions with Claude until we both understand what we're building. We ask for a comp and reject it. We ask for three options. When the picture is clear, then we unleash the agent to do its thing.

    The artifact that helped you think becomes the design record.

    Revisit this rule
  4. 15
    1999

    Create spike solutions to reduce risk.

    2026

    Spikes are cheap, so run several in parallel.

    A spike was a quick throwaway program written to answer one question, then deleted. We rationed them, because a spike could cost a pair a day or two. Now a spike costs minutes, so imps run several in parallel and let the results argue it out.

    Tools The agent itself

    Revisit this rule
  5. 16
    1999

    No functionality is added early.

    2026

    Experiment on what to build. Boil the lake on how you build it.

    YAGNI still holds for scope. Don't overbuild. Use that nearly unlimited intelligence at your fingertips to learn how to advance your project via the scientific method. Name your hypotheses and your assumptions, run bakeoffs, and experiment like crazy until you figure out exactly the feature that you need.

    And once you figure it out? Go all the way. Goldplate it as much as you want! Garry Tan calls it boiling the lake: completeness is so cheap now that taking shortcuts stops making sense. Build it complete and please your customer, but never forget to “breathe out” before you ship that PR so that none of the new stuff turns into technical debt.

    Garry Tan boils lakes and oceans. Eric Ries taught a generation to experiment.

    Tools Proof

    Revisit this rule
  6. 17
    1999

    Refactor whenever and wherever possible.

    2026

    Keep it regenerable. Regenerate when it's worth it.

    Regeneration works like a fire drill. You don't burn the building down to move offices, but you run the drill, because the drill is how you find out everyone can get out.

    If you couldn't delete a component and rebuild it from the Contract, the Contract is missing something. Run the drill now and then, and regenerate for real when a better design makes it pay. Entire systems can get regenerated in an afternoon now, so the drill is cheap.

    Essays Muhannad Salkini, “Rule 17: What the Contract can't hold” extends Stephen Margheim, “Code Is Cheap Now. That's Why It Matters.” pushes back

    Revisit this rule

Coding

  1. 18
    1999

    The customer is always available.

    2026

    Put the solution in front of the customer, and stop guessing what they want.

    XP put the customer in the room. Now a spike is one of the first things you do, and it goes straight in front of the customer. Throwaway prototypes, trial balloons, five versions of a screen before lunch. Experiments cost almost nothing, so nobody has to guess what the customer wants anymore.

    Sometimes the customer builds the prototype. At ZAR the whole company is expected to code, not just the engineers. Our CEO isn't a programmer, and some of our best systems started as prototypes he built himself.

    Tools What users see

    Revisit this rule
  2. 19
    1999

    Code must be written to agreed standards.

    2026

    Standards are enforced by machines.

    Convention over configuration. The rules run in machines: mutation gates, executable contracts, merge checks, guardrails on every change.

    Essays Agustín Calabrese, “One person, a coordinator and a flock: running Impatient Programming alone” agrees Stephen Margheim, “Code Is Cheap Now. That's Why It Matters.” extends

    Tools Structure, Standards

    Revisit this rule
  3. 20
    1999

    Code the unit test first.

    2026

    Agree on the Contract, and make it executable.

    Throughout the inhale you and the agent work out what the feature must do, and the agent writes each obligation into the Contract as it goes. Those are the invariants the result must adhere to when it is finished, functional and non-functional. Making sure the Contract is complete is part of the exhale (rule 12).

    An agent that writes the Contract while it writes the code can end up describing whatever it built. So on the exhale you check the Contract against what you agreed, and the kill matrix (rule 26) catches tests that pass no matter what the code does.

    One thing does come first. When you're changing existing code, pin the behavior it already has before the agent touches it, and find out why each fence is there before you move it.

    The most impish thing you can do is to make the Contract executable, and that's one of the greenest green fields that exists in October 2026.

    Essays Agustín Calabrese, “One person, a coordinator and a flock: running Impatient Programming alone” agrees

    Tools The Contract, Generated inputs, Tests that bite

    Revisit this rule
  4. 21
    1999

    All production code is pair programmed.

    2026

    All production code is pair programmed, with an Agent.

    XP asked people to pair on all production code. Thoughtworks, Pivotal Labs, Hashrocket. We did it with a vengeance, and it was exhausting. But it never took off hardly anywhere else because it cost two salaries for one keyboard, which is something that the people controlling the purse strings just could not get through their fat skulls as an improvement.

    Today everyone pairs with Claude Code (or a similar coding agent) all day, every day.

    Essays Mark Ryall, “Keep pairing with humans” pushes back

    Tools The agent itself

    Revisit this rule
  5. 22
    1999

    Only one pair integrates code at a time.

    2026

    Retired.

    Machines took this one over. Merge queues and CI serialize integration, so nobody takes turns anymore. IMP says so out loud and doesn't keep the rule out of nostalgia.

    Revisit this rule
  6. 23
    1999

    Integrate often.

    2026

    Integrate continuously.

    Long-lived branches hurt your teammates, and when agents are writing code all day, a branch goes stale in hours.

    Tools Review and merge

    Revisit this rule
  7. 24
    1999

    Set up a dedicated integration computer.

    2026

    Guardrails fire on every change.

    A guardrail is software, and building one is programming. Think of bowling with kids, when you put the bumpers up so the ball reaches the pins. The pins are business value. The ball is whatever your coding agent does when you give it a prompt.

    A bowling lane seen from above. The ball bounces off the bumpers on both sides and still reaches the pins.
    Bumpers up. They keep the ball out of the gutter on its way to the pins.

    Essays Agustín Calabrese, “One person, a coordinator and a flock: running Impatient Programming alone” pushes back

    Tools Safety, What users see

    Revisit this rule
  8. 25
    1999

    Use collective ownership.

    2026

    Collective ownership, agents included.

    In the most extreme implementations of IMP, we completely hand over ownership of maintenance work to autonomous agents.

    Revisit this rule

Testing

  1. 26
    1999

    All code must have unit tests.

    2026

    Every test must prove it's worth keeping.

    Not all code needs unit tests, because every test (unit or otherwise) has to prove that it's worth keeping and burning CPU cycles on. Agents will happily write thousands of automated tests along with your code.

    Imps run all automated tests through a kill matrix using mutation testing, and keep a test only if it catches something no other test catches.

    A kill matrix: six tests against eight mutants. Tests 3 and 5 catch only what other tests already catch. mutants test 1 test 2 test 3 test 4 test 5 test 6
    A kill matrix. Each column is the code broken on purpose in one small way, and a dot means that test catches it. Take away tests 3 and 5 and every mutant shown is still caught.

    Essays Agustín Calabrese, “One person, a coordinator and a flock: running Impatient Programming alone” agrees

    Tools Tests that bite

    Revisit this rule
  2. 27
    1999

    All code must pass all unit tests before it can be released.

    2026

    Green merges itself.

    Our long-term goal is to get rid of human code review altogether. The blast radius of your PR is how you decide how aggressive to get with that goal today. As much as possible should ship, land and deploy based on automated checks and adversarial model review. Save human eyes for reviews guarding against catastrophic risks.

    Claude can set up canary deployments for you without breaking a sweat. It can also hotfix or rollback almost any bad release almost instantly. IMP embraces the fact that the risks of continual deployment have never been lower.

    Essays Agustín Calabrese, “One person, a coordinator and a flock: running Impatient Programming alone” pushes back Muhannad Salkini, “Rule 17: What the Contract can't hold” extends Sebastian Scholl, “Stop Apologizing for Being the Bottleneck” extends

    Tools Review and merge

    Revisit this rule
  3. 28
    1999

    When a bug is found tests are created.

    2026

    When a bug is found, the Contract was missing something.

    A bug is a defect in code that's live in production (rule 9). Everything else is refinement.

    Add the missing obligation to the Contract first, make it executable (rule 20), and prove the new test kills the mutant that matches the bug (rule 26). Then fix the code. Every bug leaves the Contract stronger.

    Essays Agustín Calabrese, “One person, a coordinator and a flock: running Impatient Programming alone” agrees

    Tools Generated inputs

    Revisit this rule
  4. 29
    1999

    Acceptance tests are run often and the score is published.

    2026

    The Contract must be met, and contract coverage is published.

    Acceptance tests are the Contract, and the Contract isn't scored: it's either met or it isn't. What gets published is how much of the system the Contract covers.

    Reaching 100% contract coverage is very hard, so the number tells everyone how much of the system is still unwritten.

    Tools The Contract

    Revisit this rule