Skip to content
Skills Library
Programming · Building & coding

refactoring

/refactoring

Improve code quality and maintainability through systematic identification of code smells and application of proven refactoring patterns. Use when the user requests refactoring or provides relevant inputs for this workflow.

Author
seb1n ↗
Licence
MIT
Last repository change
09.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 09.08.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Improve code quality and maintainability through systematic identification of code smells and application of proven refactoring patterns. Use when the user requests refactoring or provides relevant inputs for this workflow.

Original author description

Improve code quality and maintainability through systematic identification of code smells and application of proven refactoring patterns. Use when the user requests refactoring or provides relevant inputs for this workflow.

How it works

  1. Workflow
  2. Supported Languages
  3. Usage
  4. Examples
  5. Best Practices
  6. Edge Cases
Original SKILL.md headings · 169 lines, 1,040 words
SKILL.md preview
---
name: refactoring
description: "Improve code quality and maintainability through systematic identification of code smells and application of proven refactoring patterns. Use when the user requests refactoring or provides relevant inputs for this workflow."
license: "MIT"
metadata:
  author: "awesome-ai-agent-skills contributors"
  version: "1.1.0"
---

# Code Refactoring

This skill guides an AI agent through the disciplined process of restructuring existing code without changing its external behavior. Refactoring improves readability, reduces complexity, and makes the codebase easier to extend and maintain. The agent identifies code smells, proposes targeted refactoring patterns, applies transformations safely, and verifies correctness through tests.

## Workflow

1. **Identify Code Smells**: Scan the target code for common quality issues — long functions, deeply nested conditionals, duplicated logic, overly broad variable scoping, magic numbers, dead code, and large parameter lists. Flag each smell with its location and a brief explanation of why it harms the codebase.

2. **Select Refactoring Patterns**: For every identified smell, choose the most appropriate refactoring pattern. Common patterns include Extract Method, Rename Symbol, Simplify Conditional, Inline Variable, Replace Magic Number with Named Constant, Remove Dead Code, and Introduce Parameter Object. Explain the trade-offs and expected improvement for each proposed change.

3. **Plan the Change Order**: Determine a safe sequence for applying refactorings. Prefer small, independent changes that can each be verified in isolation. Group related changes (e.g., extracting a helper then renaming it) and avoid interleaving unrelated transformations that make rollback difficult.

4. **Apply Refactorings**: Transform the code one pattern at a time. Preserve the original public API and behavior. Use language-idiomatic constructs — list comprehensions in Python, destructuring in JavaScript, pattern matching in Rust, etc.

5. **Run Tests and Verify**: Execute the existing test suite after each transformation. If no tests exist, generate lightweight unit tests covering the refactored paths before and after the change. Confirm that all tests pass and that no regressions have been introduced.

6. **Document Changes**: Summarize each refactoring applied, the smell it addressed, and any follow-up improvements that are now possible. This summary serves as a commit message or PR description.

## Supported Languages

- Python
- JavaScript / TypeScript
- Java
- Go
- Rust
- C / C++
- Ruby

## Usage

Provide the code you want refactored along with an optional goal such as "reduce complexity," "improve naming," or "break this into smaller functions." The agent will analyze the code, present a refactoring plan, and apply the changes upon approval. You can also point the agent at an entire file or module and ask it to perform a general quality pass.

## Examples

### Example 1 — Extract Method and Simplify Conditionals (Python)

**User Request**: "This function is too long and the nested ifs are hard to follow. Refactor it."

**Before**:
```python
def register_user(payload):
    if payload.get("email"):
        if "@" in payload["email"]:
            if payload.get("password") and len(payload["password"]) >= 8:
                user = {"email": payload["email"], "active": True}
                db.save(user)
                send_welcome_email(user["email"])
                log.info(f"User {user['email']} registered")
                return user
            else:
                raise ValueError("Password must be at least 8 characters")
        else:
            raise ValueError("Invalid email format")
    else:
        raise ValueError("Email is required")
```

**After**:
```python
def register_user(payload):
    _validate_payload(payload)
    user = _create_user(payload["email"])
    _notify_and_log(user)
    return user

def _validate_payload(payload):
    if not payload.get("email"):
        raise ValueError("Email is required")
    if "@" not in payload["email"]:
        raise ValueError("Invalid email format")
    if not payload.get("password") or len(payload["password"]) < 8:
        raise ValueError("Password must be at least 8 characters")

def _create_user(email):
    user = {"email": email, "active": True}
    db.save(user)
    return user

def _notify_and_log(user):
    send_welcome_email(user["email"])
    log.info(f"User {user['email']} registered")
```

**Patterns applied**: Extract Method, Flatten Nested Conditionals (guard clauses).

### Example 2 — Remove Duplication and Introduce Constants (TypeScript)

**User Request**: "Clean up this Express route handler. There's a lot of repetition."

