Skip to main content
skill CX Codex

xp-practices — Claude Code skill: XP practices and how to install

xp-practices — a skill for pair programming, continuous integration, TDD, and other extreme programming practices in AI coding.

MIT 125 installs ★ 533 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add proffesor-for-testing/agentic-qe --skill xp-practices -a claude-code
Open on GitHub

What xp-practices does

Applies Extreme Programming practices: TDD, pair programming with an agent, continuous integration, collective code ownership. Includes a priority table (what to start with), pairing modes (Driver-Navigator, Ping-Pong with TDD), and guidance for switching roles every 20–30 minutes. Coordinates a fleet of sub-agents — qe-test-generator, qe-test-executor, qe-code-reviewer — for testing, risk analysis, and code review.

The agent handles grunt work (regression testing, data generation, coverage analysis), the human handles exploratory testing and strategy. The skill saves pairing sessions, CI metrics, and retrospectives in the aqe/xp-practices/ namespace. A "When to Pair" table specifies that complex code, new technology, onboarding, and critical bugs require pairing; simple tasks and research spikes can be done solo.

From the agentic-qe QA automation suite, works with TDD, refactoring, and pair programming practices. Version 1.0, optimized December 3, 2025.

What it helps with

  • coordinate TDD, pair programming, and CI in a team with AI agents
  • split routine work between agent and human
  • choose which XP practice to adopt first
  • automate regression testing in continuous integration
  • store pairing sessions and team velocity metrics

Example prompts for the agent

  • Start a TDD session in Ping-Pong mode: I write a test, you implement it, then we switch
  • Analyze risks for this PR and generate tests for the affected code
  • Run the fleet for the XP workflow: test generation, execution, code review

How to install xp-practices

1Skills CLI (Vercel)

npx skills add proffesor-for-testing/agentic-qe --skill xp-practices -a claude-code

2Manually: put the files in place

~/.claude/skills/xp-practices/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/xp-practices/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about xp-practices

How to install xp-practices in Claude Code?

Run npx skills add proffesor-for-testing/agentic-qe --skill xp-practices -a claude-code, the skill will appear in ~/.claude/skills/xp-practices/SKILL.md.

What does xp-practices do?

Applies extreme programming practices: TDD, pair programming with an agent, continuous integration. Coordinates sub-agents for testing, risk analysis, and code review, splits routine and creative work between agent and human.

Which sub-agents does xp-practices need?

The skill coordinates qe-test-generator, qe-test-executor, and qe-code-reviewer from the agentic-qe suite. They generate tests, run them, and perform code reviews within the XP workflow.

Source text

SKILL.md · MIT
---
name: xp-practices
description: "Apply XP practices including pair programming, ensemble programming, continuous integration, and sustainable pace. Use when implementing agile development practices, improving team collaboration, or adopting technical excellence practices."
category: methodology
priority: medium
tokenEstimate: 1000
agents: [qe-quality-analyzer, qe-test-executor, qe-code-reviewer]
implementation_status: optimized
optimization_version: 1.0
last_optimized: 2025-12-03
dependencies: []
quick_reference_card: true
tags: [xp, agile, pair-programming, tdd, continuous-integration, collaboration]
trust_tier: 0
validation:
---

# 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):**
| Practice | Start Here | Why First |
|----------|------------|-----------|
| 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
```
</default_to_action>

## Quick Reference Card

### When to Pair

| Context | Pair? | Why |
|---------|-------|-----|
| 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 |

---

## Agent Integration

```typescript
// 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
```typescript
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'
});
```

---

## Related Skills
- [tdd-london-chicago](../tdd-london-chicago/) - TDD deep dive
- [refactoring-patterns](../refactoring-patterns/) - Safe refactoring
- [pair-programming](../pair-programming/) - AI-assisted pairing

---

## Remember

**XP practices work as a system** - TDD enables collective ownership, CI enables small releases, pairing enables collective ownership. Don't cherry-pick randomly.

**With Agents:** Pair humans with agents. Agents handle repetitive work (regression, data generation, coverage analysis), humans provide judgment and creativity.

© proffesor-for-testing · MIT · proffesor-for-testing/agentic-qe

Similar skills

All skills for Testing and QA →

From the same set73

The whole set →
n8n-expression-testing n8n-expression-testing is a Claude Code skill that checks n8n expressions against different data contexts, including missing values, while debugging data transformations. CX Codex +1 127installs qe-coverage-analysis qe-coverage-analysis inspects Istanbul, c8, and lcov data to detect untested paths with risk scoring. Useful when prioritizing test efforts or checking PR quality gates. CX Codex +1 127installs test-reporting-analytics test-reporting-analytics generates quality dashboards, executive reports, and failure predictions based on code diffs. Useful when tracking CI/CD trends or preparing release gates. CX Codex +1 126installs qe-iterative-loop qe-iterative-loop — a skill that runs autonomous red-green-refactor cycles: the agent fixes failing tests, achieves coverage targets, and passes quality gates on its own. CX Codex +1 126installs context-driven-testing context-driven-testing adapts software testing strategies to specific project constraints, risks, and goals instead of blindly applying generic best practices. CX Codex +1 125installs n8n-integration-testing-patterns n8n-integration-testing-patterns is a Claude Code skill for testing API contracts, authentication flows, and rate limits in n8n integrations. CX Codex +1 124installs tdd-london-chicago tdd-london-chicago — a skill for choosing London or Chicago TDD, using mocks or real objects, and moving through the Red–Green–Refactor cycle. CX Codex +1 124installs qe-chaos-resilience qe-chaos-resilience — a skill for Claude Code, Codex, Cursor and other agents that injects controlled faults into distributed systems and checks recovery behavior. Runs during circuit breaker, failover, and retry logic validation. CX Codex +1 123installs

Project sponsors

Companies that keep this analytics open