Habilidades tdd-workflows-tdd-refactor
🔧

tdd-workflows-tdd-refactor

Seguro ⚙️ Comandos externos

Refactor Code Safely with TDD

Maintain code quality while refactoring without breaking existing functionality. This skill provides comprehensive TDD workflows to guide safe code transformations.

Suporta: Claude Codex Code(CC)
🥉 74 Bronze
1

Baixar o ZIP da skill

2

Upload no Claude

Vá em Configurações → Capacidades → Skills → Upload skill

3

Ative e comece a usar

Testar

A utilizar "tdd-workflows-tdd-refactor". Refactor this OrderProcessor class while keeping tests green

Resultado esperado:

Applied Extract Method, Value Objects, and Dependency Injection patterns. All tests passing. Created separate validation service, introduced OrderTotal value object, and injected dependencies. Code coverage maintained at 95%.

A utilizar "tdd-workflows-tdd-refactor". Eliminate code smells in this 200-line function

Resultado esperado:

Decomposed into 8 focused methods using Extract Method pattern. Applied Single Responsibility Principle. Introduced Parameter Objects for complex method signatures. All 42 tests still passing. Cyclomatic complexity reduced from 45 to 8.

Auditoria de Segurança

Seguro
v1 • 2/25/2026

Static analysis detected 9 potential issues (external commands, weak crypto, reconnaissance patterns). All findings are FALSE POSITIVES - they occur in code documentation examples and markdown backticks, not executable code. No prompt injection attempts or malicious intent detected. This is a legitimate TDD refactoring skill.

1
Arquivos analisados
190
Linhas analisadas
2
achados
1
Total de auditorias
Problemas de Baixo Risco (1)
SKILL.md:23SKILL.md:139-159SKILL.md:159-162SKILL.md:162-185
External Commands in Documentation
Ruby/shell backtick patterns detected at lines 23, 139, 159, 162. These are FALSE POSITIVES - the backticks contain code examples in TypeScript/JavaScript within markdown code blocks, not executable Ruby shell commands. The skill file is documentation-only with no executable code.

Fatores de risco

⚙️ Comandos externos (4)
SKILL.md:23 SKILL.md:139-159 SKILL.md:159-162 SKILL.md:162-185
Auditado por: claude

Pontuação de qualidade

38
Arquitetura
95
Manutenibilidade
87
Conteúdo
50
Comunidade
100
Segurança
100
Conformidade com especificações

O Que Você Pode Construir

Legacy Code Modernization

Refactor legacy codebases incrementally while maintaining functionality

Code Quality Improvement

Eliminate code smells and apply design patterns systematically

Test-Supported Architecture Evolution

Evolve architecture patterns safely using comprehensive test coverage

Tente Estes Prompts

Basic Refactoring Request 
Refactor this code while keeping all tests green. Focus on eliminating code smells and improving readability.
Pattern Application 
Apply the Extract Method pattern to this code. Break down the long method into smaller, focused functions while maintaining all tests green.
Comprehensive Refactoring 
Refactor this code using TDD refactor phase: establish green baseline, detect code smells, apply appropriate design patterns, verify with full test suite, and provide before/after metrics.
Architecture Evolution 
Refactor this code to improve architecture using the Strangler Fig pattern. Gradually replace legacy components while maintaining test safety and provide incremental migration plan.

Melhores Práticas

  • Always run tests before refactoring to establish a green baseline
  • Make small, incremental changes and run tests after each modification
  • Commit after each successful refactoring to enable easy rollback
  • Separate refactoring changes from behavior changes completely

Evitar

  • Refactoring without test coverage - leads to undetected regressions
  • Making large-scale changes without intermediate test runs - high risk of breaking functionality
  • Mixing refactoring with feature additions - violates Single Responsibility Principle
  • Skipping rollback planning - makes recovery difficult when tests fail

Perguntas Frequentes

Do I need existing tests to use this skill?
Yes, this skill requires existing test coverage to refactor safely. Without tests, refactoring risks breaking existing functionality. Consider writing characterization tests first for legacy code.
How large should refactoring changes be?
Keep changes small and incremental. Run tests after each modification. Typical refactoring steps should change 5-20 lines of code and be immediately verifiable with your test suite.
Can this skill write tests for my code?
No, this skill focuses on refactoring existing code while maintaining test coverage. It does not write new tests. For test generation, consider using a dedicated TDD test-writing skill.
What if my tests fail during refactoring?
Immediately revert the last change, identify what broke, and apply smaller incremental changes. Use version control for safe experimentation. The skill includes recovery protocols for handling failures.
Does this work with all programming languages?
The refactoring principles apply broadly, but code examples and patterns are primarily demonstrated in TypeScript. Concepts translate to Java, C#, Python, and other object-oriented languages.
How do I know which design pattern to apply?
The skill provides guidance on pattern selection based on code smells detected. Start with the specific problem: duplicated code needs extraction, complex conditions need polymorphism, and tight coupling needs dependency injection.

Detalhes do Desenvolvedor

Autor

sickn33

Licença

MIT

Repositório

https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/tdd-workflows-tdd-refactor

Referência

main

Estrutura de arquivos

📄 SKILL.md