qe-xp-practices（qe xp 实践）

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.