---

name: uncle-bob-craft description: "Use when performing code review, writing or refactoring code, or discussing architecture; complements clean-code and does not replace project linter/formatter." category: code-quality risk: safe source: community date_added: "2026-03-06" author: antigravity-contributors tags: [clean-code, clean-architecture, solid, code-review, craftsmanship, uncle-bob] tools: [claude, cursor, gemini]

Uncle Bob Craft

Apply Robert C. Martin (Uncle Bob) criteria for code review and production: Clean Code, Clean Architecture, The Clean Coder, Clean Agile, and design-pattern discipline. This skill is complementary to the existing @clean-code skill (which focuses on the Clean Code book) and to your project's linter/formatter—it does not replace them.

Overview

This skill aggregates principles from Uncle Bob's body of work for reviewing and writing code: naming and functions (via @clean-code), architecture and boundaries (Clean Architecture), professionalism and estimation (The Clean Coder), agile values and practices (Clean Agile), and design-pattern use vs misuse. Use it to evaluate structure, dependencies, SOLID in context, code smells, and professional practices. It provides craft and design criteria only—not syntax or style enforcement, which remain the responsibility of your linter and formatter.

When to Use This Skill

• Code review: Apply Dependency Rule, boundaries, SOLID, and smell heuristics; suggest concrete refactors.
• Refactoring: Decide what to extract, where to draw boundaries, and whether a design pattern is justified.
• Architecture discussion: Check layer boundaries, dependency direction, and separation of concerns.
• Design patterns: Assess correct use vs cargo-cult or overuse before introducing a pattern.
• Estimation and professionalism: Apply Clean Coder ideas (saying no, sustainable pace, three-point estimates).
• Agile practices: Reference Clean Agile (Iron Cross, TDD, refactoring, pair programming) when discussing process.
• Do not use to replace or override the project's linter, formatter, or automated tests.

Aggregators by Source

| Source | Focus | Where to go | |--------|--------|-------------| | Clean Code | Names, functions, comments, formatting, tests, classes, smells | Use @clean-code for detail; this skill references it for review/production. | | Clean Architecture | Dependency Rule, layers, boundaries, SOLID in architecture | See reference.md and references/clean-architecture.md. | | The Clean Coder | Professionalism, estimation, saying no, sustainable pace | See reference.md and references/clean-coder.md. | | Clean Agile | Values, Iron Cross, TDD, refactoring, pair programming | See reference.md and references/clean-agile.md. | | Design patterns | When to use, misuse, cargo cult | See reference.md and references/design-patterns.md. |

Design Patterns: Use vs Misuse

• Use patterns when they solve a real design problem (e.g., variation in behavior, lifecycle, or cross-cutting concern), not to look "enterprise."
• Avoid cargo cult: Do not add Factory/Strategy/Repository just because the codebase "should" have them; add them when duplication or rigidity justifies the abstraction.
• Signs of misuse: Pattern name in every class name, layers that only delegate without logic, patterns that make simple code harder to follow.
• Rule of thumb: Introduce a pattern when you feel the third duplication or the second reason to change; name the pattern in code or docs so intent is clear.

Smells and Heuristics (Summary)

| Smell / Heuristic | Meaning | |-------------------|--------| | Rigidity | Small change forces many edits. | | Fragility | Changes break unrelated areas. | | Immobility | Hard to reuse in another context. | | Viscosity | Easy to hack, hard to do the right thing. | | Needless complexity | Speculative or unused abstraction. | | Needless repetition | DRY violated; same idea in multiple places. | | Opacity | Code is hard to understand. |

Full lists (including heuristics C1–T9-style) are in reference.md. Use these in review to name issues and suggest refactors (extract, move dependency, introduce boundary).

Review vs Production

| Context | Apply | |---------|--------| | Code review | Dependency Rule and boundaries; SOLID in context; list smells; suggest one or two concrete refactors (e.g., extract function, invert dependency); check tests and professionalism (tests present, no obvious pressure hacks). | | Writing new code | Prefer small functions and single responsibility; depend inward (Clean Architecture); write tests first when doing TDD; avoid patterns until duplication or variati