proffesor-for-testing/agentic-qe

xp-practices

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.

First seen Jan 24, 2026

Installation

$ npx skills add proffesor-for-testing/agentic-qe --skill xp-practices

Similar popular skills

Related neighbors and high-traction skills in the same topics — useful to compare before installing.

Also in this package

Other skills from proffesor-for-testing/agentic-qe · top by installs.

npx skills add proffesor-for-testing/agentic-qe

Browse all from proffesor-for-testing/agentic-qe

More details

Agent compatibility

Declared targets from SKILL.md / docs. Unmarked agents are not listed — the skill may still install via the CLI.

Claude Code Not declared
Cursor Not declared
Codex Not declared
GitHub Copilot Not declared
Windsurf Not declared
Gemini CLI Not declared
Cline Not declared
OpenCode Not declared

Repository health

Stars 475
License LICENSE
Default branch main
Open issues 25
Status Active

Package contents

Files included with this skill beyond the listing page.

  • skill md SKILL.md 3,877 B
  • docs SUMMARY.md 259 B

History

  1. First seen on skills.sh
  2. First recorded snapshot · 111 installs

SKILL.md

Extreme Programming (XP) Practices

<defaulttoaction> 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

</defaulttoaction>

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

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

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.