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

PracticeWhat it means
Planning gameCustomers choose and prioritize stories; developers estimate them
Small releasesPut working software in users' hands in short release cycles
Test-driven developmentWrite a failing test first, then the code to pass it, then refactor
Pair programmingTwo developers work at one workstation on the same code
Continuous integrationIntegrate and test changes many times a day
RefactoringImprove the design of existing code without changing its behavior
Simple designAvoid speculative features and complexity
Collective code ownershipAnyone can change any part of the code
On-site customerA real customer or customer proxy is available to answer questions
Sustainable paceAvoid long overtime; originally the "40-hour week"
Coding standardsShared 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.