xp-practices

Apply XP practices including TDD, CI, Pair Programming to software teams.

6|3|Updated Dec 3, 2025
One-click install
npx skills add https://github.com/pacphi/ampel --skill xp-practices-pacphi
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: xp-practices
Source: https://github.com/pacphi/ampel/tree/main/.claude/skills/xp-practices
Command: npx skills add https://github.com/pacphi/ampel --skill xp-practices-pacphi

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Extreme Programming (XP) practices provide a concrete, value-driven approach to improve team collaboration, code quality, and sustainable pace in software delivery.

Core Features & Use Cases

  • Core XP Practices: TDD, Continuous Integration (CI), Pair Programming
  • Adaptive Sequencing: Collective Ownership and Small Releases after CI and TDD
  • Team Collaboration: Pairing patterns (Driver-Navigator, Ping-Pong), ensemble programming when appropriate

Use XP to raise quality while keeping teams aligned, reducing integration pain, and delivering value faster.

Quick Start

  • Begin with Pair Programming sessions and TDD cycles
  • Adopt CI early and build a quick action plan around small releases
  • Use ensemble programming for complex architectural decisions

Frequently Asked Questions about xp-practices

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement test-driven development in an agile team?

Test-driven development (TDD) is writing tests before code to drive design and catch defects early. Start with small test cycles, write a failing test, implement code to pass it, then refactor. TDD reduces bugs, improves design, and pairs well with pair programming and continuous integration in agile workflows.

What's the best way to set up continuous integration for frequent releases?

Continuous integration (CI) automates code building, testing, and validation on every commit. Set up a CI workflow that runs test suites immediately, provides quick feedback, and gates merges to main branches. CI enables small releases, reduces integration pain, and supports sustainable delivery pace.

How do pair programming and ensemble programming improve code quality?

Pair programming uses driver-navigator roles where two developers work on one task, catching errors in real time and sharing knowledge. Ensemble programming scales this to teams tackling complex decisions together. Both practices boost code quality, reduce defects, and accelerate onboarding and learning on complex domains.

What practices should I adopt first when introducing XP to my team?

Begin with pair programming sessions and test-driven development cycles to build team alignment and quality habits. Adopt continuous integration early to catch integration issues. Build a prioritized roadmap of XP core practices—TDD, CI, pairing rotations, and small releases—tailored to your team's context and risk areas.

Can I use XP practices across complex domains and frequent releases?

Yes. XP practices scale to complex architectural decisions through ensemble programming, reduce risks in high-stakes components via TDD and CI, and support frequent releases through small-release guidance and sustainable pace. Clear roles and agent-assisted coordination help teams balance collaboration with delivery velocity.

Why does collective ownership matter in XP workflows?

Collective ownership means any team member can modify any part of the codebase, supported by TDD, CI, and pair programming. This reduces knowledge silos, accelerates onboarding, and enables small releases without bottlenecks. It reinforces team alignment and makes code maintenance faster and safer.