convez.ai
SkillAutomaçãoIntermediário
jsas-XVIII

Personal Development Cycle para Claude Code

jsas-XVIII/Personal-Development-Cycle

Ciclo de desenvolvimento estruturado com skills sequenciais para Claude Code

Ver no GitHub
InicialPluginScore · de 0 a 100

Conjunto estruturado de skills em Markdown que guiam Claude Code através de um ciclo de desenvolvimento disciplinado, desde análise até deployment. Organiza o trabalho em sete fases sequenciais (análise, planejamento, implementação, documentação, limpeza, revisão, git) mais ciclos de refatoração independentes para manutenção contínua de código.

Instalação

$npx convez-ai jsas-XVIII/Personal-Development-Cycle

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 2 meses
Versão
v1.0.0
Issues abertas
0
Contribuidores
1

Casos de uso

  • Disciplinar o desenvolvimento assistido por IA evitando scope creep
  • Garantir testes integrados em cada fase, não apenas ao final
  • Manter qualidade de código com refatorações periódicas planejadas
  • Estruturar handoffs claros entre análise, implementação e revisão

Veredito

Abordagem sólida para domesticar o desenvolvimento com IA, transformando capacidade bruta em workflow disciplinado. Prático para equipes que já usam Claude Code e querem evitar débito técnico silencioso — mas exige comprometimento com as sete fases em sequência.

README

A tradução para o português deste README ainda está na fila.

Claude Code Development Cycle Skills

A set of structured skills for Claude Code that encode a disciplined development cycle — from analysis through deployment, plus targeted refactor passes for ongoing code health.

Note: These skills are actively being used and improved. They reflect a real workflow, not a theoretical one, and will evolve as that workflow does.


Background

These skills came out of a need to bring structure to AI-assisted development without losing the judgment that makes software good. Claude Code is capable, but capability without discipline leads to scope creep, skipped steps, and silent compounding of technical debt — problems that are invisible until they become expensive.

The skills don't add capability. They direct Claude's judgment toward a specific quality bar, a specific workflow, and specific boundaries around when to stop and ask rather than decide alone. Each skill has one job, hard rules about what it does not do, and a clear handoff to the next step.

The development cycle encoded here prioritizes:

  • Understanding before implementing
  • Testing as part of implementation, not after
  • Deferring work that creates noise during active coding (linting, comments, optimization)
  • Human judgment at every point where static analysis reaches its limits

How It Works

Skills are Markdown files that Claude Code reads to understand how to behave during a specific phase of work. Each skill in this set covers one stage of the development cycle. You invoke the relevant skill at the start of each phase, and Claude follows the rules encoded in it for that session.

For installation and setup, see the Claude Code skills documentation.


The Development Cycle

Core Cycle

These seven skills form the standard development cycle. They run in order for every feature or coding task.

#SkillPurpose
01dev-cycle-analysisRead relevant files, build context, identify hot path candidates, estimate complexity, verify test baseline. No changes yet.
02dev-cycle-planningCollaborate on what to build, write acceptance criteria (effort 5+), break into phases, assign effort score, confirm working branch, write session plan to ./docs/.
03dev-cycle-implementationWrite code phase by phase, run tests, diagnose failures. Defined abort protocol for structural plan failures. No comments yet.
04dev-cycle-documentationAdd or update comments on changed code. Timestamps and author attribution on every changed function.
05dev-cycle-cleanupLint fixes, npm audit fix, README update. Only after code and tests are stable.
06dev-cycle-reviewSystematic review of all changes before push. Claude's findings plus a prompt for your own pass.
07dev-cycle-gitCommit message generation, branch description, push. Option to hand off git operations manually.

Refactor Cycle

These skills run periodically — not after every feature. Each one is independent: you pick whichever fits the current need and run it on its own. They do not need to be run together or in order. Each one runs through the full development cycle with a specific focus lens. A refactor score in ROADMAP.md tracks accumulated effort and suggests when a refactor pass is due.

#SkillFocus
1dev-cycle-refactor-health-checkDead code, architectural drift, dependency health, technical debt inventory, documentation gaps.
2dev-cycle-refactor-efficiencyPerformance bottlenecks, hot path confirmation, algorithmic complexity, resource usage.
3dev-cycle-refactor-securityInput handling, authentication gaps, data exposure, dependency vulnerabilities, common attack vectors.
4dev-cycle-refactor-bug-huntingLogic errors, edge cases, error handling gaps, state and timing issues, integration fragility.
5dev-cycle-refactor-test-coverageUntested code, undertested paths, over-mocked tests, weak assertions, integration gaps.

Project Conventions These Skills Assume

  • ROADMAP.md in the project root — master feature tracker and refactor score
  • ./docs/[task-name].md — per-session plan files, created during planning, deleted after merge
  • npm test, npm run lint, npm audit — standard npm scripts for testing, linting, and auditing
  • CLAUDE.md in the project root — Claude Code project conventions file (if present, treated as source of truth)

The npm/Node assumptions are specific to my current stack. If you are adapting these skills for a different stack, update the tooling references in the cleanup and analysis skills accordingly.


Refactor Score

Each planning session assigns a Fibonacci effort score (1, 2, 3, 5, 8, 13, 21) to the work being done. This score accumulates in ROADMAP.md across sessions:

Refactor Score: 18 / 34
  • At 20: Soft nudge to consider a refactor pass soon
  • At 34: Strong recommendation to refactor before continuing

Completing any single refactor skill resets the score to 0 — you do not need to run all five. The reset is handled automatically by the git skill, which detects whether the session was a refactor cycle and resets instead of incrementing. This mirrors Agile story point sizing and gives a data-driven signal for when technical debt has accumulated enough to address — without requiring a refactor after every feature.


Design Principles

One job per skill. Each skill covers exactly one phase. It does not drift into the next phase, and it has explicit rules about what it does not do.

Flag, don't fix. During analysis and review, Claude flags concerns without acting on them. Fixes happen in implementation, under a confirmed plan.

Evidence before optimization. The efficiency refactor skill distinguishes static hot path candidates from confirmed bottlenecks. Claude does not optimize without runtime evidence unless the structural case is overwhelming.

Human judgment at the limits. Static analysis cannot confirm performance bottlenecks, race conditions, or dynamic code references. The skills are explicit about where Claude's analysis ends and runtime observation or human review begins.

Comments for the next person. Documentation is written as if the next developer has solid coding experience but zero prior context about this specific project. The why matters more than the what.


Status

These skills are in active use and will be updated as the workflow evolves. Known areas for future improvement are tracked in the repo issues.

Feedback, forks, and adaptations for other stacks are welcome.


Author

Built through collaboration between personal development experience and Claude Code, as part of learning how to use AI tooling effectively without losing engineering discipline.

Ver o original no GitHub

Bom para

Relacionados