Intro

eXtreme Programming, Revisited

A little orange robot has run off a cliff edge and hangs in mid-air, legs still running. Huff stands on solid ground with the leash pulled taut in both hands, looking unimpressed.
On this page
  1. The software development landscape in Y2k
  2. Both failures are back with a vengeance
  3. Lazy, impatient and proud
  4. The rules, revisited
  5. Guardrails are the new craft
  6. Born at ZAR
  7. Who IMP is for
  8. Liner notes

I don't remember why anymore, but in early 2000 I managed to be one of the first subscribers to the original XP mailing list. As a result, Ross Rankin and I decided to make his startup Media Ocean the first company in Atlanta, Georgia to fully embrace eXtreme Programming. We had pairing stations, wrote our tests first, played the planning game, and faithfully did standup meetings for years, eventually growing to dozens of engineers. As a result of that, on a freezing cold winter night in December 2000, Paul Gale, Chris Gardner, Andrew Fuqua, and I founded the Atlanta XP User Group. It was very successful, and in 2003 I hosted a gathering that changed my life. We took Martin Fowler out to dinner, and he encouraged me to join ThoughtWorks, where I was hired not too long afterwards.

Most of the projects in my career since then have been managed using XP of some flavor or another. Over the years, I was able to meet or work with a many XP legends such as Kent Beck and Ron Jeffries, and even got to pair with Ward Cunningham. (Yes, my number is zero.) I even hired Robert Martin himself to mentor my team at Hashrocket. In other words, I experienced the rise (and fall) of XP and Agile up close, and it shaped how I think about building software more than anything else in my career.

That history makes me quite convinced about the moment we are currently experiencing, as someone who was in the room the last time our industry completely reinvented itself.

We're the cartoon character who ran off the cliff and hasn't looked down yet. Everyone has gained these amazing magical powers of creation and is generating way too much code, everywhere, all at once. And from what I'm hearing, almost every software development team out there is currently arguing about whether to slam their foot on the gas or slam on the brakes, and some of them are doing both at once! People are scared, and plenty of them have good reason to be.

I've seen this before. As they say, history doesn't repeat, but it rhymes.

The software development landscape in Y2k

XP took off like a wildfire in the year 2000 because it answered two failures at once. Not one. Two.

The first and favorite boogeyman for all of us early adopters in the corporate world was Big Design Up Front (BDUF). Teams doing "waterfall" spent months on requirements that were already out of date by the time they were tossed "over the wall" to the programmers. Feedback cycles were measured in years. Programmers had no say in designing the systems they implemented, that was the job of analysts and architects in their castle towers.

Ironically, the second mess addressed by XP was far more common, but hardly anyone talks about it anymore. Most software in the 90s and 2000s got built with no process at all. It was the age of cowboys. I know, because before XP, I was one of them. Get stuff done, and throw it over the wall to QA. Assuming you had QA, otherwise you did it live in production and crossed your fingers.

Extreme Programming made a lot of sense by taking things that were considered "best practice" at the time and turning them up as far as they could go. For example, if testing is good, then test all the time (e.g. TDD). If code review is good, then review every line as it's written, which many people might not realize is what the purpose of full-time pair programming is. If integration is good, integrate continuously. If customer feedback is good, then get the customer (e.g. product owner or stakeholders) relocated into the same room as the programmers. And in the age of smelly fat neckbeards, that last tidbit was often met with extreme levels of resistance! But we were rebels fighting for sanity and results! Fighting the good fight, and it worked. And then Scrum ruined it all. And then ChatGPT happened, and now AGI (probably?), so we're in a singularity? And...

Hang on with that for a sec, cause guess what?

Both failures are back with a vengeance

Consider how most people make software in the age of AI.

The new BDUF is machine-generated plans that nobody reads. The other day I watched a friend scroll through page after page after page of AI slop in Confluence. He explained that nobody reads it, but inevitably someone directs Claude to turn the Confluslop into Jira epics and user stories. Which presumably is picked up by someone's Claude Code to actually do the work? Nobody knows, exactly. I got the impression everyone on his team just sits in front of the clanker and hits enter all day. They’re not particularly happy about it, but for six figures a year, I guess it's good while it lasts. They know it won't last long, cause it's nonsense.

Confluslop. Waterfall development for the TikTok generation.

The new wild west of no-software-process-development is nothing other than vibe coding. My books helped teach generations of programmers to value convention over configuration with Ruby on Rails. Coding agents have completely flipped that on its head, and even DHH himself is enthralled. Every developer (vibe or otherwise) now has an infinite amount of configuration knobs and switches living in who knows what amount of unstructured English prompts that they use to "create software" based on literally whatever the model decides to spit out that day. Ten developers with ten agents each, and an exponential explosion of architectural and design approaches to whatever they deliver. Sound familiar?

Those of you reading this that took the "engineer" part of your job title seriously are suffering. The rants are all over X and LinkedIn and every Slack across the world. These failures are the crisis of the moment in October 2026.

