Extreme Programming (XP)
What is Extreme Programming (XP)?
Extreme Programming (XP) is an agile method created by Kent Beck in the 1990s that pushes proven engineering practices to the limit, including pair programming, test-driven development and continuous integration.
Updated November 2026 · 3 min read
Extreme Programming (XP) is an agile software development method built around a set of tightly linked engineering practices: short release cycles, test-driven development, pair programming, continuous integration, simple design and constant refactoring. The name reflects its approach of taking practices known to work and turning them up to the extreme. If code reviews are good, review all the time through pairing. If testing is good, write tests before the code.
XP was developed by Kent Beck in the mid-1990s, most famously on the Chrysler Comprehensive Compensation (C3) payroll project, with Ron Jeffries and Ward Cunningham among its early contributors. Beck described it in Extreme Programming Explained (1999), and a second edition with Cynthia Andres followed in 2004. Several XP practices, especially continuous integration and test-driven development, are now standard across the industry, including on teams that have never heard of XP.
The five values of extreme programming
- Communication. Problems usually come from someone not knowing something; XP practices keep people talking.
- Simplicity. Build the simplest thing that works today, not what might be needed later.
- Feedback. Get feedback from tests, from the system and from customers as quickly as possible.
- Courage. Tell the truth about progress, throw away code that is not working and make large changes when needed.
- Respect. Added in the second edition: team members respect each other and the work.
Core XP practices
| Practice | What it means |
|---|---|
| Planning game | Customers choose and prioritize stories; developers estimate them |
| Small releases | Put working software in users' hands in short release cycles |
| Test-driven development | Write a failing test first, then the code to pass it, then refactor |
| Pair programming | Two developers work at one workstation on the same code |
| Continuous integration | Integrate and test changes many times a day |
| Refactoring | Improve the design of existing code without changing its behavior |
| Simple design | Avoid speculative features and complexity |
| Collective code ownership | Anyone can change any part of the code |
| On-site customer | A real customer or customer proxy is available to answer questions |
| Sustainable pace | Avoid long overtime; originally the "40-hour week" |
| Coding standards | Shared conventions so code reads as if one person wrote it |
The practices support each other. Collective ownership is safe because of the tests, refactoring is safe because of continuous integration, and pairing spreads the knowledge that collective ownership needs.
XP vs. Scrum
Scrum is a management framework: it defines roles, events and artifacts but says nothing about how to write code. XP is primarily an engineering method. The two combine well, and many teams run Scrum events with XP technical practices underneath. Differences in emphasis include shorter iterations in XP (traditionally one to two weeks), XP's willingness to swap in new high-priority stories mid-iteration if work has not started, and XP's prescriptive engineering discipline.
A hypothetical XP adoption
Consider a hypothetical six-person team that releases quarterly and spends the last three weeks of every quarter fixing integration bugs. The team adopts XP practices in stages. It starts with continuous integration and test-driven development for all new code, then introduces pairing on risky changes, and moves to one-week iterations.
In each weekly planning game, the product manager, acting as the on-site customer, brings 45 points of prioritized stories, and the developers confirm that 30 points fit their recent pace. The product manager chooses which 30 points matter most. After six months, the team releases every week, the end-of-quarter stabilization period is gone, and new team members become productive faster because pairing teaches them the codebase.
Common pitfalls
- Picking practices in isolation. Collective ownership without tests, or refactoring without continuous integration, increases risk instead of reducing it.
- Pairing all day, every day, by mandate. Pairing is tiring. Many teams pair on complex or risky work and work solo on routine changes.
- No real customer. Without someone who can make product decisions quickly, the short feedback loops break down.
- Dropping sustainable pace. XP assumes rested people make fewer mistakes. Constant overtime undermines quality.
XP is one of the founding methods of agile software development, and Kent Beck was among the authors of the Agile Manifesto. Its practices also form much of the engineering foundation of DevOps.
Frequently asked questions
What is the difference between Extreme Programming and Scrum?
Scrum is a management framework that defines roles, events and artifacts but says nothing about how to write code, while Extreme Programming is mainly an engineering method. XP traditionally uses shorter iterations of one to two weeks and allows swapping in new high-priority stories mid-iteration if work has not started. Many teams run Scrum events with XP practices underneath.
Which engineering practices does Extreme Programming use?
XP's practices include test-driven development, pair programming, continuous integration many times a day, small releases, refactoring, simple design, collective code ownership, coding standards, an on-site customer, a planning game and a sustainable pace. They reinforce each other: tests make shared ownership safe, and pairing spreads the knowledge shared ownership needs.
Who created Extreme Programming?
Kent Beck developed Extreme Programming in the mid-1990s, most famously on Chrysler's C3 payroll project, with Ron Jeffries and Ward Cunningham among its early contributors. Beck described the method in Extreme Programming Explained (1999), and a second edition written with Cynthia Andres followed in 2004, adding respect as a fifth value.
Related terms
Test-Driven Development (TDD)
Write the test first, make it pass, then refactor.
Pair Programming
Two developers, one keyboard: continuous review as code is written.
Continuous Integration (CI)
Merging code often, with every change built and tested automatically.
Scrum
An agile framework of short Sprints, three roles and regular inspection.