claude-code-pro-pack — Summary

claude-code-pro-pack is a minimal, battle-tested behavior file for AI coding agents — a 12-rule CLAUDE.md plus a matching AGENTS.md, five example skills, and three templates (PRD generator, browser workflow graduation, skill template). The 12 rules explicitly build on Andrej Karpathy's original 4-rule CLAUDE.md, adding 8 rules that address agent-orchestration failures the original didn't cover: token spirals, silent partial failures, two-pattern pollution, and duplicate-function drift.

Problem it solves: Most CLAUDE.md files either have too few rules (missing common failure modes) or too many (compliance drops past ~200 lines). The pack holds at 12 rules with per-rule failure-mode citations to stay within the agent's attention budget while covering the most impactful behavioral failures.

Distinctive trait: Every rule in the file cites the specific failure mode it closes — e.g., Rule 7 closes "two codebase patterns disagreeing," Rule 12 closes "silent partial failures." This makes the reasoning auditable and the rules extensible by developers who want to add new rules with the same pattern.

Target audience: Developers on any AI coding tool who want a drop-in behavior baseline that works out-of-the-box without installing a framework. Positioned as "Claude Code behavior baseline" to use alongside anthropic/skills (domain tasks) and addyosmani/agent-skills (lifecycle workflow).

Differs from seeds: Closest to agent-os (Archetype 4 — markdown scaffold, zero primitives) but differs: agent-os includes commands that write the standards files, while this pack is purely drop-in files with no installer or commands. Unlike superpowers (which uses hooks and skills to enforce behavior automatically), this pack relies entirely on the agent reading and following the CLAUDE.md — no injection mechanism.

claude-code-pro-pack — Overview

Origin

Published by sisyphusse1-ops on GitHub. 26 stars, 7 forks, MIT license. Last commit: 2026-05-10. Language: HTML (landing page). GitHub Actions action included (action.yml).

Philosophy

"Built from real-world agent failure modes across 30+ codebases. Drop-in files. No framework. ~700 tokens total."

"Karpathy's original 4-rule CLAUDE.md cut Claude coding mistakes from ~40% to ~11%. This pack adds 8 more rules covering the agent-orchestration failures the original didn't — token spirals, silent partial failures, two-pattern pollution, duplicate-function drift."

"Past ~200 lines of CLAUDE.md, compliance drops sharply — rules get buried. The pack holds at 12 rules + minimal boilerplate so the agent actually reads and follows the file. Every rule cites a real failure it closes, not a preference."

The 12 Rules (verbatim from CLAUDE.md)

1. Think before coding. State assumptions out loud. Surface tradeoffs. Push back when a simpler approach exists. No silent guesses.
2. Simplicity first. Minimum code that solves the stated problem. No speculative features. No abstractions for single-use code.
3. Surgical changes. Touch only what the task requires. Don't "improve" adjacent code, comments, or formatting. Match existing style.
4. Goal-driven execution. Define success criteria up front, then loop until verified. Prefer stating the goal over dictating steps.
5. Don't make the model do non-language work. Retries, routing, rate-limiting, arithmetic, time — write deterministic code, not prompts.
6. Hard token budget. Every loop gets a ceiling. If the same 8KB input has been re-chewed for 90 minutes, stop and step back.
7. Surface conflicts, don't average them. When two parts of the codebase disagree, pick one visibly and explain why.
8. Read before you write. Before adding code, read the nearby code. New functions that duplicate existing ones break silently through import order.
9. Tests are gated by correctness, not "pass." A passing test on a function returning a constant is not a passing test.
10. Long-running operations need checkpoints. Multi-step refactors and migrations commit between steps.
11. Convention beats novelty. In a codebase with an established pattern, use that pattern even when yours is "better."
12. Fail visibly, not silently. A migration that "completed successfully" while skipping 14% of records is a bug, not a success.

Positioning vs. Competitors

Explicit comparison table in README:

claude-code-pro-pack — Architecture

Distribution

• Type: Template bundle (static files) + optional GitHub Action
• License: MIT
• Language: HTML (landing page), Markdown (templates + rules)