The good news is that despite the confusion everywhere, XP can inspire what comes next. Take what works, turn the dials up to 11, and give the result a catchy brand name people can rally around.

So my friends, I'm taking a shot at just that.

I'm calling it Impatient Programming. IMP for short. Practitioners are Imps, and we keep our clankers on tight leashes. 😈

Lazy, impatient and proud

The name comes from Larry Wall, one of my earliest programming heroes. (Trivia: I was a Perl guy in the late 90s!) In Programming Perl he listed the three great virtues of a programmer: laziness, impatience and hubris. All three of those virtues are safer than ever to practice in earnest using AI coding agents, as long as we put guardrails in place to keep them honest.

XP values mixed with Larry's virtues, make a killer combination.

Impatience, kept honest by feedback. This one is in the name. We're impatient. We want to ship as much as possible, as quickly as possible, so speed is a core value. We read as little code as possible. We have zero tolerance for technical debt, it gets eliminated immediately. Every merge gets released. The customer sees the work this week. A known-wrong shape doesn't get to live another day.

Laziness, kept honest by simplicity. Wall's lazy programmer goes to great lengths to save effort overall. In IMP that means putting an enormous amount of effort into continuous (and ideally automated!) guardrail engineering, so that no coding agent ever makes the same mistake more than once. It also means doubling down on convention over configuration and expressive language. In the most extreme implementations of IMP, we completely hand over ownership of maintenance work to autonomous agents.

Hubris, kept honest by courage and respect. Wall's proud programmer writes code that other people won't want to say bad things about. In IMP that means we will (in the words of Garry Tan) boil the lake, but the result is still going to be tight, complete software, in codebases that are as close to architectural perfection as possible. With great AI powers comes great responsibility, to make sure that our messes do not derail others on the team. There's no longer any excuse to not shoot for perfection.

XP's own values carry over untouched: communication, simplicity, feedback, courage and respect. Nobody has to give those up to become an imp. But most of all, and this is my biggest individual contribution to this movement, there's the heart.

My friend Jerry Weinberg said that no matter how it looks at first, it's always a people problem. I've found that's true, and that the reverse is true too. When we win, it's always because the people involved are amazing individuals. Putting people first is the most impish thing you can do in the age of the clankers. It's also what I think keeps IMP inside the Agile tradition, whose champions I hope embrace Impatient Programming. Nothing about this is a joke.

The rules, revisited

In 1999 Don Wells put the rules of Extreme Programming on a single web page, in five groups: planning, managing, designing, coding and testing. I 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 the ones that changed the most.

Rule 21, 1999: All production code is pair programmed.

Pair programming won

This one is perhaps the biggest irony of all, and I can't be the only one feeling that way. 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 all day, every day.

Rule 13, 1999: Choose a system metaphor.

The metaphor finally has a home!

System metaphor was the XP practice teams found hardest to apply. As a word nerd, that always made me really sad. Metaphor asked the team to share one mental model of the system, and to give it a name, and backstory and all that. At least I think that's what it was, because in reality no team I ever worked with interpreted it the same way. The problem is that the metaphor lived in people's heads. Well, I guess it also lived on whiteboards and in theory, the codebase, where it was supposed to influence naming choices, naming being one of the hardest things in computer science and all that. 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. That includes the non-functional obligations nobody writes down. Picture a component that averages 100 milliseconds, and a caller that times out at 150. Someone innocently refactors the component to make it "better designed" except now it averages 140 milliseconds. The better design made things worse, because now you have intermittent failures nobody can explain, because the contract that mattered was never written down anywhere in a form that our coding agents could use as guardrails.

The Contract isn't user stories, redux. Entire systems can get regenerated in an afternoon now. (Ruby on Rails apps get rewritten as Rust!) We only regenerate when it's worth doing, but we keep everything regenerable, the way you run a fire drill without burning the building down. If you can't rebuild a component from its Contract, the Contract is missing something. The Contract is now the thing most worth protecting. It should be convention-oriented and structured language, and it should be versioned, and if you work in a team, you probably want to make it the main focus of your "code reviews" well after everyone stops looking at implementation code.

Rule 20, 1999: Code the unit test first.

Test first became the Contract

XP said write the unit test first. IMP says agree on the Contract. Throughout the inhale I talk through what we're building with Claude, and it writes each obligation into the Contract as it works. Making sure the Contract is complete is part of the exhale. 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. But the most important take-away is that by the time the PR merges, the Contract has to capture the invariants that the result must adhere to. Functional and non-functional.

Rule 26, 1999: All code must have unit tests.

Every test has to earn its place

XP said all code must have unit tests. IMP says 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.

Rule 12, 1999: 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.

Rule 16, 1999: No functionality is added early.

Experiment on what to build, then feel free to "boil the lake"

XP said add no functionality early. IMP says 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.

XP had a name for this: the spike. 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.

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.

Rule 18, 1999: The customer is always available.

Stop guessing what the customer wants

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.

