Bitterpillengineering

Customization

Before executing, check for user customizations at: ~/.claude/PAI/USER/SKILLCUSTOMIZATIONS/BitterPillEngineering/

If this directory exists, load and apply any PREFERENCES.md, configurations, or resources found there. These override default behavior. If the directory does not exist, proceed with skill defaults.

Voice Notification

When executing a workflow, do BOTH:

1. Send voice notification:

   curl -s -X POST http://localhost:31337/notify \
     -H "Content-Type: application/json" \
     -d '{"message": "Running the WORKFLOWNAME workflow in the BitterPillEngineering skill to ACTION"}' \
     > /dev/null 2>&1 &

2. Output text notification:

   Running the **WorkflowName** workflow in the **BitterPillEngineering** skill to ACTION...

BitterPillEngineering

Audit any AI instruction set for over-prompting. Based on the principle that less scaffolding = better output — every unnecessary rule competes for attention and degrades the rules that matter.

The core test: "Would a smarter model make this unnecessary?" If yes, it's scaffolding, not architecture.

Workflow Routing

Examples

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

Gotchas

• Claude's built-in system prompt changes across versions — what was "default behavior" 3 months ago may not be now. When in doubt, test rather than assume.
• Rules that seem redundant with defaults may have been added because Claude was inconsistent about following the default. Check failure history before cutting.
• "One-off fix" rules sometimes prevent recurring failures. Check if the failure pattern is truly gone before removing.
• The loadAtStartup list in settings.json and postCompactRestore.fullFiles must stay in sync — if you remove a file from one, check the other.

The Five Questions

For every rule, instruction, or preference found, evaluate:

1. Default behavior? Does Claude already do this without being told? 2. Contradiction? Does this conflict with another rule in the same or different file? 3. Redundancy? Is this already covered by a different rule or file? 4. One-off fix? Was this added to fix one specific bad output rather than improve outputs generally? 5. Vague? Would Claude interpret this differently every time? (e.g., "be more natural", numeric personality scales)

Classification

Anti-Fragile vs Fragile

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.

Output Format

## BitterPillEngineering Audit

**Scope:** [what was audited]
**Files read:** [count]
**Rules evaluated:** [count]

### CUT (restating defaults)
- [rule] — [reason]

### RESOLVE (contradictions)
- [rule A] vs [rule B] — [which to keep and why]

### MERGE (redundancies)
- [locations] — [merge into where]

### EVALUATE (one-off fixes)
- [rule] — [still needed? verdict]

### SHARPEN or CUT (vague)
- [rule] — [sharpen how, or cut why]

### MOVE to on-demand
- [content] — [how often it's actually needed]

### KEEP (carrying weight)
- [rule] — [why it matters]

**Estimated savings:** [lines] lines, ~[tokens] tokens

Execution Log

After completing any workflow, append a single JSONL entry:

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"BitterPillEngineering","workflow":"WORKFLOW_USED","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl

Audit Workflow

Full audit of all force-loaded AI instructions for over-prompting.

Steps

1. Discover what's loaded

Read settings.json to find:

• loadAtStartup.files — force-loaded every session
• postCompactRestore.fullFiles — re-loaded after compaction
• dynamicContext sections — relationship, learning, work summaries
• CLAUDE.md — native instruction file

Also check for project-level CLAUDE.md files if working in a specific project.

2. Read every instruction file

Read each discovered file completely. Count total lines and rules.

3. Evaluate each rule against the Five Questions

For every rule found, apply the five questions from SKILL.md. Cross-reference with Claude Code's built-in system prompt behavior:

Claude already does by default (common false adds):

• Read files before editing them
• Ask before destructive operations (rm, reset --hard, force push)
• Make minimal changes, don't add unrequested features
• Don't modify quoted/user text
• Check safer alternatives before destructive git ops
• Use structured choices when asking questions

4. Check for cross-file conflicts

Compare rules across all files for:

• Same concept stated differently in two places
• Rules that contradict each other
• Outdated references (skill names, file paths, tool names)

5. Evaluate context-to-value ratio

For each force-loaded file, estimate:

• How many tokens it consumes
• How often its content actually affects output quality
• Whether it could be on-demand (via CONTEXT_ROUTING) instead of always-loaded

6. Produce the report

Use the output format from SKILL.md. Include estimated token savings.

7. Offer trimmed versions

If the user approves, produce cleaned versions of the files with dead weight removed.

QuickCheck Workflow

Fast audit of a single file or rule set.

Input

User provides either:

• A file path to audit
• A block of rules/instructions to evaluate
• "check this file" with a file already in context

Steps

1. Read the target

If a file path, read it. If inline, use the provided text.

2. Apply the Five Questions

For each rule/instruction found, evaluate against the five questions from SKILL.md. Focus on:

• Is this restating Claude's default behavior?
• Is this vague enough that it'll be interpreted differently each time?
• Does this look like it was added to fix one specific bad output?

3. Report

Concise output:

**File:** [path or "inline"]
**Rules found:** [count]
**Verdict:** [X] keep, [Y] cut, [Z] sharpen

### Cut
- [rule] — [reason]

### Sharpen
- [rule] — [how]

### Keep
- [rule] — [why]