Audits any AI instruction set for over-prompting using the core test — would a smarter model make this rule unnecessary?
AI instruction sets accumulate weight over time. Every bad output gets a new rule. Every edge case gets a new reminder. Every misfire gets a new constraint. Six months in, your CLAUDE.md is thousands of words of scaffolding that competes for context window, contradicts itself, and restates things the model already does by default. The instructions meant to sharpen the AI are now dulling it — because every unnecessary rule crowds out the ones that actually matter.
Apply one core test to every rule: would a smarter model make this unnecessary? If yes, it's scaffolding you're maintaining for no reason. The Five Questions classify each rule — does Claude already do this? Does it contradict another rule? Is it a one-off fix for a past mistake? Is it too vague to act on consistently? Then each rule gets a disposition: CUT if it restates default behavior, RESOLVE if it contradicts another rule, MERGE if it's duplicated elsewhere, EVALUATE if it was a one-off patch, SHARPEN or CUT if it's too vague, MOVE if it's rarely needed and could load on demand. Two workflows: Audit runs the full system reading all force-loaded files from settings.json, evaluating every rule, and returning categorized findings with estimated token savings. QuickCheck targets a single file for a fast keep/cut/sharpen verdict.
What you say to your DA, and what the BitterPillEngineering skill actually does.
The thinking, frameworks, and architecture that distinguish this skill from a generic version of the same task.
Audits any AI instruction set for over-prompting. It runs every rule through Five Questions — does Claude already do this, does it contradict another rule, is it redundant, was it a one-off fix, is it vague — then classifies each as CUT, RESOLVE, MERGE, EVALUATE, SHARPEN, MOVE, or KEEP, with an estimate of the tokens you'd save. Two workflows: Audit (full system) and QuickCheck (single file).
Instruction sets accumulate. Every time the model does something wrong, someone adds a rule, and over months the file fills with instructions that restate default behavior, contradict each other, or fixed one bad output that never recurred. The cost is hidden: every unnecessary rule competes for attention and degrades the rules that actually matter, so a bloated setup produces worse output than a lean one. The hard part is telling load-bearing rules from dead weight — which is what this audit does, rule by rule.
Built on the principle that less scaffolding = better output. The core test for every rule: "Would a smarter model make this unnecessary?" If yes, it's scaffolding, not architecture, and it's a candidate to cut. The Five Questions and the classification table below drive the verdict for each rule.
Example 1: Full system audit
User: "Run BPE on my setup"
→ Invokes Audit workflow
→ Reads all force-loaded files from settings.json
→ Evaluates each rule against the Five Questions
→ Returns categorized report with estimated token savings
Example 2: Check a single file
User: "Quick check this CLAUDE.md"
→ Invokes QuickCheck workflow
→ Reads the target file
→ Returns concise keep/cut/sharpen verdict
Example 3: Post-cleanup validation
User: "I trimmed my rules, check if anything's still redundant"
→ Invokes Audit workflow
→ Compares remaining rules against Claude defaults
→ Flags any surviving dead weight
loadAtStartup list in settings.json and postCompactRestore.fullFiles must stay in sync — if you remove a file from one, check the other.For every rule, instruction, or preference found, evaluate:
| Category | Action |
|---|---|
| Restates default behavior | CUT — the model already does this |
| Contradicts another rule | RESOLVE — pick one, cut the other |
| Duplicates another rule | MERGE — one location, one statement |
| One-off fix for past mistake | EVALUATE — still relevant or already learned? |
| Vague / unquantifiable | SHARPEN — add specific DO/DON'T examples, or cut |
| Loaded but rarely actionable | MOVE to on-demand — load via CONTEXT_ROUTING when needed |
| Specific, actionable, non-default | KEEP — this is what good instructions look like |
Keep (anti-fragile): Verification harnesses, ISC, data pipelines, specific DO/DON'T examples, tool preferences, routing rules.
Cut (fragile): CoT orchestrators, format parsers, retry cascades, numeric personality scales, abstract value statements, process descriptions that aren't followed.
Scope: [what was audited] Files read: [count] Rules evaluated: [count]
Estimated savings: [lines] lines, ~[tokens] tokens ```
Workflows/Audit.md audit setup, full audit, check all rules
Say any of these to your DA and PAI activates the BitterPillEngineering skill automatically:
Or invoke explicitly:
Skill("BitterPillEngineering")The thinkers, books, frameworks, and research this skill is built on. The ideas belong to them — the integration belongs to PAI.
Install PAI on your machine — your DA gets the BitterPillEngineering skill plus 44 others, all hooked into one Life OS.