refactoring-patterns · proffesor-for-testing — Claude Code skill: what it does, how to install
Skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode that applies refactoring patterns. Runs when you need to improve code structure without changing behavior.
MIT 140 installs ★ 533 updated 2026-10-25
npx skills add proffesor-for-testing/agentic-qe --skill refactoring-patterns -a claude-codeWhat refactoring-patterns does
The skill works in cycles: run tests, make one change, run tests again, commit. Built-in code smell table — long method over 20 lines, large class, duplication — maps each smell to a pattern: Extract Method, Extract Class, Replace Loop with Pipeline. For example, nested loops become .filter().map().reduce(), a conditional with more than three clauses becomes a named function. The skill integrates with sub-agents qe-quality-analyzer, qe-test-generator and qe-test-executor: the first detects smells in src/services/, the second adds tests, the third verifies behavior stays unchanged.
Built-in rule of three: first time — write code, second time — tolerate duplication, third time — refactor. Licensed under MIT. Refactoring without tests is forbidden: the skill refuses if npm test fails.
To install in Claude Code, run two commands — npx skills add proffesor-for-testing/agentic-qe --skill refactoring-patterns -a claude-code, the file goes into ~/.claude/skills/refactoring-patterns/SKILL.md. In Cursor — same command with -a cursor flag, file in .cursor/skills/. In GitHub Copilot — gh skill install proffesor-for-testing/agentic-qe refactoring-patterns.
What it helps with
- split a 50-line function into five short methods
- replace six function arguments with a parameter object
- remove code duplication across three places with Extract Method
- rewrite nested loops as a pipeline with
filterandmap - extract magic numbers into named constants
Example prompts for the agent
- Find code smells in
src/services/and suggest refactorings - Break down the
processOrdermethod into several single-responsibility functions - Replace the conditional
if (order.total > 1000 && customer.isPremium)with a named function
How to install refactoring-patterns
1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill refactoring-patterns -a claude-code2Manually: put the files in place
~/.claude/skills/refactoring-patterns/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/refactoring-patterns/
1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill refactoring-patterns -a codex2Manually: put the files in place
.agents/skills/refactoring-patterns/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill refactoring-patterns -a cursor2Manually: put the files in place
.cursor/skills/refactoring-patterns/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install proffesor-for-testing/agentic-qe assets/skills/refactoring-patterns2Manually: put the files in place
.github/skills/refactoring-patterns/SKILL.md1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill refactoring-patterns -a gemini-cli2Platform CLI
gemini skills install https://github.com/proffesor-for-testing/agentic-qe --path assets/skills/refactoring-patternsManually: put the files in place
.devin/skills/refactoring-patterns/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill refactoring-patterns -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 refactoring-patterns
How to install refactoring-patterns in Claude Code?
Run npx skills add proffesor-for-testing/agentic-qe --skill refactoring-patterns -a claude-code, the skill file will appear in ~/.claude/skills/refactoring-patterns/SKILL.md.
What does the refactoring-patterns skill do?
Applies refactoring patterns — Extract Method, Replace Loop with Pipeline, Decompose Conditional — in a cycle: tests, change, tests again, commit. Works with sub-agents to detect code smells and verify behavior stays the same.
Can I refactor without tests using this skill?
No. The skill requires npm test to pass before refactoring and after every change. Without green tests, refactoring will not start — this is part of the built-in safety cycle.
Source text
SKILL.md · MIT
---
name: refactoring-patterns
description: "Apply safe refactoring patterns to improve code structure without changing behavior. Use when cleaning up code, reducing technical debt, or improving maintainability."
category: development-practices
priority: medium
tokenEstimate: 1000
agents: [qe-code-reviewer, qe-quality-analyzer, qe-test-refactorer]
implementation_status: optimized
optimization_version: 1.0
last_optimized: 2025-12-03
dependencies: []
quick_reference_card: true
tags: [refactoring, code-quality, technical-debt, maintainability, clean-code]
trust_tier: 2
validation:
schema_path: schemas/output.json
validator_path: scripts/validate-config.json
---
# Refactoring Patterns
<default_to_action>
When refactoring:
1. ENSURE tests pass (never refactor without tests)
2. MAKE small change (one refactoring at a time)
3. RUN tests (must stay green)
4. COMMIT (save progress)
5. REPEAT
**Safe Refactoring Cycle:**
```bash
npm test # Green ✅
# Make ONE small change
npm test # Still green ✅
git commit -m "refactor: extract calculateTotal"
# Repeat
```
**Code Smells → Refactoring:**
| Smell | Refactoring |
|-------|-------------|
| Long method (>20 lines) | Extract Method |
| Large class | Extract Class |
| Long parameter list (>3) | Introduce Parameter Object |
| Duplicated code | Extract Method/Class |
| Complex conditional | Decompose Conditional |
| Magic numbers | Named Constants |
| Nested loops | Replace Loop with Pipeline |
**NEVER REFACTOR:**
- Without tests (write tests first)
- When deadline is tomorrow
- Code you don't understand
- Code that works and won't be touched
</default_to_action>
## Quick Reference Card
### Common Refactorings
| Pattern | Before | After |
|---------|--------|-------|
| **Extract Method** | 50-line function | 5 small functions |
| **Extract Class** | Class doing 5 things | 5 single-purpose classes |
| **Parameter Object** | `fn(a,b,c,d,e,f)` | `fn(options)` |
| **Replace Conditional** | `if (type === 'a') {...}` | Polymorphism |
| **Pipeline** | Nested loops | `.filter().map().reduce()` |
### The Rule of Three
1. First time → Just do it
2. Second time → Wince and duplicate
3. Third time → **Refactor**
---
## Key Patterns
### Extract Method
```javascript
// Before: Long method
function processOrder(order) {
// 50 lines of validation, calculation, saving, emailing...
}
// After: Clear responsibilities
function processOrder(order) {
validateOrder(order);
const pricing = calculatePricing(order);
const saved = saveOrder(order, pricing);
sendConfirmationEmail(saved);
return saved;
}
```
### Replace Loop with Pipeline
```javascript
// Before
let results = [];
for (let item of items) {
if (item.inStock) {
results.push(item.name.toUpperCase());
}
}
// After
const results = items
.filter(item => item.inStock)
.map(item => item.name.toUpperCase());
```
### Decompose Conditional
```javascript
// Before
if (order.total > 1000 && customer.isPremium && allInStock(order)) {
return 'FREE_SHIPPING';
}
// After
function isEligibleForFreeShipping(order, customer) {
return isLargeOrder(order) &&
isPremiumCustomer(customer) &&
allInStock(order);
}
```
---
## Refactoring Anti-Patterns
| ❌ Anti-Pattern | Problem | ✅ Better |
|-----------------|---------|-----------|
| Without tests | No safety net | Write tests first |
| Big bang | Rewrite everything | Small incremental steps |
| For perfection | Endless tweaking | Good enough, move on |
| Premature abstraction | Pattern not clear yet | Wait for Rule of Three |
| During feature work | Mixed changes | Separate commits |
---
## Agent Integration
```typescript
// Detect code smells
const smells = await Task("Detect Code Smells", {
source: 'src/services/',
patterns: ['long-method', 'large-class', 'duplicate-code']
}, "qe-quality-analyzer");
// Safe refactoring with test verification
await Task("Verify Refactoring", {
beforeCommit: 'abc123',
afterCommit: 'def456',
expectSameBehavior: true
}, "qe-test-executor");
```
---
## Agent Coordination Hints
### Memory Namespace
```
aqe/refactoring/
├── smells/* - Detected code smells
├── suggestions/* - Refactoring recommendations
├── verifications/* - Behavior preservation checks
└── history/* - Refactoring log
```
### Fleet Coordination
```typescript
const refactoringFleet = await FleetManager.coordinate({
strategy: 'refactoring',
agents: [
'qe-quality-analyzer', // Identify targets
'qe-test-generator', // Add safety tests
'qe-test-executor', // Verify behavior
'qe-test-refactorer' // TDD refactor phase
],
topology: 'sequential'
});
```
---
## Related Skills
- [tdd-london-chicago](../tdd-london-chicago/) - TDD refactor phase
- [code-review-quality](../code-review-quality/) - Review refactored code
- [xp-practices](../xp-practices/) - Collective ownership
---
## Remember
**Refactoring is NOT:**
- Adding features
- Fixing bugs
- Performance optimization
- Rewriting from scratch
**Refactoring IS:**
- Improving structure
- Making code clearer
- Reducing complexity
- Removing duplication
- **Without changing behavior**
**Always have tests. Always take small steps. Always keep tests green.**
© proffesor-for-testing · MIT · proffesor-for-testing/agentic-qe
Similar skills
All skills for Code review and refactoring →refactoring-patterns by other authors comes first.