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
npx skills add proffesor-for-testing/agentic-qe --skill xp-practices -a claude-codeWhat 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-code2Manually: put the files in place
~/.claude/skills/xp-practices/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/xp-practices/
1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill xp-practices -a codex2Manually: put the files in place
.agents/skills/xp-practices/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill xp-practices -a cursor2Manually: put the files in place
.cursor/skills/xp-practices/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install proffesor-for-testing/agentic-qe assets/skills/xp-practices2Manually: put the files in place
.github/skills/xp-practices/SKILL.md1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill xp-practices -a gemini-cli2Platform CLI
gemini skills install https://github.com/proffesor-for-testing/agentic-qe --path assets/skills/xp-practicesManually: put the files in place
.devin/skills/xp-practices/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill xp-practices -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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