| name | code-craft |
| description | Router/index for the software-craftsmanship skill family — 7 classic books turned into knowledge bases: clean-code, refactoring, design-patterns, solid-principles, code-complete, pragmatic-programmer, 97-things. Use when the user wants cleaner code / more disciplined, standardized engineering, asks which principle/pattern/refactoring applies, wants a code-quality or design-review rubric, or says 让代码更简洁 / 工程更规范 / 重构 / 设计模式 / 设计原则 — and you need to pick the right craftsmanship skill. Routes a task or topic to the OWNING skill with clear boundaries so they don't overlap. Distinct from dev-commons (this workspace's stack-specific recipes) and from code-review/simplify (which execute reviews); those run the work, code-craft supplies the canonical craft knowledge. |
| allowed-tools | ["Read","Grep"] |
| metadata | {"tier":"default-min","cost":"light","side_effects":"none","argument-hint":"[a task, topic, smell, principle, or pattern — or a skill name]"} |
code-craft — the software-craftsmanship router
Seven classics, each its own skill. This router declares who owns what and routes you to the right one. Load the owning skill; don't re-derive its content here.
Route by intent
| You want to… | Go to |
|---|
| Name things / shape functions / comments / formatting / error handling / clean tests / a review-heuristics checklist | clean-code |
| Improve existing code safely — name a smell → apply a refactoring with mechanics | refactoring |
| Decide an OO design or diagnose rot — SOLID, design smells, package & dependency metrics | solid-principles |
| Pick or recall one of the 23 GoF patterns; disambiguate look-alikes | design-patterns |
| Construction breadth + checklists — defensive programming, variables/data, control flow, code tuning, integration, layout | code-complete |
| Cross-cutting pragmatic philosophy — DRY, orthogonality, tracer bullets, DBC, the 70 Tips | pragmatic-programmer |
| A fast maxim, or many short expert opinions across all topics | 97-things |
Ownership boundaries (so the skills don't overlap)
- clean-code (R. Martin) — code-level standards: what good names/functions/comments/formatting/tests look like; the Ch17 smells-&-heuristics review catalog. → Principle behind a rule → solid-principles; the step-by-step fix → refactoring.
- refactoring (Fowler) — owns the smell → named-refactoring → mechanics catalog ("how to change existing code"). → Design-scale smells/principles → solid-principles; review heuristics → clean-code; patterns as targets → design-patterns.
- solid-principles (Martin, PPP) — owns SOLID + the 7 design smells + package/component principles (REP/CCP/CRP, ADP/SDP/SAP, I/A/D metrics, Main Sequence). → The pattern catalog it references → design-patterns.
- design-patterns (GoF) — owns the 23 patterns (intent/participants/consequences/disambiguation). → The why/when at principle level → solid-principles.
- code-complete (McConnell) — owns construction breadth + checklists/thresholds (params ≤7, nesting ≤3–4, name length, etc.). Touches every topic shallowly; for depth on one topic prefer the specialist sibling.
- pragmatic-programmer (Hunt & Thomas) — owns the attitude/philosophy & cross-cutting craft (DRY, orthogonality, reversibility, tracer bullets, DBC, knowledge portfolio, 70 Tips). → Concrete code standards → clean-code; mechanics → refactoring.
- 97-things (Henney, ed.) — a fast aphorism index across all of the above; for depth on any maxim, jump to the relevant sibling.
Overlap resolution (when two skills touch the same idea)
- SRP / OCP / DIP — deep home is solid-principles; clean-code (Ch10) has the code-level version. Prefer solid-principles for the principle itself.
- Code smells — three complementary catalogs by altitude: refactoring Ch3 (code-level → fixes), solid-principles Ch7 (design-rot), clean-code Ch17 (review heuristics).
- Refactoring — the catalog/mechanics live in refactoring; clean-code, code-complete, solid-principles, pragmatic-programmer all just reference it.
- DRY — named home is pragmatic-programmer; echoed in clean-code (Ch3) and 97-things.
- Law of Demeter / testing / naming — appear in several; each book's take is kept faithfully. Use this router to choose the altitude you want.
Relationship to your other skills (NOT part of this family)
- dev-commons — your stack-specific recipes (Flask / Electron / Next.js / Python / Windows + the 15 code-conventions). That answers "how to build a route in this project"; code-craft is the language-agnostic craft layer above it. Do not duplicate dev-commons' convention tables here.
- code-review / simplify / review / debug-backend — action skills that execute a review or change. They are the verbs; the code-craft family supplies the criteria (load a craft skill to ground a review in named principles).
- book-to-skill — the converter these 7 were built with; use it to add or refresh a book.
How to use
- Give me a task/topic/smell/principle/pattern → I name the owning skill and load it.
- Give me a skill name → I hand off directly.
- Doing a review? Pull the rubric from clean-code + solid-principles (+ refactoring for existing code), then run code-review/simplify to apply it.
