Agent Rules / Skills from Programming Books
Rules and skills for AI coding agents (Codex, Cursor, Claude Code) distilled from classic software engineering books on refactoring, architecture, DDD, and code quality.
Evidence shows: The repository clearly states an MIT license and the author is Maciej Ciemborowicz, but the publisher is not verified by the FollowAgents curated enterprise registry, so identity is unknown. No permission requests, data collection, external calls, or sensitive data handling mechanisms are present, hence those criteria score 0. Source attribution is clear (author and license), but no mechanism to verify provenance is provided, hence score 2.
Evidence shows: The repository is internally consistent; no contradictions between README, docs, and rule sets. Rule sets are plain Markdown with no external dependencies, so dependency availability scores 2. No failure messages or error handling mechanisms are provided, hence score 0.
Evidence shows: The repository targets AI coding agents like Codex, Cursor, and Claude Code, and provides multiple usage scenarios (always-on, on-demand, skills, scoped rules, MCP or RAG patterns). Capability boundaries are described in README and docs (e.g., rule sets are not a substitute for reading books). Trigger precision is supported by mini/nano/full versions and specific usage instructions. Environment fit is addressed via USAGE.md and COMPATIBILITY.md.
Evidence shows: Information architecture is clear with README, docs directory, rule set directories, and CHANGELOG. Install notes are provided in USAGE.md. Naming is stable with consistent rule set names. Examples and FAQ are in README. Known limitations are stated in README's 'Important Note'. License is MIT. Versioning and changelog are in CHANGELOG.md. Maintenance responsibility is with the author, but no explicit maintenance plan is provided.
Evidence shows: Output usability is high; rule sets are plain Markdown directly usable by AI agents. Marginal value lies in converting book principles into actionable rules, with an experiment suggesting better effectiveness than merely naming the book. Cost-benefit is reasonable; rule sets are lightweight and easy to integrate.
Evidence shows: Claims are traceable; README provides experiment details and results. Cross-source corroboration is limited; only one experiment and a Reek check, not cross-validated with independent sources. Fact and inference separation is clear; README distinguishes experimental observations from inferences.
- Publisher identity is unverified; treat as unknown and do not infer reliability from brand.
- The experiment result is an early qualitative signal, not a benchmark; do not over-interpret.
- Rule sets are inspired by books but not official materials; be mindful of copyright and accuracy.
What does this agent do, and when should you use it?
This MIT-licensed repository provides ready-to-use AGENTS.md rule sets and skills for AI coding agents, distilled from well-known software engineering books such as Refactoring, Clean Architecture, and Domain-Driven Design. Each rule set is available in three tool-agnostic Markdown versions: mini (recommended), nano (compact), and full (canonical). The repository includes per-book rule files, usage guidance (USAGE.md), compatibility notes (COMPATIBILITY.md), changelog, and a validation experiment showing that using a mini rules set during refactoring yields code that better implements the book's principles compared to merely mentioning the book title. Rules can be integrated into Codex, Cursor, Claude Code, and GitHub Copilot.
The repository is a collection of Markdown files, each dedicated to a specific book (e.g., clean-code/clean-code.md, refactoring/refactoring.md), containing concrete coding rules, patterns, and skills. Users can copy these files into their projects as AGENTS.md, or adapt them for other tools like Cursor or Claude Code skills. The files are static and do not execute code; they serve as instructions for AI coding agents. The repository also includes documentation on usage, compatibility, and a validation experiment comparing refactoring with rules vs. without.
- A developer starting a new project in Codex wants to apply Clean Code principles; they can add the clean-code rules to AGENTS.md.
- An engineer maintaining legacy code uses the Working Effectively with Legacy Code rules to safely refactor.
- An architect designing microservices in Cursor uses Domain-Driven Design rules to define bounded contexts.
- A data engineer uses Designing Data-Intensive Applications rules to ensure reliability in data systems.
- A development team standardizes coding practices by combining rules from multiple books (e.g., Refactoring and Clean Code) in Claude Code.
- A developer wants to create Claude Code skills; they can convert a mini rule set into a skill.
What are this agent's strengths and limitations?
- Rules are based on classic books, providing well-established coding principles and patterns.
- Three granularity versions (full/mini/nano) allow adjustment to different context budgets.
- Integration guides for multiple popular AI agents (Codex, Cursor, Claude Code).
- Validation experiment shows using rules improves refactoring effectiveness.
- MIT license allows free use and modification.
- Rules are not book summaries; understanding may be incomplete without reading the books.
- Requires manual integration into each project; no automated setup tools.
- Validation experiment covers only one book; effectiveness for other books is unverified.
- Rules may assume specific programming languages or technologies, requiring adjustments.
- Dependent on AI agent support for Markdown files; compatibility varies across tools.
How do you install or deploy this agent?
This repository is a collection of rule sets; no installation is required. Clone the repo: git clone https://github.com/ciembor/agent-rules-books.git. Then choose a book directory (e.g., clean-code/), copy the relevant .md file (e.g., clean-code.md) into your project, and rename it to AGENTS.md or CLAUDE.md as appropriate.
How do you use this agent?
- Select a rule set from the repository (e.g., clean-code/mini version). 2. Copy the corresponding file (e.g., clean-code.md) to your project root and rename it to AGENTS.md (or CLAUDE.md / .cursorrules). 3. Ensure your AI coding agent (Codex, Cursor, Claude Code) supports AGENTS.md. 4. Start coding or refactoring; the agent will follow the rules. For skills, convert the mini rules into a Claude Code skill format.
How does this agent compare with similar options?
The repository does not explicitly mention alternatives, but similar rule sets exist in community projects like 'Awesome AGENTS.md'. This repo differentiates by systematically extracting rules from classic books and providing multiple granularity versions.