Agent skill

Qe Pair Programming

by proffesor-for-testing in proffesor-for-testing/agentic-qe

AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, quality monitoring, and comprehensive testing.

MITAuto-check passedDevelopment

Install Qe Pair Programming

skills CLI

$ npx skills add proffesor-for-testing/agentic-qe --skill qe-pair-programming -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install proffesor-for-testing/agentic-qe qe-pair-programming --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/proffesor-for-testing/agentic-qe.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.kiro/skills/qe-pair-programming .claude/skills/qe-pair-programming && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "qe-pair-programming" agent skill from https://github.com/proffesor-for-testing/agentic-qe/tree/main/.kiro/skills/qe-pair-programming into .claude/skills/qe-pair-programming/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "qe-pair-programming", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/proffesor-for-testing/agentic-qe/tree/main/.kiro/skills/qe-pair-programming

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add proffesor-for-testing/agentic-qe --skill qe-pair-programming -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install proffesor-for-testing/agentic-qe qe-pair-programming --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/proffesor-for-testing/agentic-qe.git skills-src && mkdir -p .agents/skills && cp -r skills-src/.kiro/skills/qe-pair-programming .agents/skills/qe-pair-programming && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "qe-pair-programming" agent skill from https://github.com/proffesor-for-testing/agentic-qe/tree/main/.kiro/skills/qe-pair-programming into .agents/skills/qe-pair-programming/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "qe-pair-programming", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add proffesor-for-testing/agentic-qe --skill qe-pair-programming -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install proffesor-for-testing/agentic-qe qe-pair-programming --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/proffesor-for-testing/agentic-qe.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/.kiro/skills/qe-pair-programming .cursor/skills/qe-pair-programming && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "qe-pair-programming" agent skill from https://github.com/proffesor-for-testing/agentic-qe/tree/main/.kiro/skills/qe-pair-programming into .cursor/skills/qe-pair-programming/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "qe-pair-programming", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/proffesor-for-testing/agentic-qe.git --path .kiro/skills/qe-pair-programming

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add proffesor-for-testing/agentic-qe --skill qe-pair-programming -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install proffesor-for-testing/agentic-qe qe-pair-programming --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/proffesor-for-testing/agentic-qe.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/.kiro/skills/qe-pair-programming .gemini/skills/qe-pair-programming && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "qe-pair-programming" agent skill from https://github.com/proffesor-for-testing/agentic-qe/tree/main/.kiro/skills/qe-pair-programming into .gemini/skills/qe-pair-programming/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "qe-pair-programming", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install proffesor-for-testing/agentic-qe qe-pair-programming

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add proffesor-for-testing/agentic-qe --skill qe-pair-programming -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/proffesor-for-testing/agentic-qe.git skills-src && mkdir -p .github/skills && cp -r skills-src/.kiro/skills/qe-pair-programming .github/skills/qe-pair-programming && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "qe-pair-programming" agent skill from https://github.com/proffesor-for-testing/agentic-qe/tree/main/.kiro/skills/qe-pair-programming into .github/skills/qe-pair-programming/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "qe-pair-programming", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add proffesor-for-testing/agentic-qe --skill qe-pair-programming -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install proffesor-for-testing/agentic-qe qe-pair-programming --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/proffesor-for-testing/agentic-qe.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/.kiro/skills/qe-pair-programming .opencode/skills/qe-pair-programming && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "qe-pair-programming" agent skill from https://github.com/proffesor-for-testing/agentic-qe/tree/main/.kiro/skills/qe-pair-programming into .opencode/skills/qe-pair-programming/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "qe-pair-programming", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: qe-pair-programming
GitHub stars: 494
Used in: 6 other repos
Token cost: ~6k tokens
SKILL.md length: 779 words
Files: 1
Skills in repo: 111
Repo updated: Oct 4, 2026
First seen: Oct 7, 2026
Licence: MIT

At a glance

AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, quality monitoring, and comprehensive testing.

Works in 5 steps: 30-second warning before switch → Current driver completes thought → Context summary generated → …
Tasks that involve Test-driven development
SKILL.md covers What This Skill Does, Prerequisites, Quick Start and Complete Guide
Calls npm

What it does

Qe Pair Programming is an agent skill from proffesor-for-testing/agentic-qe. AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, quality monitoring, and comprehensive testing. Supports TDD, debugging, refactoring, and learning sessions. Features automatic role switching, continuous code review, security scanning, and performance optimization with truth-score verification.

