When applying XP practices:

START with practices that give immediate value
BUILD supporting practices gradually
ADAPT to your context
MEASURE results

Core XP Practices (Prioritized):

| TDD | ✅ Yes | Foundation for everything

| Continuous Integration | ✅ Yes | Fast feedback

| Pair Programming | ✅ Yes | Knowledge sharing

| Collective Ownership | After CI+TDD | Needs safety net

| Small Releases | After CI | Infrastructure dependent

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

Quick Reference Card

The Five XP Values

| Communication | Everyone knows what everyone does | Daily standups, pairing

| Simplicity | Simplest thing that works | YAGNI, small design

| Feedback | Get feedback early and often | TDD, CI, short iterations

| Courage | Tell truth, adapt | Refactor, admit mistakes

| Respect | Everyone contributes value | Sustainable pace, pairing

Core Practices

| Pair Programming | Two devs, one workstation | Quality + knowledge sharing

| TDD | Red-Green-Refactor | Confidence + design

| CI | Integrate multiple times/day | Fast feedback

| Collective Ownership | Anyone can change anything | No bottlenecks

| Sustainable Pace | 40-hour weeks | Long-term productivity

| Small Releases | Ship frequently | Risk reduction

Pair Programming

When to Pair

| Complex/risky code | ✅ Always | Needs multiple perspectives

| New technology | ✅ Always | Learning accelerator

| Onboarding | ✅ Always | Knowledge transfer

| Critical bugs | ✅ Always | Two heads better

| Simple tasks | ❌ Skip | Not worth overhead

| Research spikes | ❌ Skip | Pair to discuss findings

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)

Passes all tests - Works correctly
Reveals intention - Clear, expressive code
No duplication - DRY principle
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

| "Pairing is 2x slower" | 15% slower writing, 15% fewer bugs, net positive

| "No time for TDD" | Debugging takes longer than testing

| "CI is hard to setup" | Start simple: one action, one test

| "Collective ownership = chaos" | Only without tests + CI

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.

安装