**Before**:
```typescript
app.post("/orders", async (req, res) => {
  if (!req.body.items || req.body.items.length === 0) {
    return res.status(400).json({ error: "Items are required" });
  }
  if (req.body.items.length > 50) {
    return res.status(400).json({ error: "Too many items" });
  }
  let total = 0;
  for (const item of req.body.items) {
    total += item.price * item.quantity;
  }
  if (total > 10000) {
    return res.status(400).json({ error: "Order exceeds maximum total" });
  }
  const order = { items: req.body.items, total: total, status: "pending" };
  await db.orders.insert(order);
  return res.status(201).json(order);
});
```

**After**:
```typescript
const MAX_ITEMS = 50;
const MAX_ORDER_TOTAL = 10_000;

app.post("/orders", async (req, res) => {
  const { items } = req.body;
  const validationError = validateOrder(items);
  if (validationError) {
    return res.status(400).json({ error: validationError });
  }

  const total = calculateTotal(items);
  if (total > MAX_ORDER_TOTAL) {
    return res.status(400).json({ error: "Order exceeds maximum total" });
  }

  const order = await createOrder(items, total);
  return res.status(201).json(order);
});

function validateOrder(items?: OrderItem[]): string | null {
  if (!items || items.length === 0) return "Items are required";
  if (items.length > MAX_ITEMS) return "Too many items";
  return null;
}

function calculateTotal(items: OrderItem[]): number {
  return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
}

async function createOrder(items: OrderItem[], total: number) {
  const order = { items, total, status: "pending" as const };
  await db.orders.insert(order);
  return order;
}
```

**Patterns applied**: Extract Method, Replace Magic Number with Named Constant, Destructuring.

## Best Practices

- **Keep refactorings small and atomic.** Each change should be independently verifiable and easy to revert if something breaks.
- **Never refactor and add features at the same time.** Mixing behavior changes with structural changes makes bugs nearly impossible to trace.
- **Preserve the public API.** Internal restructuring should not force callers to change unless the user explicitly requests an API redesign.
- **Lean on the test suite.** If test coverage is low, write characterization tests that capture current behavior before refactoring.
- **Use guard clauses to flatten deeply nested conditionals.** Early returns improve readability far more than adding comments to nested branches.
- **Rename aggressively.** Clear names eliminate the need for comments. A function called `validate_email` is better than `check` with a comment explaining what it checks.

## Edge Cases

- **No existing tests**: Generate minimal tests that capture current input/output behavior before applying any transformations. Warn the user that confidence in correctness depends on test coverage.
- **Tightly coupled modules**: When refactoring one module would break imports or contracts in another, map the dependency graph first and propose an interface boundary before extracting logic.
- **Generated or vendored code**: Do not refactor auto-generated files (e.g., protobuf stubs, ORM migrations). Flag them and skip.
- **Performance-critical hot paths**: Some "ugly" code is intentionally optimized. Verify with the user before replacing hand-tuned loops with higher-level abstractions that may regress performance.
- **Mixed formatting styles**: If the file has inconsistent style (tabs vs. spaces, quote styles), run the project's formatter after refactoring rather than manually fixing style during the refactoring pass.

Versions

RepositoryScoreLicence
This page · seb1n/awesome-ai-agent-skills100MIT
gabrieldulolmarques/refactoring-skill100CC-BY-4.0
4typen/skills100MIT
t8jwscc7qy-sketch/foma-skills100Apache-2.0
mtwuser/zero-cloud-gravity100MIT
krzysztofsurdy/code-virtuoso100MIT
sagargupta16/claude-skills100MIT
nimadorostkar/Claude-Skills-collection100MIT
DariuszDusza/agentic-workflow-foundry100Apache-2.0

Database snapshot: 13.11.2026 · package version 19e76c2e96eb (SHA-256 digest of the entire package)

Downloads in the last 30 days: 2 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100refactoring-specialist
    Code refactoring expert for improving code structure, readability, and maintainability. Use when user asks to refactor, clean up, or improve code quality.
  • 100refactoring-advisor
    Analyze code for structural issues and code smells, then recommend prioritized refactoring patterns with before/after examples. Use when the user asks to refactor, clean up, or improve code structure, when a module has grown hard to change or test, or when a review surfaces maintainability problems.
  • 90clade-code-quality
    Code quality, error handling, shell safety, language, and maintainability rules. Use when implementing or refactoring code, scripts, or language-specific components.
  • 100python-refactoring
    Python refactoring catalog with 83 patterns covering immutability, class design, control flow, architecture, OO metrics, and Python idioms. Analyze code for smells and apply numbered refactoring patterns with before/after examples. Use when the user invokes /refactor or…
  • 93code-quality
    two-stage review (spec compliance first, then code quality), refactoring, and quality improvement. Use when reviewing code, eliminating code smells, reducing technical debt, refactoring methods, running self-critique loops, or improving maintainability and readability.
  • 100review
    Review code quality, security, and maintainability before committing. Use when reviewing code changes, checking code quality, performing security review, or validating changes before commit.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.