Agent skill · Code Review & Quality

improve-code-quality

Guided journey from a working-but-untested vibe-coded prototype to a production-ready product with tests, clean structure, a business-rules boundary, and resilience at scale. Orchestrates nine skills phase by phase - working-with-legacy-code, clean-code, refactoring-patterns, software-design-philosophy, clean-architecture, pragmatic-programmer, release-it, system-design, ddia-systems - asking the user questions at every decision point and recording results in the project docs/ folder (TESTING.md, TECH-DEBT.md, RELIABILITY.md, IMPROVE-CODE-QUALITY-PLAN.md) so the journey resumes across sessions

wondelaigithub.com/wondelaiGitHub ↗
claude-codeMIT
Install
npx skills add wondelai/skills --skill improve-code-quality --agent claude-code

Same command for any agent — swap --agent for codex, cursor, copilot.

Facts
Files in the skill folder: 2
SKILL.md size: 24 KB
Bundled scripts: none
Version: 1.0.0
Declared author: wondelai
Path: improve-code-quality/SKILL.md
Open the folder on GitHub →
Where it comes from
Stars: 1,835
Language: Shell
Read our review of the source →

Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.

Review
written from the skill's own SKILL.md · Aug 5, 2026

What it does

Guided journey from a working-but-untested vibe-coded prototype to a production-ready product with tests, clean structure, a business-rules boundary, and resilience at scale. Orchestrates nine skills phase by phase and records results in the project docs/ folder (TESTING.md, TECH-DEBT.md, RELIABILITY.md, IMPROVE-CODE-QUALITY-PLAN.md) so the journey resumes across sessions. Use when the user wants to harden an AI-generated prototype, add tests before refactoring, make code safe to change, or says ''this works on my machine but I am scared to touch it''. For a large aged codebase, use remove-technical-debt; to decide structure before building, use design-code-architecture; for a product and UX pass, use improve-app. For one framework in isolation, invoke that skill directly.

How it works

  • The skill defines a nine-phase journey where each phase is handled by a specific sub-skill (e.g., working-with-legacy-code, clean-code, refactoring-patterns, etc.).
  • Before each phase, it asks the user to decide entry points and confirms the phase plan, resuming from an existing tracker if available.
  • Phase 1 creates docs/TESTING.md and docs/TECH-DEBT.md as safety nets; subsequent phases extend docs files (e.g., docs/TECH-DEBT.md, docs/ARCHITECTURE.md, docs/RELIABILITY.md) with phase-specific artifacts.
  • Phase invocation follows the slug of the phase (e.g., invoke working-with-legacy-code, clean-code, refactoring-patterns, etc.). If a phase tool is unavailable, the user can install it via npx skills add wondelai/skills/<slug> --global.
  • Each phase requires decisions to be recorded in a tracker with Key Decisions and Next Actions, and a draft artifact is presented for sign-off before writing.
  • Phase 1 is a gate; changes to code absent from the Safety Net Map are not allowed. Commits are single-purpose per phase, especially during refactors with tests green.

When to use it

  • When the user wants to harden an AI-generated prototype, add tests before refactoring, make code safe to change, or address fear around touching working code.
  • For a large aged codebase, use remove-technical-debt; to decide structure before building, use design-code-architecture; for a product and UX pass, use improve-app. For a single framework in isolation, invoke that skill directly.

What it can touch

  • The skill references creating and extending docs/ files: TESTING.md, TECH-DEBT.md, ARCHITECTURE.md, RELIABILITY.md, IMPROVE-CODE-QUALITY-PLAN.md, and possibly others under docs/.
  • It invokes phase-specific skills by slug (e.g., working-with-legacy-code, clean-code, refactoring-patterns, software-design-philosophy, clean-architecture, pragmatic-programmer, release-it, system-design, ddia-systems).

Caveats

  • Requires tracker existence to resume; intake creates IMPROVE-CODE-QUALITY-PLAN.md with phase statuses.
  • Phase progress depends on user decisions; skipping or deferring follows defined rules. Phase 1 must pin behavior before later phases touch code.
  • Artifacts are created or extended in docs/ with uppercase section headings per artifact templates; each phase adheres to single-purpose commits when possible.
From the SKILL.md

# Improve Code Quality Turn a working-but-untested vibe-coded prototype into a product you can ship and operate. This is an interactive, resumable journey of nine phases: the agent asks before every decision and records the outcome in your project's `docs/` folder, so you can stop after any phase and pick up later. A week-old prototype is already legacy code — so the first move is a safety net, and every phase after it is verifiable because of that net. ## Core Principle **A week-old untested prototype is already legacy code: flip tactical to strategic — safety net first, then readability, structure, and production hardening in order.** This skill sequences the phases, asks the decision questions, and records every choice in `docs/`. The constituent skills carry the method — invoke them rather than improvising their frameworks. Skipping ahead (refactoring before tests, scaling before sizing) is the exact failure mode this ordering exists to prevent. ## Journey Map | Phase | Skill | Question it answers | Artifact | |---|---|---|---| | 1 | working-with-legacy-code | Can I change this code without breaking it unknowingly? | Creates docs/TESTING.md + docs/TECH-DEBT.md — GATE | | 2 | cl

What's inside
Steps it walks through
  1. Core Principle
  2. Journey Map
  3. Operating Rules
  4. Intake
  5. Phases
  6. Phase 1 — Build the safety net (working-with-legacy-code) — GATE
  7. Phase 2 — Make the code readable (clean-code)
  8. Phase 3 — Apply named refactorings (refactoring-patterns)
  9. Phase 4 — Reduce complexity with deep modules (software-design-philosophy)
  10. Phase 5 — Draw the architecture boundary (clean-architecture)
  11. Phase 6 — Lock in the habits (pragmatic-programmer)
  12. Phase 7 — Make it survive production (release-it)
  13. Phase 8 — Size for real load (system-design)
  14. Phase 9 — Get the data layer right (ddia-systems)
Ships with 1 file
  • references/artifact-templates.md
More from skills
All skills →
About this skill
What does the improve-code-quality skill do?

Guided journey from a working-but-untested vibe-coded prototype to a production-ready product with tests, clean structure, a business-rules boundary, and resilience at scale. Orchestrates nine skills phase by phase - working-with-legacy-code, clean-code, refactoring-patterns, software-design-philosophy, clean-architecture, pragmatic-programmer, release-it, system-design, ddia-systems - asking the user questions at every decision point and recording results in the project docs/ folder (TESTING.md, TECH-DEBT.md, RELIABILITY.md, IMPROVE-CODE-QUALITY-PLAN.md) so the journey resumes across sessions

How do I install it?

Run `npx skills add wondelai/skills --skill improve-code-quality --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.

Where does this skill come from?

From wondelai/skills, a repository with 1,835 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.

Is a popular skill a good skill?

Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.

Keep going