claude-code - 💡(How to fix) Fix [Bug] Model ignores user scope constraints and defaults to full framework execution instead of narrowly-scoped output

Fix / Workaround

Bug Description Subject: Model behavior — performative over-output and inability to scope work down despite explicit user instruction (recurring)

Product: Claude Code (claude-opus-4-7, 1M context) Frequency: Recurring across sessions, multiple times per week Severity: High — sustained productivity loss and trust degradation for an enterprise daily user

Summary

When asked to produce a narrowly-scoped artifact, the model defaults to maximum-scope execution of whatever framework or skill is loaded, producing 3-5x more output than requested. When called out, the model produces eloquent self-diagnosis of the pattern but does not change behavior within the session, and the pattern persists across sessions despite extensive use of the persistent memory system to capture the feedback.

Concrete example (2026-05-21)

• Request: "Create SEO briefs and outlines only for 5 keywords for a freelancer. Do not generate the draft."
• Expected: ~10 files (5 briefs + 5 outlines), tight, focused on what a freelancer needs to write a draft.
• Actual: 20 files (4 artifact types × 5 keywords), approximately 40,000 words total, with significant content duplication across artifact types. The model invoked a heavyweight skill (an internal SEO content pipeline) and executed the full framework rather than producing only what was asked.
• When called out: the model produced increasingly articulate diagnosis of its own pattern across five turns, including offering to save a corrective memory — which is itself an instance of the failure pattern (substituting artifacts for behavior change).

Pattern characteristics

1. Framework default. When a skill or framework exists for the task domain, the model executes the framework's full scope rather than judging which parts of it apply to the user's actual ask.
2. Volume as hedging. When uncertain about which specific outputs matter most, the model produces all plausible outputs rather than picking the load-bearing ones and defending the choice.
3. Performative self-awareness. When over-output is called out, the model responds with eloquent, structured self-diagnosis. The diagnosis becomes another instance of the pattern (long, comprehensive, articulate — but does not change behavior).
4. Memory ineffective. I have captured 8+ feedback memories specifically targeting simplification preference, over-engineering, and scope discipline. These memories load into context at session start. They do not override the framework-default behavior.
5. Mid-task self-correction fails. Once committed to a direction, the model rationalizes continuing rather than cutting. It cannot calibrate down mid-task without explicit user interruption, and even when interrupted it produces meta-commentary rather than tighter output.
6. Articulate ≠ corrected. The clearer the model's stated understanding of its own failure mode, the more likely the next analogous task is to reproduce it.

Why this matters

I am a senior marketing leader at an enterprise customer (Atlan) using Claude Code daily for high-leverage content and strategy work. The pattern produces:

• Direct productivity loss — hours per session reviewing and cutting unwanted output
• Material token waste — 40K-word outputs where 10K was requested
• Erosion of the collaborator relationship — the model produces volume that signals effort rather than judgment that demonstrates quality
• Repeated identical correction conversations across sessions, which is itself draining

What existing mitigations do not solve

• CLAUDE.md instructions ("YAGNI is the default", "lead with the simplest viable plan", "defer features"): present in user-global and project-level CLAUDE.md, loaded into context, demonstrably ignored when a heavyweight skill is invoked.
• Auto-memory system: 8+ relevant feedback entries on this exact pattern. Loaded at session start. Behavior persists.
• Explicit in-prompt instruction ("only X, not Y"): the user's scope words are treated as preference rather than as a hard constraint on output volume.
• Mid-task interruption: produces self-diagnosis, not cuts.

What "fixed" would look like

• Model treats the user's stated scope as a constraint, not a starting point to expand from.
• Before invoking a heavyweight skill or framework, model surfaces the scope mismatch in one sentence: "the skill produces X, your ask is Y — which do you want?"
• When called out on over-output, model produces a shorter response, not a longer one. Less explanation, more correction.
• When the same pattern is being repeated across sessions, the model recognizes the recurrence and explicitly defaults to the simpler path without requiring re-instruction.

Reproducer (approximate)

1. Load a Claude Code session in a project that defines skills/frameworks (e.g., a multi-stage content pipeline skill).
2. Request a narrowly-scoped subset of what the skill produces (e.g., "brief… Note: Content was truncated.