brooks-lint
Helps your agent review code, finding design flaws and architectural risks. It draws on classic software engineering books.
What it does
This program analyzes your programming code using lessons from 12 classic software engineering books. It looks for design issues, like repeated code or complicated dependencies, that common tools might miss.
When to use it
- ✓When you want feedback on your code's structure beyond the basics.
- ✓Before making major code changes to find weak spots.
- ✓When code works but feels confusing or poorly organized.
Example of what to ask your AI
“Review this code and tell me if it follows good design practices.”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
It compares your code against principles from famous programming books like 'Clean Code' and 'The Pragmatic Programmer'. It identifies bad patterns and suggests architectural improvements.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add sickn33/agentic-awesome-skills --skill brooks-lintOr download just the file:
curl -L https://raw.githubusercontent.com/sickn33/agentic-awesome-skills/main/plugins/agentic-awesome-skills-claude/skills/brooks-lint/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Brooks Lint
Overview
Brooks Lint is a Claude Code skill that reviews your code through the lens of 12 classic software engineering books. Instead of checking style rules, it asks: "What would the authors of The Pragmatic Programmer, Clean Code, and Designing Data-Intensive Applications say about this code?"
It synthesizes the principles from landmark engineering books into actionable, structured feedback — catching design smells, tight coupling, missing abstractions, and architectural risks that linters and AI tools typically miss.
Named after Fred Brooks, author of The Mythical Man-Month — because the hardest bugs are conceptual, not syntactic.
The 12 Books
| Book | Key Principles Applied |
|---|---|
| The Pragmatic Programmer | DRY, orthogonality, tracer bullets |
| Clean Code | Naming, function size, comment clarity |
| The Mythical Man-Month | Conceptual integrity, second-system effect |
| Designing Data-Intensive Applications | Data consistency, fault tolerance, scalability |
| A Philosophy of Software Design | Deep modules, information hiding, complexity |
| Refactoring | Code smells, extract method, encapsulation |
| Working Effectively with Legacy Code | Seams, characterization tests, dependency breaking |
| Domain-Driven Design | Ubiquitous language, bounded contexts, aggregates |
| Release It! | Stability patterns, timeouts, bulkheads, circuit breakers |
| Structure and Interpretation of Computer Programs | Abstraction, recursion, metalinguistic abstraction |
| The Art of UNIX Programming | Modularity, composability, rule of least surprise |
| Extreme Programming Explained | YAGNI, simple design, collective ownership |
When to Use This Skill
- Use when you want architectural feedback beyond what linters provide
- Use before major refactors to identify structural debt
- Use when reviewing code that "works but feels wrong"
- Use when onboarding to a codebase to quickly map risk areas
- Use for design reviews before starting a new module or service
How It Works
Brooks Lint applies each book's core principles as a review lens:
- Smell detection: Flags violations of DRY, SRP, Law of Demeter, etc.
- Coupling analysis: Identifies tight dependencies and missing abstraction layers
- Naming critique: Applies Clean Code naming rules to variables, methods, classes
- Architecture review: Checks for DDIA-style data consistency and fault tolerance gaps
- Stability patterns: Flags missing timeouts, retries, and circuit breakers (Release It!)
- Complexity scoring: Applies APOSD complexity metrics to identify over-engineered sections
Installation
# Install via Claude Code plugin marketplace
# Search: "brooks-lint" in Claude Code > Extensions
# Or install via NPX (Antigravity)
npx agentic-awesome-skills --claude
# Then invoke: @brooks-lint
Examples
Example 1: Review a Service Class
@brooks-lint review src/services/PaymentService.ts
Brooks Lint output:
[Pragmatic Programmer] DRY violation: payment validation logic duplicated in 3 places
[Clean Code] Method processPayment() does 4 things — violates Single Responsibility
[Release It!] No timeout on external payment gateway call — risk of cascade failure
[DDIA] No idempotency key — retry on network error will double-charge
[APOSD] PaymentService knows too much about UserRepository — high coupling
Example 2: Full Codebase Architecture Review
@brooks-lint analyze the overall architecture of this codebase
Example 3: Pre-Refactor Review
@brooks-lint what are the biggest design smells in this module before I refactor it?
Review Categories
| Category | Books Applied | What It Catches |
|---|---|---|
| DRY / Duplication | PP, Refactoring | Copy-paste code, shared logic not extracted |
| Naming | Clean Code, DDD | Unclear names, domain language violations |
| Coupling | APOSD, PP | Tight dependencies, missing interfaces |
| Stability | Release It! | Missing timeouts, no retry logic, no circuit breakers |
| Data Integrity | DDIA | Race conditions, non-idempotent operations |
| Complexity | APOSD, SICP | Over-engineering, unnecessary abstraction |
| Legacy Debt | WELC | Hard-to-test code, missing seams |
| Domain Clarity | DDD, XP | Anemic models, missing bounded contexts |
Best Practices
…
FAQ
Why is it called 'Brooks Lint'?
It's named after Fred Brooks, author of 'The Mythical Man-Month', who believed the hardest bugs are conceptual, not typos.
What kinds of problems does it find?
It finds issues like duplicated code (DRY), poor naming, tight coupling between code parts, and architectural flaws that could cause future problems.
Does it replace a human reviewer?
No, it's a helpful tool. It's good for a second opinion based on established principles, but critical decisions should still be made by humans.
Details
Original description by the author
AI code reviewer grounded in classic software engineering books for catching design smells, coupling issues, and architectural risks.
Popularity
- GitHub stars
- 48k
- Ranking position
- #2447
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
00-andruia-consultant
Helps your agent start or improve AI projects. It analyzes code, suggests tools, and creates action plans in Spanish.
sickn33/agentic-awesome-skills
007
Lets your agent perform security audits and threat modeling. It's useful for protecting projects against attacks and vulnerabilities.
sickn33/agentic-awesome-skills
10-andruia-skill-smith
Helps your agent create or improve AI tools. It defines how tools work, writes documentation, and validates the structure.
sickn33/agentic-awesome-skills
20-andruia-niche-intelligence
Lets your agent create a summary about a specific industry. It's useful for understanding the context, rules, usage patterns, and risks of a project, using reliable sources.
sickn33/agentic-awesome-skills
Similar skills
cpp-testing
Makes your agent write and improve tests for C++ code. It helps set up testing tools and fix errors.
affaan-m/ECC
csharp-testing
Helps your agent create tests for C# and .NET code. It uses best practices to ensure tests are efficient and reliable.
affaan-m/ECC
django-tdd
Enables your agent to apply testing strategies for Django with pytest-django and TDD. It's useful for writing robust tests and ensuring code quality, especially for DRF APIs.
affaan-m/ECC