skills

Skills for writing and reviewing clean code with Claude Code, and domain-driven design with Codex.

Skill	Use when
writing-clean-code	Writing new code — SOLID, dependency injection, naming, pattern selection
adversarial-review	Reviewing existing code — multi-agent smell hunt with adversarial verification
domain-driven-design	Codex domain modeling — sequential subagents from discovery and strategic design through tactical modeling, adversarial skepticism, and parent reconciliation

domain-driven-design supports greenfield and existing systems. Each phase builds on accepted upstream conclusions and can challenge them with new evidence. It uses ordinary Codex runtime subagents, requires no custom agent installation, and treats “no DDD abstraction needed” as a valid outcome.

adversarial-review at a glance

Diff-agnostic: reviews a PR, a branch diff, staged changes, a commit range, a pasted diff, or plain files/directories — every mode reduces to the same review set.

review set ──▶ 9 hunters (blind, parallel within capacity) ──▶ merge + dedup ──▶ finding-skeptic ──▶ report

• Five hunters cover the refactoring.guru smell families (Bloaters, OO Abusers, Change Preventers, Dispensables, Couplers); clean-code-reviewer covers SOLID. Three dedicated hunters cover function clarity, module architecture, and function flow.
• Every smell has a C# and a pseudocode example in adversarial-review/references/smells-*.md.
• Every finding needs file:line + quoted evidence + a harm scenario. The skeptic attempts evidence-based disproof while retaining supported maintenance findings; unresolved evidence and incomplete hunter coverage stay visible. Design rationale and sources: prior-art.md.

Clean code documents

• Function and implementation clarity: descriptive names, honest return contracts, readable conditions, comments, and explicit effects.
• Module architecture: cohesive responsibilities, representation boundaries, validation ownership, and public contracts.
• Function flow: one level of iteration per function, meaningful extraction, and understandable composition.

Install

Claude Code skills (writing and review):

git clone <this repo>
ln -s "$PWD/skills/writing-clean-code" ~/.claude/skills/writing-clean-code
ln -s "$PWD/skills/adversarial-review" ~/.claude/skills/adversarial-review

Optional — use the reviewer agents standalone (@agent-bloater-hunter, @agent-clean-code-reviewer, ...):

for f in skills/adversarial-review/agents/*.md; do
  ln -s "$PWD/$f" ~/.claude/agents/"$(basename "$f")"
done

The adversarial-review skill does not require the standalone install; its orchestrator spawns the roles as subagents directly from the agents/ files.

Codex skill (run from the cloned repository root):

mkdir -p ~/.agents/skills
ln -s "$PWD/domain-driven-design" ~/.agents/skills/domain-driven-design

Invoke $domain-driven-design for substantive DDD work in a Codex session with subagents available.

Layout

writing-clean-code/
  SKILL.md                 # core discipline, links out
  references/              # solid, dependency-injection, clean-code-rules, design-patterns
adversarial-review/
  SKILL.md                 # the pipeline: scope → hunt → dedup → skeptic → report
  agents/                  # 10 roles: 5 smell hunters, SOLID, 3 clean-code hunters, skeptic
  references/              # smell catalogs (code + pseudocode), SOLID violations,
                           # scope-collection, refactoring-techniques, prior-art
domain-driven-design/
  SKILL.md                 # sequential Codex orchestration, skeptic, reconciliation
  references/              # strategic and tactical phase contracts with source grounding