Rule 14, 1999: Use CRC cards for design sessions.

Start with artifacts

I never liked drawing boxes on whiteboards. I used to say I think with my fingers, so I jumped straight into code. That worked for me because I'm a fast coder and have been doing what I do for 30 years. It doesn't work for everyone. It doesn't even necessarily work for me anymore, because planning and design is so much easier than it used to be.

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

Rule 4, 1999: The project is divided into iterations.

No iterations. A showcase instead.

For me, XP iterations existed for one reason, which was tracking velocity. They were never supposed to set release cadence.

Then Scrum came along and ruined everything. A team picks two weeks of work and controls it completely. Then they coast for most of the two weeks and rush shoddy work at the end, no thank you. Those are the wrong kind of deadlines, and completely obsolete in the age of AI.

IMP has no iterations. Work flows pull request by pull request. 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. 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.

Rule 1, 1999: User stories are written.

Get your story straight

The showcase closes the week. Getting your story straight opens it. Before you commit to a project, write down your success criteria for the week and post them where the team can see them. 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.

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.

Rule 9, 1999: The Project Velocity is measured.

Measure 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. And when you find a real bug, the Contract was missing something. Write the missing obligation into the Contract, make it executable, prove the new test catches the bug, and then fix the code. Every bug leaves the Contract stronger.

Rule 6, 1999: Give the team a dedicated open work space.

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.

Every morning our autonomous agents post a public brief on what they and/or their teams worked on for the last 24 hours.

Rule 27, 1999: All code must pass all unit tests before it can be released.

Green merges itself

XP said all code must pass all tests before release. IMP says 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.

Guardrails are the new craft

Here's what I tell programmers who love the craft and don't want to become Product Engineers focused on business outcomes.

Platform and infrastructure work is where the technical frontier lives now. If you want to stay deeply technical, working on hardcore nerdy stuff, then you're going to have to embrace working on ever-improving guardrails. That means harnesses, agent orchestration, knowledge graphs, and intelligent event-based nervous systems. Auto-optimizing loops and evals.

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. Every software team in the world is improvising its own bumpers right now. Until established frameworks exist that let you apply conventions to writing full-featured IMP-style contracts, building guardrails is the most interesting work in software. That's the bleeding edge, and it's why I spend my days on it at ZAR.

Born at ZAR

XP was born on Chrysler's C3 payroll project. IMP was born at ZAR, where I'm CTO. We give people in places like Pakistan, Bangladesh, and Nigeria access to dollars, debit cards, stocks and gold. We're a financial technology company. People depend on what we build, so it has to be right. And yet our core product engineers run ten Claude Code sessions at a time and delegate subsystem maintenance to autonomous agents. Impatient Programming works here, it isn't a toy or a joke.

Last month, I deleted substantial components from Agora, our agent orchestration platform. Claude Code regenerated each one, working only from a written intent, a set of decision records and an executable Contract. It regenerated without access to the old code. I ran seven experiments over nine days on three components.

Three things stood out:

  • The contract outperformed the old spec. Mutation testing showed the executable contract, written from the component's promises, catching more broken code than the Rspec suite of tests belonging to the old implementation.
  • Every gap helped flesh out the contract. Wherever the intent didn't say something, the regenerations made unpredictable choices. Each of those gaps became a sentence in the next revision of the Contract.
  • It found a real bug. One experiment found that a human admin's click during an agent reboot cycle was getting lost in production. It was fixed in the next run.

My friend Chad Fowler has been writing publicly about regenerative software, and his work is deeply influential to Impatient Programming. He was also an early adopter of XP, but he lost interest when it got absorbed into Agile because, in his words: "the rigor drained out."

IMP's response is that our rigor doesn't depend on belief. The rules run in machines: mutation gates, executable contracts, merge checks, guardrails on every change. A name can't drain rigor that's enforced by a build.

Read the case study

Who IMP is for

IMP is for teams doing professional software engineering, the kind of team that wants to pick a method, adopt it as its way of working, and tell the rest of the company, "This is how we work now." Individuals can take pieces of it, but it's intended for teams.

People are looking for something to shield them from the AI chaos and quell the fear of becoming a "meat proxy". In the 2000s a team lead could say "we do XP" and people knew what it meant. I want that again.

We're hanging in the air. We can fall, or we can grow wings. I'm an optimist.


Liner notes

Kent Beck, Ward Cunningham, Ron Jeffries and Don Wells drew the first map. Larry Wall named the virtues. Gerald Weinberg taught us it's always a people problem. Peter Naur saw the theory behind the code. Ryan Singer's Shape Up gave us the hill. Garry Tan boils lakes and oceans. Eric Ries taught a generation to experiment. C. Northcote Parkinson explained why deadlines expand. Chad Fowler named regenerative software, and Frank Westphal mapped XP onto AI first. IMP was born at ZAR, from practices my colleagues and I have developed and use every day, and a couple of them deserve thanks by name: Stephen Margheim, Brandon Timinsky, and Sebastian Scholl.