Its SKILL.md is about 6k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Test-driven development, Refactoring and Performance optimization. The repository describes itself as: Agentic QE Fleet is an open-source AI-powered QA/QE platform designed for use with Coding Agents (works best with Claude Code) featuring specialized agents and skills to support… The licence is MIT.

When your agent uses it

Tasks that involve Test-driven development
Tasks that involve Refactoring
Tasks that involve Performance optimization

Example prompts

“/qe-pair-programming”

Requirements

Node.js

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

30-second warning before switch
Current driver completes thought
Context summary generated
Roles swap smoothly
New driver continues

What it can do on your machine

Read from SKILL.md and the folder at commit 829d030. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Shell commands in SKILL.md call:
- npm
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md. Its commands use npm, which can reach the network depending on how they are called.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Qe Pair Programming loads about 6k tokens when it runs. Until then it costs about 91 tokens; SKILL.md has 779 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~91
When it runs · the whole SKILL.md, loaded when a task matches: ~6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from proffesor-for-testing/agentic-qe at commit 829d030, republished under its MIT licence (© proffesor-for-testing). 779 words, ~6,050 tokens.

Download SKILL.mdSave it as .claude/skills/qe-pair-programming/SKILL.md (or your agent's skills folder).

name: qe-pair-programming
description: AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, quality monitoring, and comprehensive testing. Supports TDD, debugging, refactoring, and learning sessions. Features automatic role switching, continuous code review, security scanning, and performance optimization with truth-score verification.
inclusion: auto

Pair Programming

Collaborative AI pair programming with intelligent role management, real-time quality monitoring, and comprehensive development workflows.

What This Skill Does

This skill provides professional pair programming capabilities with AI assistance, supporting multiple collaboration modes, continuous verification, and integrated testing. It manages driver/navigator roles, performs real-time code review, tracks quality metrics, and ensures high standards through truth-score verification.

Key Capabilities:

Multiple Modes: Driver, Navigator, Switch, TDD, Review, Mentor, Debug
Real-Time Verification: Automatic quality scoring with rollback on failures
Role Management: Seamless switching between driver/navigator roles
Testing Integration: Auto-generate tests, track coverage, continuous testing
Code Review: Security scanning, performance analysis, best practice enforcement
Session Persistence: Auto-save, recovery, export, and sharing

Prerequisites

Required:

Claude Flow CLI installed (npm install -g claude-flow@alpha)
Git repository (optional but recommended)

Recommended:

Testing framework (Jest, pytest, etc.)
Linter configured (ESLint, pylint, etc.)
Code formatter (Prettier, Black, etc.)

Quick Start

Basic Session

bash

# Start simple pair programming
claude-flow pair --start

TDD Session

bash

# Test-driven development
claude-flow pair --start \
  --mode tdd \
  --test-first \
  --coverage 90

Complete Guide

Session Control Commands

Starting Sessions

bash

# Basic start
claude-flow pair --start

# Expert refactoring session
claude-flow pair --start \
  --agent senior-dev \
  --focus refactor \
  --verify \
  --threshold 0.98

# Debugging session
claude-flow pair --start \
  --agent debugger-expert \
  --focus debug \
  --review

# Learning session
claude-flow pair --start \
  --mode mentor \
  --pace slow \
  --examples

Session Management

bash

# Check status
claude-flow pair --status

# View history
claude-flow pair --history

# Pause session
/pause [--reason <reason>]

# Resume session
/resume

# End session
claude-flow pair --end [--save] [--report]

Available Modes

Driver Mode

You write code while AI provides guidance.

bash

claude-flow pair --start --mode driver

Your Responsibilities:

Write actual code
Implement solutions
Make immediate decisions
Handle syntax and structure

AI Navigator:

Strategic guidance
Spot potential issues
Suggest improvements
Real-time review
Track overall direction

Best For:

Learning new patterns
Implementing familiar features
Quick iterations
Hands-on debugging

Commands:

/suggest     - Get implementation suggestions
/review      - Request code review
/explain     - Ask for explanations
/optimize    - Request optimization ideas
/patterns    - Get pattern recommendations

Navigator Mode

AI writes code while you provide direction.

bash

claude-flow pair --start --mode navigator

Your Responsibilities:

Provide high-level direction
Review generated code
Make architectural decisions
Ensure business requirements

AI Driver:

Write implementation code
Handle syntax details
Implement your guidance
Manage boilerplate
Execute refactoring

Best For:

Rapid prototyping
Boilerplate generation
Learning from AI patterns
Exploring solutions

Commands:

/implement   - Direct implementation
/refactor    - Request refactoring
/test        - Generate tests
/document    - Add documentation
/alternate   - See alternative approaches

Switch Mode

Automatically alternates roles at intervals.

bash

# Default 10-minute intervals
claude-flow pair --start --mode switch

# 5-minute intervals (rapid)
claude-flow pair --start --mode switch --interval 5m

# 15-minute intervals (deep focus)
claude-flow pair --start --mode switch --interval 15m

Handoff Process:

30-second warning before switch
Current driver completes thought
Context summary generated
Roles swap smoothly
New driver continues

Best For:

Balanced collaboration
Knowledge sharing
Complex features
Extended sessions

Specialized Modes

TDD Mode - Test-Driven Development:

bash

claude-flow pair --start \
  --mode tdd \
  --test-first \
  --coverage 100

Workflow: Write failing test → Implement → Refactor → Repeat

Review Mode - Continuous code review:

bash

claude-flow pair --start \
  --mode review \
  --strict \
  --security

Features: Real-time feedback, security scanning, performance analysis

Mentor Mode - Learning-focused:

bash

claude-flow pair --start \
  --mode mentor \
  --explain-all \
  --pace slow

Features: Detailed explanations, step-by-step guidance, pattern teaching

Debug Mode - Problem-solving:

bash

claude-flow pair --start \
  --mode debug \
  --verbose \
  --trace

Features: Issue identification, root cause analysis, fix suggestions

In-Session Commands

Code Commands

/explain [--level basic|detailed|expert]
  Explain the current code or selection

/suggest [--type refactor|optimize|security|style]
  Get improvement suggestions

/implement <description>
  Request implementation (navigator mode)

/refactor [--pattern <pattern>] [--scope function|file|module]
  Refactor selected code

/optimize [--target speed|memory|both]
  Optimize code for performance

/document [--format jsdoc|markdown|inline]
  Add documentation to code

/comment [--verbose]
  Add inline comments

/pattern <pattern-name> [--example]
  Apply a design pattern

Testing Commands

/test [--watch] [--coverage] [--only <pattern>]
  Run test suite

/test-gen [--type unit|integration|e2e]
  Generate tests for current code

/coverage [--report html|json|terminal]
  Check test coverage

/mock <target> [--realistic]
  Generate mock data or functions

/test-watch [--on-save]
  Enable test watching

/snapshot [--update]
  Create test snapshots

Review Commands

/review [--scope current|file|changes] [--strict]
  Perform code review

/security [--deep] [--fix]
  Security analysis

/perf [--profile] [--suggestions]
  Performance analysis

/quality [--detailed]
  Check code quality metrics

/lint [--fix] [--config <config>]
  Run linters

/complexity [--threshold <value>]
  Analyze code complexity

/goto <file>[:line[:column]]
  Navigate to file or location

/find <pattern> [--regex] [--case-sensitive]
  Search in project

/recent [--limit <n>]
  Show recent files

/bookmark [add|list|goto|remove] [<name>]
  Manage bookmarks

/history [--limit <n>] [--filter <pattern>]
  Show command history

/tree [--depth <n>] [--filter <pattern>]
  Show project structure

Git Commands

/diff [--staged] [--file <file>]
  Show git diff

/commit [--message <msg>] [--amend]
  Commit with verification

/branch [create|switch|delete|list] [<name>]
  Branch operations

/stash [save|pop|list|apply] [<message>]
  Stash operations

/log [--oneline] [--limit <n>]
  View git log

/blame [<file>]
  Show git blame

AI Partner Commands

/agent [switch|info|config] [<agent-name>]
  Manage AI agent

/teach <preference>
  Teach the AI your preferences

/feedback [positive|negative] <message>
  Provide feedback to AI

/personality [professional|friendly|concise|verbose]
  Adjust AI personality

/expertise [add|remove|list] [<domain>]
  Set AI expertise focus

Metrics Commands

/metrics [--period today|session|week|all]
  Show session metrics

/score [--breakdown]
  Show quality scores

/productivity [--chart]
  Show productivity metrics

/leaderboard [--personal|team]
  Show improvement leaderboard

Role & Mode Commands

/switch [--immediate]
  Switch driver/navigator roles

/mode <type>
  Change mode (driver|navigator|switch|tdd|review|mentor|debug)

/role
  Show current role

/handoff
  Prepare role handoff

Command Shortcuts

Alias	Full Command
`/s`	`/suggest`
`/e`	`/explain`
`/t`	`/test`
`/r`	`/review`
`/c`	`/commit`
`/g`	`/goto`
`/f`	`/find`
`/h`	`/help`
`/sw`	`/switch`
`/st`	`/status`

Configuration

Basic Configuration

Create .claude-flow/pair-config.json:

json

{
  "pair": {
    "enabled": true,
    "defaultMode": "switch",
    "defaultAgent": "auto",
    "autoStart": false,
    "theme": "professional"
  }
}

Complete Configuration

json

{
  "pair": {
    "general": {
      "enabled": true,
      "defaultMode": "switch",
      "defaultAgent": "senior-dev",
      "language": "javascript",
      "timezone": "UTC"
    },

    "modes": {
      "driver": {
        "enabled": true,
        "suggestions": true,
        "realTimeReview": true,
        "autoComplete": false
      },
      "navigator": {
        "enabled": true,
        "codeGeneration": true,
        "explanations": true,
        "alternatives": true
      },
      "switch": {
        "enabled": true,
        "interval": "10m",
        "warning": "30s",
        "autoSwitch": true,
        "pauseOnIdle": true
      }
    },

    "verification": {
      "enabled": true,
      "threshold": 0.95,
      "autoRollback": true,
      "preCommitCheck": true,
      "continuousMonitoring": true,
      "blockOnFailure": true
    },

    "testing": {
      "enabled": true,
      "autoRun": true,
      "framework": "jest",
      "onSave": true,
      "coverage": {
        "enabled": true,
        "minimum": 80,
        "enforce": true,
        "reportFormat": "html"
      }
    },

    "review": {
      "enabled": true,
      "continuous": true,
      "preCommit": true,
      "security": true,
      "performance": true,
      "style": true,
      "complexity": {
        "maxComplexity": 10,
        "maxDepth": 4,
        "maxLines": 100
      }
    },

    "git": {
      "enabled": true,
      "autoCommit": false,
      "commitTemplate": "feat: {message}",
      "signCommits": false,
      "pushOnEnd": false,
      "branchProtection": true
    },

    "session": {
      "autoSave": true,
      "saveInterval": "5m",
      "maxDuration": "4h",
      "idleTimeout": "15m",
      "breakReminder": "45m",
      "metricsInterval": "1m"
    },

    "ai": {
      "model": "advanced",
      "temperature": 0.7,
      "maxTokens": 4000,
      "personality": "professional",
      "expertise": ["backend", "testing", "security"],
      "learningEnabled": true
    }
  }
}

Built-in Agents

json

{
  "agents": {
    "senior-dev": {
      "expertise": ["architecture", "patterns", "optimization"],
      "style": "thorough",
      "reviewLevel": "strict"
    },
    "tdd-specialist": {
      "expertise": ["testing", "mocks", "coverage"],
      "style": "test-first",
      "reviewLevel": "comprehensive"
    },
    "debugger-expert": {
      "expertise": ["debugging", "profiling", "tracing"],
      "style": "analytical",
      "reviewLevel": "focused"
    },
    "junior-dev": {
      "expertise": ["learning", "basics", "documentation"],
      "style": "questioning",
      "reviewLevel": "educational"
    }
  }
}

CLI Configuration

bash

# Set configuration
claude-flow pair config set defaultMode switch
claude-flow pair config set verification.threshold 0.98

# Get configuration
claude-flow pair config get
claude-flow pair config get defaultMode

# Export/Import
claude-flow pair config export > config.json
claude-flow pair config import config.json

# Reset
claude-flow pair config reset

Profile Management

Create reusable profiles:

bash

# Create profile
claude-flow pair profile create refactoring \
  --mode driver \
  --verify true \
  --threshold 0.98 \
  --focus refactor

# Use profile
claude-flow pair --start --profile refactoring

# List profiles
claude-flow pair profile list

Profile configuration:

json

{
  "profiles": {
    "refactoring": {
      "mode": "driver",
      "verification": {
        "enabled": true,
        "threshold": 0.98
      },
      "focus": "refactor"
    },
    "debugging": {
      "mode": "navigator",
      "agent": "debugger-expert",
      "trace": true,
      "verbose": true
    },
    "learning": {
      "mode": "mentor",
      "pace": "slow",
      "explanations": "detailed",
      "examples": true
    }
  }
}

Real-World Examples

Example 1: Feature Implementation

Implementing user authentication with JWT tokens:

bash

# Session setup
claude-flow pair --start \
  --mode switch \
  --agent senior-dev \
  --focus implement \
  --verify \
  --test

Session Flow:

👥 Starting pair programming for authentication feature...

[DRIVER: You - 10 minutes]
/explain JWT authentication flow
> AI explains JWT concepts and best practices

/suggest implementation approach
> AI suggests using middleware pattern with refresh tokens

# You write the basic auth middleware structure

[SWITCH TO NAVIGATOR]

[NAVIGATOR: AI - 10 minutes]
/implement JWT token generation with refresh tokens
> AI generates secure token implementation

/test-gen
> AI creates comprehensive test suite

[SWITCH TO DRIVER]

[DRIVER: You - 10 minutes]
# You refine the implementation
/review --security
> AI performs security review, suggests improvements

/commit --message "feat: JWT authentication with refresh tokens"
✅ Truth Score: 0.98 - Committed successfully

Example 2: Bug Fixing

Debugging a memory leak in Node.js:

bash

# Session setup
claude-flow pair --start \
  --mode navigator \
  --agent debugger-expert \
  --focus debug \
  --trace

Session Flow:

👥 Starting debugging session...

/status
> Analyzing application for memory issues...

/perf --profile
> Memory usage growing: 150MB → 450MB over 10 minutes

/find "new EventEmitter" --regex
> Found 3 instances of EventEmitter creation

/inspect eventEmitters --deep
> Discovering listeners not being removed

/suggest fix for memory leak
> AI suggests: "Add removeListener in cleanup functions"

/implement cleanup functions for all event emitters
> AI generates proper cleanup code

/test
> Memory stable at 150MB ✅

/commit --message "fix: memory leak in event emitters"

Example 3: TDD Session

Building shopping cart with test-driven development:

bash

# Session setup
claude-flow pair --start \
  --mode tdd \
  --agent tdd-specialist \
  --test-first

Session Flow:

👥 TDD Session: Shopping Cart Feature

[RED PHASE]
/test-gen "add item to cart"
> AI writes failing test:
  ✗ should add item to cart
  ✗ should update quantity for existing item
  ✗ should calculate total price

[GREEN PHASE]
/implement minimal cart functionality
> You write just enough code to pass tests

/test
> Tests passing: 3/3 ✅

[REFACTOR PHASE]
/refactor --pattern repository
> AI refactors to repository pattern

/test
> Tests still passing: 3/3 ✅

[NEXT CYCLE]
/test-gen "remove item from cart"
> AI writes new failing tests...

Example 4: Code Refactoring

Modernizing legacy code:

bash

# Session setup
claude-flow pair --start \
  --mode driver \
  --focus refactor \
  --verify \
  --threshold 0.98

Session Flow:

👥 Refactoring Session: Modernizing UserService

/analyze UserService.js
> AI identifies:
  - Callback hell (5 levels deep)
  - No error handling
  - Tight coupling
  - No tests

/suggest refactoring plan
> AI suggests:
  1. Convert callbacks to async/await
  2. Add error boundaries
  3. Extract dependencies
  4. Add unit tests

/test-gen --before-refactor
> AI generates tests for current behavior

/refactor callbacks to async/await
# You refactor with AI guidance

/test
> All tests passing ✅

/review --compare
> AI shows before/after comparison
> Code complexity: 35 → 12
> Truth score: 0.99 ✅

/commit --message "refactor: modernize UserService with async/await"

Example 5: Performance Optimization

Optimizing slow React application:

bash

# Session setup
claude-flow pair --start \
  --mode switch \
  --agent performance-expert \
  --focus optimize \
  --profile

Session Flow:

👥 Performance Optimization Session

/perf --profile
> React DevTools Profiler Results:
  - ProductList: 450ms render
  - CartSummary: 200ms render
  - Unnecessary re-renders: 15

/suggest optimizations for ProductList
> AI suggests:
  1. Add React.memo
  2. Use useMemo for expensive calculations
  3. Implement virtualization for long lists

/implement React.memo and useMemo
# You implement with AI guidance

/perf --profile
> ProductList: 45ms render (90% improvement!) ✅

/implement virtualization with react-window
> AI implements virtual scrolling

/perf --profile
> ProductList: 12ms render (97% improvement!) ✅
> FPS: 60 stable ✅

/commit --message "perf: optimize ProductList with memoization and virtualization"

Show full SKILL.md (314 more words)Show less

Example 6: API Development

Building RESTful API with Express:

bash

# Session setup
claude-flow pair --start \
  --mode navigator \
  --agent backend-expert \
  --focus implement \
  --test

Session Flow:

👥 API Development Session

/design REST API for blog platform
> AI designs endpoints:
  POST   /api/posts
  GET    /api/posts
  GET    /api/posts/:id
  PUT    /api/posts/:id
  DELETE /api/posts/:id

/implement CRUD endpoints with validation
> AI implements with Express + Joi validation

/test-gen --integration
> AI generates integration tests

/security --api
> AI adds:
  - Rate limiting
  - Input sanitization
  - JWT authentication
  - CORS configuration

/document --openapi
> AI generates OpenAPI documentation

/test --integration
> All endpoints tested: 15/15 ✅

Session Templates

Quick Start Templates

bash

# Refactoring template
claude-flow pair --template refactor
# Focus: Code improvement
# Verification: High (0.98)
# Testing: After each change
# Review: Continuous

# Feature template
claude-flow pair --template feature
# Focus: Implementation
# Verification: Standard (0.95)
# Testing: On completion
# Review: Pre-commit

# Debug template
claude-flow pair --template debug
# Focus: Problem solving
# Verification: Moderate (0.90)
# Testing: Regression tests
# Review: Root cause

# Learning template
claude-flow pair --template learn
# Mode: Mentor
# Pace: Slow
# Explanations: Detailed
# Examples: Many

Session Management

Session Status

bash

claude-flow pair --status

Output:

👥 Pair Programming Session
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Session ID: pair_1755021234567
Duration: 45 minutes
Status: Active

Partner: senior-dev
Current Role: DRIVER (you)
Mode: Switch (10m intervals)
Next Switch: in 3 minutes

📊 Metrics:
├── Truth Score: 0.982 ✅
├── Lines Changed: 234
├── Files Modified: 5
├── Tests Added: 12
├── Coverage: 87% ↑3%
└── Commits: 3

🎯 Focus: Implementation
📝 Current File: src/auth/login.js

Session History

bash

claude-flow pair --history

Output:

📚 Session History
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. 2024-01-15 14:30 - 16:45 (2h 15m)
   Partner: expert-coder
   Focus: Refactoring
   Truth Score: 0.975
   Changes: +340 -125 lines

2. 2024-01-14 10:00 - 11:30 (1h 30m)
   Partner: tdd-specialist
   Focus: Testing
   Truth Score: 0.991
   Tests Added: 24

3. 2024-01-13 15:00 - 17:00 (2h)
   Partner: debugger-expert
   Focus: Bug Fixing
   Truth Score: 0.968
   Issues Fixed: 5

Session Persistence

bash

# Save session
claude-flow pair --save [--name <name>]

# Load session
claude-flow pair --load <session-id>

# Export session
claude-flow pair --export <session-id> [--format json|md]

# Generate report
claude-flow pair --report <session-id>

Background Sessions

bash

# Start in background
claude-flow pair --start --background

# Monitor background session
claude-flow pair --monitor

# Attach to background session
claude-flow pair --attach <session-id>

# End background session
claude-flow pair --end <session-id>

Advanced Features

Custom Commands

Define in configuration:

json

{
  "customCommands": {
    "tdd": "/test-gen && /test --watch",
    "full-review": "/lint --fix && /test && /review --strict",
    "quick-fix": "/suggest --type fix && /implement && /test"
  }
}

Use custom commands:

/custom tdd
/custom full-review

Command Chaining

/test && /commit && /push
/lint --fix && /test && /review --strict

Session Recording

bash

# Start with recording
claude-flow pair --start --record

# Replay session
claude-flow pair --replay <session-id>

# Session analytics
claude-flow pair --analytics <session-id>

Integration Options

With Git:

bash

claude-flow pair --start --git --auto-commit

With CI/CD:

bash

claude-flow pair --start --ci --non-interactive

With IDE:

bash

claude-flow pair --start --ide vscode

Best Practices

Session Practices

Clear Goals - Define session objectives upfront
Appropriate Mode - Choose based on task type
Enable Verification - For critical code paths
Regular Testing - Maintain quality continuously
Session Notes - Document important decisions
Regular Breaks - Take breaks every 45-60 minutes

Code Practices

Test Early - Run tests after each change
Verify Before Commit - Check truth scores
Review Security - Always for sensitive code
Profile Performance - Use /perf for optimization
Save Sessions - For complex work
Learn from AI - Ask questions frequently

Mode Selection

Driver Mode: When learning, controlling implementation
Navigator Mode: For rapid prototyping, generation
Switch Mode: Long sessions, balanced collaboration
TDD Mode: Building with tests
Review Mode: Quality focus
Mentor Mode: Learning priority
Debug Mode: Fixing issues

Troubleshooting

Session Won't Start

Check agent availability
Verify configuration file syntax
Ensure clean workspace
Review log files

Session Disconnected

Use --recover to restore
Check network connection
Verify background processes
Review auto-save files

Poor Performance

Reduce verification threshold
Disable continuous testing
Check system resources
Use lighter AI model

Configuration Issues

Validate JSON syntax
Check file permissions
Review priority order (CLI > env > project > user > global)
Run claude-flow pair config validate

Quality Metrics

Truth Score Thresholds

Error:   < 0.90 ❌
Warning: 0.90 - 0.95 ⚠️
Good:    0.95 - 0.98 ✅
Excellent: > 0.98 🌟

Coverage Thresholds

Error:   < 70% ❌
Warning: 70% - 80% ⚠️
Good:    80% - 90% ✅
Excellent: > 90% 🌟

Complexity Thresholds

Error:   > 15 ❌
Warning: 10 - 15 ⚠️
Good:    5 - 10 ✅
Excellent: < 5 🌟

Environment Variables

Override configuration via environment:

bash

export CLAUDE_PAIR_MODE=driver
export CLAUDE_PAIR_VERIFY=true
export CLAUDE_PAIR_THRESHOLD=0.98
export CLAUDE_PAIR_AGENT=senior-dev
export CLAUDE_PAIR_AUTO_TEST=true

Command History

Navigate history:

↑/↓ - Navigate through command history
Ctrl+R - Search command history
!! - Repeat last command
!<n> - Run command n from history

Keyboard Shortcuts (Configurable)

Default shortcuts:

json

{
  "shortcuts": {
    "switch": "ctrl+shift+s",
    "suggest": "ctrl+space",
    "review": "ctrl+r",
    "test": "ctrl+t"
  }
}

claude-flow pair --help - Show help
claude-flow pair config - Manage configuration
claude-flow pair profile - Manage profiles
claude-flow pair templates - List templates
claude-flow pair agents - List available agents

Files

Just SKILL.md in .kiro/skills/qe-pair-programming of proffesor-for-testing/agentic-qe.

Open the folder on GitHubat commit 829d030

Used in 10 other repositories

We found 25 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 6 other GitHub owners. This page covers the copy in proffesor-for-testing/agentic-qe, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Qe Pair Programming next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Qe Pair Programming compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Qe Pair Programming this skillproffesor-for-testing/agentic-qe	494	6 repos	~6k	Automated safety check: Pass	MIT	3 days ago
Happier Implementhappier-dev/happier	1.9k	—	~4.2k	Automated safety check: Pass	MIT	today
Refactortestdouble/han	279	—	~3.1k	Automated safety check: Pass	MIT	6 days ago
Devnpc-live/clawfirm	156	—	~642	Automated safety check: Pass	None	3 mo ago
Code Review ChecklistshareAI-lab/learn-claude-code	78k	5 repos	~1.1k	Automated safety check: Pass	MIT	9 days ago
Dignified Python Standardsdocling-project/docling	68k	—	~1.5k	Automated safety check: Pass	Apache-2.0	yesterday

Similar skills

Happier Implement
happier-dev/happier
Implement, change, build, fix, refactor, migrate, or apply accepted review findings in the Happier repositories with canonical-owner discovery, scope-preserving solution economy, TDD, efficient…
1.9k GitHub stars~4.2k tokensUpdated today
DevelopmentAuto-check passed
Refactor
testdouble/han
Restructure existing code without changing its behavior, through a test-gated refactoring loop: a named target, a green suite over that target before any edit, a planned sequence of small named…
279 GitHub stars~3.1k tokensUpdated 6 days ago
DevelopmentAuto-check passed
Dev
npc-live/clawfirm
Software development workflow dispatcher. An agent skill from npc-live/clawfirm.
156 GitHub stars~642 tokensUpdated 3 mo ago
DevelopmentAuto-check passed
Code Review Checklist
shareAI-lab/learn-claude-code
Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.
78k GitHub starsUsed in 5 repos~1.1k tokens
DevelopmentAuto-check passed
Dignified Python Standards
docling-project/docling
Applies opinionated production Python conventions chosen by the project's Python version: modern type syntax, pathlib, explicit checks and interface guidance.
68k GitHub stars~1.5k tokensUpdated yesterday
DevelopmentAuto-check passed
Clean Code Guard
amElnagdy/guard-skills
Reviews generated or changed production code against Clean Code, SOLID, DRY, KISS, YAGNI and LLM-specific failure modes before it ships, in any language.
1.3k GitHub starsUsed in 2 repos~4.3k tokens
DevelopmentAuto-check passed

Questions about Qe Pair Programming

What does Qe Pair Programming do?

AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, quality monitoring, and comprehensive testing. Qe Pair Programming is an agent skill from proffesor-for-testing/agentic-qe. AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, quality monitoring, and comprehensive testing.

When should I use Qe Pair Programming?

Qe Pair Programming fits situations like: tasks that involve Test-driven development; tasks that involve Refactoring; tasks that involve Performance optimization.

How do I install Qe Pair Programming in Claude Code?

Run `npx skills add proffesor-for-testing/agentic-qe --skill qe-pair-programming -a claude-code`. Or copy the skill folder (.kiro/skills/qe-pair-programming in proffesor-for-testing/agentic-qe) into .claude/skills/qe-pair-programming in your project. Claude Code loads it when a task matches its description.

How do I install Qe Pair Programming in Codex?

Run `npx skills add proffesor-for-testing/agentic-qe --skill qe-pair-programming -a codex`. Or copy the skill folder (.kiro/skills/qe-pair-programming in proffesor-for-testing/agentic-qe) into .agents/skills/qe-pair-programming in your project. Codex loads it when a task matches its description.

Can I use Qe Pair Programming in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add proffesor-for-testing/agentic-qe --skill qe-pair-programming -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/qe-pair-programming, .gemini/skills/qe-pair-programming, .github/skills/qe-pair-programming and .opencode/skills/qe-pair-programming in your project.

What does Qe Pair Programming need to run?

Going by SKILL.md and its folder, Qe Pair Programming needs the command-line tools its instructions call (npm). Our summary lists: Node.js.

Does Qe Pair Programming access the network?

SKILL.md contains no URLs. Its commands use npm, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Qe Pair Programming safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Qe Pair Programming use?

Qe Pair Programming is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Qe Pair Programming use?

About 6k tokens (SKILL.md is roughly 24k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Qe Pair Programming?

Skills that share tags, products or a category with Qe Pair Programming: Happier Implement (happier-dev/happier, 1.9k stars), Refactor (testdouble/han, 279 stars), Dev (npc-live/clawfirm, 156 stars) and Code Review Checklist (shareAI-lab/learn-claude-code, 78k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Qe Pair Programming?

proffesor-for-testing (a GitHub user) maintains it in proffesor-for-testing/agentic-qe, which has 494 GitHub stars. The repository holds 111 skills in this directory. The repository was last updated on October 4, 2026.

Source: proffesor-for-testing/agentic-qe on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Qe Pair Programming

Facts

At a glance

What it does

When your agent uses it

Example prompts

Requirements

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

Pair Programming

What This Skill Does

Prerequisites

Quick Start

Basic Session

TDD Session

Complete Guide

Session Control Commands

Starting Sessions

Session Management

Available Modes

Driver Mode

Navigator Mode

Switch Mode

Specialized Modes

In-Session Commands

Code Commands

Testing Commands

Review Commands

Navigation Commands

Git Commands

AI Partner Commands

Metrics Commands

Role & Mode Commands

Command Shortcuts

Configuration

Basic Configuration

Complete Configuration

Built-in Agents

CLI Configuration

Profile Management

Real-World Examples

Example 1: Feature Implementation

Example 2: Bug Fixing

Example 3: TDD Session

Example 4: Code Refactoring

Example 5: Performance Optimization

Example 6: API Development

Session Templates

Quick Start Templates

Session Management

Session Status

Session History

Session Persistence

Background Sessions

Advanced Features

Custom Commands

Command Chaining

Session Recording

Integration Options

Best Practices

Session Practices

Code Practices

Mode Selection

Troubleshooting

Session Won't Start

Session Disconnected

Poor Performance

Configuration Issues

Quality Metrics

Truth Score Thresholds

Coverage Thresholds

Complexity Thresholds

Environment Variables