Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
[Skill Management] Use when enhancing, compressing, or expanding prompts, docs, or skills with attention anchoring [INTELLIGENT ROUTING]. Flag: --op={compress|expand|enhance} (default enhance); --op=compress strips token bloat, --op=expand reconstructs compressed text.
Quick Summary
Goal: Two-phase optimization — (1) Caveman Compression strips stop words + grammatical scaffolding while preserving semantic meaning; (2) Prompt Enhancement applies AI attention anchoring so AI reads and follows all instructions — producing a prompt/skill that states its objective and ultimate outcome (one consolidated Goal) in both top summary and bottom reminders so AI optimizes for the right result.
Summary:
Two phases, in order: caveman-compress prose FIRST, then attention-anchor structure — NEVER skip or reorder.
Enhance derives BOTH a Goal (the outcome to optimize for) AND a Summary (key things + steps to notice) for the target, and places both in its Quick Summary.
Protect content: NEVER compress code/YAML/tables/SYNC tags, NEVER delete rules or file:line evidence; post rule-density MUST be ≥ pre.
Detect — Classify target: skill file, sub-agent file (.claude/agents/*.md), protocol file, or general doc
Read — Read target file completely
Goal + Summary — Derive the target's one-sentence Goal (what it achieves + the ultimate outcome it must cause) AND its Summary (2-4 bullets of the key important things + the steps AI must notice) from the target's task, constraints, and success criteria
Compress — Apply caveman compression (Phase 1)
Enhance — Apply AI attention anchoring transforms (Phase 2)
Verify — No content loss, rule density ≥ pre-optimization, Goal anchored top and bottom
Key Rules:
Operation flag (see Operation Mode): --op=enhance (default) = compress + anchor + skill-principles; --op=compress = token-strip only; --op=expand = reconstruct compressed text into fluent form (inverse Phase 1 + structural Transform 4)
NEVER skip Phase 1 (compress) before Phase 2 (enhance) — compression removes noise, enhancement structures signal
NEVER remove meaningful rules, constraints, code examples, or file:line evidence
MUST ATTENTION derive the target's Goal and add it to both ## Quick Summary and ## Closing Reminders
MUST ATTENTION derive the target's Summary (key important things + steps AI must notice) and place it in ## Quick Summary immediately after the Goal — a condensing digest at a different altitude than Workflow/Key Rules, NEVER a verbatim re-listing of them
MUST ATTENTION skill AND sub-agent (.claude/agents/*.md) targets require the SAME Goal + Summary + Closing-Reminders structure (see When Target is a Sub-Agent File) — anchored top and bottom; NEVER alter SYNC blocks when enhancing an agent
Post-optimization rule density (MUST ATTENTION/NEVER/ALWAYS per 100 lines) MUST be ≥ pre-optimization
Caveman compression applies to prose only — NEVER compress code blocks, YAML, or structured tables
No file? Ask via AskUserQuestion. Text passed (not file path)? Apply caveman compression directly and output result.
Operation Mode (--op=)
Route on --op (default enhance). Transforms 1-3 (inline summaries, top summary, closing reminders — the shared SYNC base block below) are identical across all ops; only Phase 1 and Transform 4 differ:
--op
Phase 1
Transform 4
Skill-principles + Goal
Former skill
enhance(default)
Caveman Compression
Conciseness pass
Applied (skill files)
host
compress
Caveman Compression
Conciseness pass
Skipped (pure token strip)
/prompt-compress
expand
Language Expansion (inverse — branch below)
Structural Clarity
Skipped
/prompt-expand
enhance / compress → run Phase 1: Caveman Compression + Transform 4: Conciseness below. enhance additionally derives the Goal and (for skill files) applies the Universal Skill-Building Principles; compress skips both for a pure token-reduction pass.
expand → run the Language Expansion branch below INSTEAD of Caveman Compression, and the Structural Clarity Transform 4 instead of conciseness.
No --op provided → enhance.
--op=expand — Language Expansion branch
Reconstruct fluent, grammatically correct English from caveman-compressed text while preserving ALL semantic content (inverse of Phase 1). Run INSTEAD of Caveman Compression.
Verify (expand): no semantic loss (all facts/numbers/paths present), rule density post ≥ pre, no telegraphic 2-5 word prose sentences remain, code blocks untouched.
Phase 0: Detect Target Type
Before any other step, classify target:
Target type
Detection
Action
Skill file
Path matches .claude/skills/**/*.md
Apply Universal Skill-Building Principles after Phase 1
Sub-agent file
Path matches .claude/agents/*.md
Apply Sub-Agent Required Structure after Phase 1
Protocol file
Path matches .claude/protocols/**/*.md
Standard 2-phase optimization only
General doc/prompt
Any other .md file
Standard 2-phase optimization only
Raw text
No file path provided
Apply caveman compression only, output result
When Target is a Skill File
Target .claude/skills/**/*.md (any SKILL.md)? Apply Universal Skill-Building Principles AFTER caveman compression, BEFORE writing enhanced output.
Skill Enhancement Checklist
After caveman compression, evaluate skill against each principle, add missing structure:
Principle
Check
Action if missing
Detect Before Act
Phase 0 / classification step present?
Add artifact-type detection before Phase 1
Derive, Don't Enumerate
Thinking framework vs. fixed checklist?
Replace checklist with "understand → derive → execute"
Target .claude/agents/*.md (a custom sub-agent definition — the shape a creator skill like custom-agent emits)? Apply the Sub-Agent Required Structure AFTER caveman compression, BEFORE writing enhanced output. Same Goal + Summary + Closing-Reminders contract as a skill file — anchored top and bottom so the isolated, zero-history sub-agent optimizes for the right outcome — mapped onto the agent body (## Role → ## Workflow → ## Key Rules → ## Output).
One consolidated sentence — what the agent achieves AND the ultimate outcome it must cause
**Summary:**
inside Quick Summary, immediately after Goal
2-4 bullets — the read-this-if-nothing-else digest (key things + steps to notice); distinct altitude from Workflow/Key Rules, NEVER a verbatim re-listing
**Workflow:** / **Key Rules:**
inside Quick Summary
Keep existing
## Closing Reminders
end of file, after the :reminder SYNC blocks
Present — first line **IMPORTANT MUST ATTENTION Goal:** echoes the same Goal
MUST ATTENTION add the missing **Summary:** and the Closing-Reminders Goal echo; lightly tighten Role/Workflow prose only — why: the structure must match a skill so creator skills emit one consistent shape.
NEVER alter <!-- SYNC:... --> blocks or their :reminder variants — they are canonical-sync content; edit the canonical source (.claude/skills/shared/sync-inline-versions.md) instead — why: a divergent SYNC copy fails the verify-sync-divergence oracle.
NEVER delete the agent body sections (## Role, ## Workflow, ## Key Rules, ## Output) — preserve them; only restructure the summary/closing anchors.
Phase 1: Caveman Compression
Applies to --op=compress|enhance. For --op=expand, run the Language Expansion branch (above) instead.
Aggressively remove stop words + grammatical scaffolding preserving meaning. Use only content words carrying semantic weight.
What to Remove
Category
Examples
Articles
a, an, the
Auxiliary verbs
is, are, was, were, am, be, been, being, have, has, had, do, does, did
Redundant prepositions
of, for, to, in, on, at (when meaning stays clear without them)
Pronouns (when context clear)
it, this, that, these, those
Pure intensifiers
very, quite, rather, somewhat, really, extremely
What to Keep (Always)
Category
Reason
All nouns
Core semantic units
All main verbs (not auxiliaries)
Actions carry meaning
All meaningful adjectives
Add semantic signal
Numbers and quantifiers
at least, approximately, more than, 15, many
Uncertainty qualifiers
appears to be, seems, might, what sounded like
Critical prepositions
from, with, without, stuck to — change meaning
Time/frequency words
every Tuesday, weekly, always, never
Names and titles
Dr., Mr., Senator
Technical/domain terms
Never simplify domain language
Negations
not, no, never, without
Preposition Decision Rule
Keep when defining relationship: made from wood (keep from), stuck to wall (keep to)
Remove when purely grammatical: system for processing data → system processing data
Keep in/on/at for location/position: file in /src (keep) vs written in prose (remove)
Compression Examples
Original
Compressed
Removed
"The system was designed to process data efficiently"
"System designed process data efficiently."
The, was, to
"It removes predictable grammar while preserving the unpredictable content"
Record: current line count, rule density (MUST ATTENTION/NEVER/ALWAYS count)
List all READ references → classify as .claude/ (needs inline summary) or docs/ (skip)
Derive the one-sentence Goal (what it achieves + ultimate outcome it must cause) from target task/outcomes/guardrails; cite source lines or mark inferred with confidence
Derive the Summary (2-4 bullets of the key important things + the steps AI must notice) — the read-this-if-nothing-else digest at a different altitude than Workflow/Key Rules; cite source lines or mark inferred with confidence — why: the Summary condenses what matters most, it does not re-list every step/rule
Present but weak → strengthen with Goal, Workflow, Key Rules
Ensure **Goal:** states what the skill achieves AND the ultimate outcome it must cause — a single consolidated line (never split the objective and outcome into two separate lines)
Ensure **Summary:** is present in Quick Summary immediately after the Goal — create if missing, strengthen if weak; it condenses the key important things + the steps AI must notice at a different altitude than Workflow/Key Rules (NEVER a verbatim re-listing of them) — why: the Goal gives the outcome, the Summary gives the read-this-if-nothing-else digest
Protocol summaries appear before Quick Summary
Step 5: Add/Fix Bottom Section
Missing Closing Reminders → add standard section
Pick rules AI most commonly skips (evidence-based, task creation, pattern search)
Echo the same Goal near the start of Closing Reminders: **IMPORTANT MUST ATTENTION Goal:** ...
Remove old "IMPORTANT Task Planning Notes" if superseded by Closing Reminders
Step 6: Verify
Check
Pass Condition
No YAML corruption
Frontmatter intact
No content loss
All rules, code, paths present
Rule density
Post ≥ pre (count MUST ATTENTION/NEVER/ALWAYS)
Goal
Present in Quick Summary and Closing Reminders
Summary
Present in Quick Summary (key things + steps digest)
Line count
Reduced (compression worked)
Formatting
Blank lines between sections, headers correct
READ classification
.claude/ → inline summary, docs/ → skipped
[IMPORTANT] Use TaskCreate to break ALL work into small tasks BEFORE starting.
Output Quality — Token efficiency without sacrificing quality.
No inventories/counts — AI can grep | wc -l. Counts go stale instantly
No directory trees — AI can glob/ls. Use 1-line path conventions
No TOCs — AI reads linearly. TOC wastes tokens
No examples that repeat what rules say — one example only if non-obvious
Lead with answer, not reasoning. Skip filler words and preamble
Sacrifice grammar for concision in reports
Unresolved questions at end, if any
Universal Skill-Building Principles — 10 principles for building AI skills that work across any project type. Source: extracted from review-changes, plan-review, code-review skill rewrites.
Meta-principle: Teach AI to reason, not to recite. Skill's job: structure WHEN and HOW AI applies its existing knowledge — not enumerate every possible concern.
Detect Before Act — Every skill starts with a classification phase. Detect artifact type (plan type, code category, change nature) before applying any logic. Detection drives: sub-agent selection, which dimensions to emphasize, mandatory vs. optional checks.
Anti-pattern: same checklist applied regardless of input type.
Derive, Don't Enumerate — Teach AI HOW to reason about a domain, not WHAT items to tick. Replace "check X, Y, Z" with "understand role → read conventions → derive concerns from first principles → execute with evidence." Fixed checklist = ceiling. Thinking framework = floor.
Test: Can this skill run on a Python/Go project without modification? If not → it's enumerating, not teaching.
Evidence Gates — Every claim, finding, recommendation requires file:line proof or traced call chain. Confidence thresholds: >80% act freely, 60-80% verify first, <60% DO NOT recommend. "Insufficient evidence" is valid output. Speculation is forbidden output.
Fresh Eyes Protocol — Round 1 in main session. Round 2+ with fresh sub-agent (zero memory of Round 1). Main agent reads report but NEVER filters or overrides findings. Max 3 rounds, then escalate to user. Never declare PASS after Round 1 alone.
Why: main agent rationalizes its own mistakes. Zero-memory sub-agent catches what main agent dismissed.
Specialize by Type — Route to specialized sub-agents based on detected artifact type:
Artifact type
Sub-agent
Source code / diffs
code-reviewer
Security-sensitive changes
security-auditor
Performance-critical changes
performance-optimizer
Plans / docs / specs
general-purpose
Embed Protocols Verbatim, Never Reference — Shared protocols MUST be copied inline into every sub-agent prompt — never referenced by file path or tag name. AI compliance drops significantly behind file-read indirection. Maintain canonical source; embed body at every call site.
Search-Based Discovery — Never hardcode project-specific paths, formats, or identifiers. Teach skill to discover them:
"Search for coding-standards, style-guide, contributing" not "read docs/X/code-review-rules.md"
"Find the project's test format near changed files" not "look for TC-{FEATURE}-{NNN} in docs/specs/"
This is what makes a skill work across any project without modification.
Dimensions > Checklists — Structure review/analysis as named thinking dimensions, each with a Think: prompt that forces first-principles reasoning: (1) state dimension's role, (2) derive what could go wrong if weak, (3) apply to artifact with evidence. Produces targeted, evidence-backed findings — not generic "add more detail" suggestions.
Serial attention: When applying a dimension-based framework, NEVER scan all dimensions simultaneously. One focused pass per dimension. AI misses violations when attention is split across concurrent concerns. Pattern: identify applicable dimensions → sequential focused passes → aggregate.
Threshold invariant: 3+ similar patterns in any dimension pass = MANDATORY extraction. 2+ violations of same kind = structural/architectural finding, not individual instance.
Recursive Quality Loop — Fix → Re-review → Fix → Re-review. Each round uses a NEW fresh sub-agent. Continue until PASS or 3 rounds max, then escalate. Never declare success after Round 1 alone. Never reuse a sub-agent across rounds.
Anti-Rationalization Anchors — Explicitly name and embed the evasion patterns AI uses to skip steps in the skill's closing reminders:
Evasion
Rebuttal
"Too simple for this"
Wrong assumptions waste more time. Apply anyway.
"Already searched"
Show file:line evidence. No proof = no search.
"Just do it"
Still need task tracking. Skip depth, never skip tracking.
Primacy-Recency Effect — LLM performance drops 15-47% for middle-context information (Stanford). AI attention peaks at first/last 10% of text. Action: Place the 3 most critical rules in both the first 5 lines AND the last 5 lines of every prompt. Queries at end improve quality by up to 30% (Anthropic).
High-Signal Density — Anthropic: "Identify the smallest collection of high-signal tokens that maximize the probability of the desired outcome."Action: Every line should change AI behavior. If removing a line doesn't change output → cut it. Target ≥8 rules (MUST ATTENTION/NEVER/ALWAYS) per 100 lines.
Context Rot — LLM performance degrades as context length grows — even when all content is relevant. Compression (5-20x) maintains or improves accuracy while saving 70-94% tokens. Action: Compress aggressively. Shorter, denser prompts outperform longer, diluted ones.
Structured > Prose — Tables, bullets, XML/markdown parse faster than paragraphs. Constrained formats reduce error rates vs free-text. Action: Convert narrative to tables/bullets. Use markdown headers for semantic sections.
RCCF Framework — Modern LLMs (2025+) already know how to reason. What they need: Role (personality), Context (grounding), Constraints (guardrails), Format (structure). Constraints and format matter more than verbose instructions.
Checkbox Avoidance — [ ] syntax triggers mechanical compliance — AI ticks boxes without reasoning. Bullet rules force reading and evaluation. Action: Replace - [ ] Check X with - MUST ATTENTION verify X.
Example Economy — 3-5 examples optimal for few-shot; diminishing returns after. Action: 1 best example per pattern. Use BAD→GOOD pairs (2-3 lines each) for anti-patterns.
Deferred Tool Loading — Claude Code delays loading tool definitions when they exceed 10% of context window. Action: Keep injected docs well under 10% of context budget. Docs exceeding ~3,000 lines are too large for injection — split or compress.
Rule Density Verification — Post-optimization rule count (MUST ATTENTION/NEVER/ALWAYS) must be ≥ pre-optimization count. Compression should preserve or increase density, never decrease it. Action: Count before and after every optimization pass.
Affirmative Directives — Models comply with affirmative directives more reliably than prohibitions; a bare "don't X" leaves the correct action unspecified, so the model substitutes an arbitrary alternative. Action: State the action to take, not only the action to avoid. Keep NEVER/forbidden guardrails for hard invariants — but pair each with the right path ("Do X" not just "Don't do Y").
Rationale-Carrying Instructions — A rule shipped with its reason generalizes to edge cases the rule never enumerated and survives compression; a bare imperative gets misapplied or silently dropped. Action: Append a terse — why: … clause to every non-obvious rule. The reason names the failure prevented or outcome wanted — never restates the rule.
Prompt Enhancement Transforms (Base) — Transforms 1-3 are identical across all /prompt-enhance ops (--op=compress|expand|enhance). Transform 4 is per-op (conciseness pass for compress/enhance; structural clarity pass for expand) and stays local to each op branch.
Transform 1: Inline Summaries for READ References
Problem: AI sees MUST ATTENTION READ file.md and skips it.
Solution: Add a 2-3 line summary of key rules BEFORE the read instruction.
Before:
MUST ATTENTION READ .claude/protocols/evidence.md
After:
> **Evidence-Based Reasoning** — Speculation is FORBIDDEN. Every claim requires `file:line` proof.
> Confidence: >95% recommend freely, 80-94% with caveats, <80% DO NOT recommend.
MUST ATTENTION READ .claude/protocols/evidence.md for full details.
Scope rules:
.claude/ protocol files → always add an inline summary (stable, belongs to framework)
docs/project-reference/ files → NO inline summary (project-specific). Add: (Claude may inject this via hooks; Codex must open this file directly using docs-index routing)
Transform 2: Top Summary Section
Required structure (first 20 lines after frontmatter):
> **[IMPORTANT]** TaskCreate instruction...> **Protocol Name** — [inline summary]. MUST ATTENTION READ `path` for details.## Quick Summary**Goal:** [One sentence — what this skill achieves AND the ultimate outcome it must cause]
**Summary:** [2-4 bullets/sentences — the key important things + the steps AI must notice; the read-this-if-nothing-else digest, distinct altitude from the enumerated Workflow/Key Rules below]
**Workflow:**1.**[Step]** — [description]
**Key Rules:**- [Most critical constraint]
Transform 3: Bottom Closing Reminders
Add at the very end of the file:
---
## Closing Reminders**IMPORTANT MUST ATTENTION Goal:** [same goal as Quick Summary]
**IMPORTANT MUST ATTENTION** [echo rule #1 from the top section]
**IMPORTANT MUST ATTENTION** [echo rule #2]
**IMPORTANT MUST ATTENTION** [echo rule #3]
**IMPORTANT MUST ATTENTION** add a final review task to verify work quality
Pick 3-5 rules AI most commonly violates. Bottom section re-anchors attention after the long middle.
Shared Protocol Duplication Policy — Inline protocol content in skills (wrapped in <!-- SYNC:tag -->) is INTENTIONAL duplication. Do NOT extract, deduplicate, or replace with file references. AI compliance drops significantly when protocols are behind file-read indirection. To update: edit .claude/skills/shared/sync-inline-versions.md first, then grep SYNC:protocol-name and update all occurrences.
AI Mistake Prevention — Failure modes to avoid on every task:
Re-read files after context changes. Context compaction, resume, or long-running work can make memory stale; verify current files before acting.
Verify generated content against source evidence. AI hallucinates APIs, names, claims, and document facts. Check the relevant source before documenting or referencing.
Check downstream references before deleting or renaming. Removing an artifact can stale docs, generated mirrors, configs, and callers; map references first.
Trace the full impact chain after edits. Changing a definition can miss derived outputs and consumers. Follow the affected chain before declaring done.
Verify ALL affected outputs, not just the first. One green check is not all green checks; validate every output surface the change can affect.
Assume existing values are intentional — ask WHY before changing. Before changing a constant, limit, flag, wording, or pattern, read nearby context and history.
Surface ambiguity before acting — don't pick silently. Multiple valid interpretations require an explicit question or stated assumption with risk.
Keep shared guidance role-relevant. Universal guidance must help every receiving skill or agent; code-specific obligations belong only in code-specific protocols.
Critical Thinking Mindset — Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence >80% to act.
Anti-hallucination: Never present guess as fact — cite sources for every claim, admit uncertainty freely, self-check output for errors, cross-reference independently, stay skeptical of own confidence — certainty without evidence root of all hallucination.
MUST ATTENTION apply critical + sequential thinking — every claim needs appropriate traced evidence (file:line for repo/code claims; source URL or artifact section for research, product, content, and docs claims); confidence >80% to act, <60% DO NOT recommend. Anti-hallucination: never present guess as fact, admit uncertainty freely, cross-reference independently, stay skeptical of own confidence.
MUST ATTENTION apply AI mistake prevention — verify generated content against evidence, trace downstream references before deleting or renaming, verify all affected outputs, re-read files after context loss, and surface ambiguity before acting.
Closing Reminders
IMPORTANT MUST ATTENTION Goal: Two-phase optimization (caveman compression + attention anchoring) that produces a prompt/skill stating its objective and ultimate outcome (one consolidated Goal) anchored top and bottom, so AI optimizes for the right result.
IMPORTANT MUST ATTENTION Protocols in force (concise digest of the SYNC/shared blocks this skill carries — each is a signpost to its canonical body above):
Output Quality: MUST ATTENTION no inventories/trees/TOCs; lead with answer; sacrifice grammar for concision.
Prompt Enhancement Transforms: MUST ATTENTION inline READ summaries, top Quick-Summary, bottom Closing-Reminders (Transforms 1-3 base).
Shared Protocol Duplication Policy: NEVER extract SYNC duplication to references — edit canonical first; inline is intentional.
AI Mistake Prevention: verify generated content against evidence, trace downstream references, verify all affected outputs, re-read after context loss, surface ambiguity.
Critical Thinking: MUST ATTENTION traced file:line proof per claim; confidence >80% to act; NEVER guess.
IMPORTANT MUST ATTENTION select --op FIRST (default enhance) — compress/enhance apply caveman compression FIRST (Phase 1) before structural enhancement (never skip); expand applies Language Expansion (inverse) instead — why: expand reconstructs, it does not strip
IMPORTANT MUST ATTENTION NEVER compress code blocks, YAML frontmatter, structured tables, or SYNC tags
IMPORTANT MUST ATTENTION read target file completely before any changes
IMPORTANT MUST ATTENTION derive the target's one-sentence Goal (what it achieves + ultimate outcome), then place it in both ## Quick Summary and ## Closing Reminders — why: AI must know the ultimate outcome after enhancement
IMPORTANT MUST ATTENTION enhance derives BOTH the target's Goal AND its Summary (key important things + steps AI must notice) and places both in ## Quick Summary, the Summary at a different altitude than Workflow/Key Rules — why: the Goal tells AI the outcome to optimize for; the Summary tells AI the key things/steps to notice up front
IMPORTANT MUST ATTENTION skill AND sub-agent (.claude/agents/*.md) targets share ONE required structure — Goal + Summary in ## Quick Summary, Goal echoed in ## Closing Reminders — so creator skills (e.g. custom-agent) emit a consistent shape; when enhancing an agent NEVER alter <!-- SYNC:... --> blocks or delete ## Role/## Workflow/## Key Rules/## Output — why: SYNC copies are canonical-synced and divergence fails the build
IMPORTANT MUST ATTENTION read each referenced protocol file to write accurate inline summaries — NEVER guess content
IMPORTANT MUST ATTENTION apply primacy-recency anchoring — 3 critical rules in first 5 AND last 5 lines of every enhanced file
IMPORTANT MUST ATTENTION verify rule density: count MUST ATTENTION/NEVER/ALWAYS before and after — post ≥ pre
IMPORTANT MUST ATTENTION state the action to take, not only what to avoid — pair every NEVER with the right path, and append a terse — why: to each non-obvious rule — why: affirmative directives + carried rationale are followed more reliably and survive compression (principles #10/#11)
IMPORTANT MUST ATTENTION add inline summaries only for .claude/ protocol files, not project-specific docs/ files
IMPORTANT MUST ATTENTION keep all meaningful content — only restructure/compress, NEVER delete rules or code examples
IMPORTANT MUST ATTENTION verify no YAML frontmatter corruption after changes
IMPORTANT MUST ATTENTION cite file:line evidence for every claim (confidence >80% to act). NEVER speculate without proof.
IMPORTANT MUST ATTENTION READ CLAUDE.md before starting
Anti-Rationalization:
Evasion
Rebuttal
"File is short, skip compression"
Apply both phases anyway — density matters at any length
"Already read the file"
Show recorded line count + rule density as proof
"Closing reminders already exist"
Verify they echo top-section rules AND include anti-rationalization table
"Skill file, skip Universal Principles"
NEVER skip — Phase 0 detection is BLOCKING
[TASK-PLANNING] Before acting, analyze task scope and systematically break it into small todo tasks and sub-tasks using TaskCreate.
