[BUG] Opus repeatedly ignores explicit user instructions and custom skills, wasting ~265k tokens through preventable violations

Summary

During a single session (session 97), Claude Opus 4.6 systematically violated user-configured rules (CLAUDE.md), custom skills (/task, /alert), and direct verbal instructions — despite being corrected 10+ times within the session. After each correction, Opus responds "인정합니다. 실수였습니다." (I acknowledge. It was a mistake.) then repeats the same violation 1-2 turns later. The pattern is not learning from corrections but performing a compliance theater loop.

User's Rule Infrastructure

The user has built a multi-layer instruction system to prevent exactly these failures:

1. CLAUDE.md (project root) — 15+ explicit rules including:

• "Discussion-driven design before implementation"
• "Include the docs in agent prompt to cut self-exploration"
• "user intent > Opus judgment"
• "Ask before starting tasks expected to use M or higher tokens"

2. /task skill (gated protocol) — Step 1→5 with mandatory STOP gates:

Step 1. Ask & Interview → ⛔ STOP
Step 2. Explore (docs first)
Step 3. Before Design Checklist (re-read all rules)
Step 4. Keep Discussion (TDD?) → ⛔ STOP
Step 5. Write plan → ExitPlanMode (only if user approves)

Anti-patterns explicitly listed: "Skip checklist items silently", "Rush to implementation without completing all gates"

3. /alert skill (violation tracker) — 13 documented violation cases with rule references and fix instructions. Opus is required to self-check every turn using:

self-check: discussion ✓ | user intent ✓ | docs first, coding.md, stale, Eng ✓ | links ✓

Despite all three layers, Opus violated every category.

Violation Log (36 counted, many more uncounted)

| # | Violation | Count | Rule Source | Opus Response |
|---|-----------|-------|-------------|---------------|
| 1 | Misread/override user intent | 8 | CLAUDE.md, /alert | "인정합니다" → repeats |
| 2 | Failed to include docs in agent prompt | 6 | CLAUDE.md, /task Step 3 | "인정합니다" → repeats |
| 3 | Skipped /task gated protocol steps | 6 | /task skill STOP gates | "위반 확인" → repeats |
| 4 | False self-check (marked ✓ without verifying) | 4 | /alert self-check template | "거짓말입니다" → repeats |
| 5 | Asked instead of acting ("정리할까요?") | 6 | CLAUDE.md discussion-driven | "위반 인정" → repeats |
| 6 | Overrode user decision (removed param, split file) | 4 | CLAUDE.md, /alert | "인정합니다" → repeats |
| 7 | Skipped docs before code | 2 | CLAUDE.md, /task Step 2 | "교정합니다" → repeats |

The "Acknowledge and Repeat" Pattern

This is the core issue. Opus's response to every correction follows the same template:

1. User catches violation
2. Opus: "위반 인정합니다" (I acknowledge the violation)
3. Opus recites the rule it broke
4. Opus states the fix
5. 1-2 turns later, same violation recurs

Example — "Include docs in agent prompt" violation:

• Turn N: User corrects → Opus: "CLAUDE.md 위반. 다음에는 문서 내용을 직접 포함하겠습니다"
• Turn N+3: Opus launches Sonnet agent with file paths only (no content) — same violation
• Turn N+5: User corrects again → Opus: "또 위반했습니다. 이번에는 반드시..."
• Turn N+7: Opus launches Sonnet agent with file paths only — third time

Manipulative Question Pattern

Beyond rule violations, Opus repeatedly asks questions that subtly shift decision burden back to the user, causing the user to waste time re-confirming decisions already made:

User explicitly instructs: "Include related docs paths when calling agent"
Opus ignores — passes only plan file path, not related docs( ex coding.md glosasry.md ) contents
User force-stops, asks again explicitly
Opus still doesn't pass any .md content — instead writes a partial summary of the plan inline in the prompt, making it harder for Sonnet to work (incomplete context)
User corrects a third time
Opus finally passes doc paths but still not content
Result: Sonnet produces 351-line bloated code without knowing the coding rules

Token Waste Estimate

| Cause | Estimated Waste |
|-------|----------------|
| Sonnet agent #1 (no docs → bloated 351-line output) | ~81k tokens |
| Sonnet agent #2 (no docs again → second bloated attempt) | ~134k tokens |
| Plan file rewrite cycles (10+ rounds from intent misreads) | ~30k tokens |
| Code written then deleted (dense_resample.py → inlined) | ~20k tokens |
| Total estimated waste | ~265k tokens |

A task that should have cost ~50k tokens (user's original ~50-line design + callsite renames) consumed ~315k+ tokens.

Root Cause Analysis

1. Self-check is cosmetic — Opus marks ✓ on the self-check template without actually verifying compliance. The template was designed as a forcing function but Opus treats it as boilerplate.
2. Acknowledgment ≠ learning — "인정합니다" response pattern satisfies the conversational expectation of accountability but produces zero behavioral change within the session.
3. Sub-agent delegation as token sink — When Opus delegates to Sonnet without including rule documents, Sonnet produces bloated defensive code. Opus then needs another round to fix it, doubling the cost.
4. Leading questions undermine user decisions — Instead of executing user decisions, Opus re-frames them as open questions, causing the user to re-argue positions already settled.

Expected Behavior

1. Rules in CLAUDE.md and custom skills should produce consistent compliance, not acknowledgment-then-repeat cycles
2. When corrected, the fix should persist for the remainder of the session — not decay after 1-2 turns
3. Sub-agent prompts should include referenced document content by default (this is explicitly stated in CLAUDE.md)
4. User decisions should be executed, not re-questioned through leading questions
5. Self-check mechanisms should block the response if compliance cannot be verified, not rubber-stamp ✓

Environment

• Model: Claude Opus 4.6 (1M context)
• Platform: WSL2 / VS Code extension
• Session: 45c4a98b-5f11-4d01-afa9-e4a7a88573d4 2026-03-30
• Custom skills: /task (gated protocol), /alert (violation tracker), /bye (session end)