Install Method

# Step 1: Copy CLAUDE.md (or AGENTS.md for Codex) to project root
# Step 2: Uncomment ## Project specifics block, add stack/test runner/off-limits rules
# Step 3: Commit
# Step 4 (optional): Copy 2-3 skills from examples/ into .claude/skills/ or skills/

No CLI, no installer, no npm package. Manual copy.

Directory Tree

cc-pro-pack/
├── CLAUDE.md                            # 12-rule behavior file — Claude Code
├── AGENTS.md                            # Same 12 rules, Codex/OpenCode variant
├── templates/
│   ├── prd-generator.md                 # Senior PM prompt → agent-ready PRDs
│   ├── browser-skill-graduation.md      # Turn browser workflows into reusable skills
│   └── skill-template.md               # SKILL.md frontmatter + structure template
├── examples/
│   ├── skill-plan-first.md
│   ├── skill-systematic-debugging.md
│   ├── skill-tdd-loop.md
│   ├── skill-github-pr-workflow.md
│   └── skill-code-review.md
├── docs/
│   ├── why-12-rules.md                  # Failure mode each rule closes
│   └── adoption-guide.md               # 10-minute setup for any project
├── action.yml                           # GitHub Action (cc-audit integration)
└── index.html                           # GitHub Pages landing page

Required Runtime

None for the behavior files. The GitHub Action uses Node (not documented in detail).

Target AI Tools

• Claude Code (CLAUDE.md)
• Codex / OpenCode (AGENTS.md)
• Cursor (CLAUDE.md readable)
• Hermes Agent
• GitHub Copilot

Related Repos

• cc-audit: companion one-file Python linter that scores any CLAUDE.md/AGENTS.md against the 12-rule baseline (mentioned in README; separate repo under same author)

claude-code-pro-pack — Components

Core Files (2)

Both files have a ## Project specifics section that is commented out — users uncomment and fill in stack-specific rules.

Both files include a ## Verification checklist with 4 pre-return self-checks.

Example Skills (5)

Templates (3)

Documentation (2)

No Commands, Hooks, MCP, or Subagents

The pack ships zero slash-commands, zero lifecycle hooks, zero MCP servers, and zero subagents. Pure behavioral instructions in markdown files.

claude-code-pro-pack — Uniqueness & Positioning

Differs From Seeds

Most similar to agent-os (Archetype 4 — markdown scaffold, zero primitives): both ship structured markdown files for agents to read passively. The key difference: agent-os ships opinionated standards/ content and "commands" that write those standards into new projects, targeting a standards-install workflow; claude-code-pro-pack is a single drop-in CLAUDE.md + AGENTS.md pair targeting a behavior-baseline use case. Also similar to superpowers in behavioral philosophy (enforcing engineering discipline) but lacks superpowers' automatic injection via hooks — compliance is passive.

The notable positioning move is the explicit origin story: "builds on Karpathy's original 4-rule CLAUDE.md." This grounds the pack in a widely-cited reference point in the community and makes the "8 additional rules" framing legible.

CLAUDE.md vs AGENTS.md Schism

This pack ships both a CLAUDE.md and an AGENTS.md with identical content — the same 12 rules, just different filenames for different tool conventions. This is a direct response to the naming schism in the AI coding community: Claude Code reads CLAUDE.md, Codex and OpenCode read AGENTS.md, other tools have their own conventions. The pack resolves this with parallel files rather than symlinks or a unified format.

Observable Failure Modes

• No injection mechanism — an agent that doesn't read CLAUDE.md carefully (e.g., compacted context) loses all 12 rules
• Rules 1–12 rely on the agent's willingness to follow them; adversarial or misconfigured agents ignore them
• The ~700 token claim is small, but 12 rules + boilerplate + project specifics + example skills can add up quickly
• No verification that the agent actually complied with any rule — the checklist is self-assessed

Relationship to Ecosystem

README recommends using this pack together with anthropic/skills (domain tasks) and addyosmani/agent-skills (lifecycle workflow): "Use all three — pack for behavior, anthropic/skills for domain tasks, addyosmani for lifecycle flow."