Extreme Programming (XP) Practices

<default_to_action> When applying XP practices:

1. •START with practices that give immediate value
2. •BUILD supporting practices gradually
3. •ADAPT to your context
4. •MEASURE results

Core XP Practices (Prioritized):

Pairing Quick Start:

Driver-Navigator (Classic):
- Driver: Writes code
- Navigator: Reviews, thinks ahead
- Rotate every 20-30 min

Ping-Pong (with TDD):
A: Write failing test
B: Make test pass + refactor
B: Write next failing test
A: Make test pass + refactor

</default_to_action>

Quick Reference Card

The Five XP Values

Core Practices

Pair Programming

When to Pair

Pairing Dos and Don'ts

Do:

• •✅ Switch roles every 20-30 min
• •✅ Take breaks together
• •✅ Think out loud
• •✅ Ask questions
• •✅ Keep sessions 2-4 hours max

Don't:

• •❌ Grab keyboard without asking
• •❌ Check phone while pairing
• •❌ Dominate conversation
• •❌ Pair all day (exhausting)

Ensemble (Mob) Programming

Setup: 3+ developers, one screen, rotating driver

[Screen]
   ↓
[Driver] ← Directions from navigators
   ↑
[Navigator 1] [Navigator 2] [Navigator 3]

Rotation: Driver switches every 5-10 min

Best for:

• •Complex problem solving
• •Architectural decisions
• •Learning new frameworks
• •Resolving blockers

Continuous Integration

CI Workflow:

1. Pull latest from main
2. Make small change (<2 hrs work)
3. Run tests locally (all pass)
4. Commit and push
5. CI runs tests automatically
6. If fail → fix immediately

Best Practices:

• •Commit frequently (small changes)
• •Keep build fast (<10 min)
• •Fix broken builds immediately
• •Never commit to broken build

Four Rules of Simple Design

(In priority order)

1. •Passes all tests - Works correctly
2. •Reveals intention - Clear, expressive code
3. •No duplication - DRY principle
4. •Fewest elements - No speculative code

Agent Integration

// Agent-human pair testing
const charter = "Test payment edge cases";
const tests = await Task("Generate Tests", { charter }, "qe-test-generator");
const reviewed = await human.review(tests);
await Task("Implement", { tests: reviewed }, "qe-test-generator");

// Continuous integration with agents
await Task("Risk Analysis", { prDiff }, "qe-regression-risk-analyzer");
await Task("Generate Tests", { changes: prDiff }, "qe-test-generator");
await Task("Execute Tests", { scope: 'affected' }, "qe-test-executor");

// Sustainable pace: agents handle grunt work
const agentWork = ['regression', 'data-generation', 'coverage-analysis'];
const humanWork = ['exploratory', 'risk-assessment', 'strategy'];

Agent Coordination Hints

Memory Namespace

aqe/xp-practices/
├── pairing-sessions/*   - Pair/ensemble session logs
├── ci-metrics/*         - CI health metrics
├── velocity/*           - Team velocity data
└── retrospectives/*     - XP retrospective notes

Fleet Coordination

const xpFleet = await FleetManager.coordinate({
  strategy: 'xp-workflow',
  agents: [
    'qe-test-generator',   // TDD support
    'qe-test-executor',    // CI integration
    'qe-code-reviewer'     // Collective ownership
  ],
  topology: 'parallel'
});

Common Objections

Related Skills

• •tdd-london-chicago - TDD deep dive
• •refactoring-patterns - Safe refactoring
• •pair-programming - AI-assisted pairing

Remember

XP practices work as a system. Don't cherry-pick randomly:

• •TDD enables collective ownership
• •CI enables small releases
• •Pairing enables collective ownership
• •Sustainable pace enables everything

With Agents: Agents amplify XP. Pair humans with agents. Agents handle repetitive work, humans provide judgment and creativity.