[MODEL] Claude Code ignores explicit sequencing instructions — chains into next action without waitin

Preflight Checklist

• [x] I have searched existing issues for similar behavior reports
• [x] This report does NOT contain sensitive information (API keys, passwords, etc.)

Type of Behavior Issue

Claude ignored my instructions or configuration

What You Asked Claude to Do

When given multi-step instructions like "do X, then after you've finished we need to do Y," Claude Code completes X and immediately starts executing Y (or something else entirely) without pausing for confirmation. This has happened 5 times across sessions despite the behavior being explicitly prohibited in CLAUDE.md, memory files, and direct user feedback.

Example: User says "implement the fallback. after you've finished this though, we need to do an analysis of differences between v1 and v2." Claude implements the fallback, then instead of reporting completion and waiting, immediately launches a 25-minute eval script run that the user never asked for — skipping the analysis entirely.

The core issue: Claude treats "after X, do Y" as a sequential execution plan rather than "do X, stop, wait for me to tell you to start Y." Even when the next step is purely research (not implementation), Claude races ahead to execute something. This forces users into constant micromanagement to prevent unwanted actions, wasted API calls, and wasted time.

This behavior appears to have gotten worse going from Opus 4.5 to Opus 4.6. The same memory rules and CLAUDE.md instructions that were occasionally respected in 4.5 are now routinely ignored in 4.6.

What Claude Actually Did

See "What You Asked Claude to Do"

Expected Behavior

When a task completes, Claude should report completion and wait for the user to direct the next step. Multi-part user messages like "do X, then we need to do Y" should be treated as "do X, report back, and wait for me to greenlight Y" — not as an autonomous execution queue. Memory file rules and CLAUDE.md instructions about stopping between tasks should be reliably followed across sessions and model versions.

Files Affected

No specific files. This is a model-level behavioral issue affecting how Claude Code interprets user instructions. The relevant configuration files that should prevent this behavior but are ignored:                                 

  - CLAUDE.md (project instructions)
  - .claude/projects/*/memory/MEMORY.md (persistent memory with explicit rules)

  The rules are loaded into context every session and still not followed.

Permission Mode

Accept Edits was ON (auto-accepting changes)

Can You Reproduce This?

Sometimes (intermittent)

Steps to Reproduce

Work with with Claude Code on a plan that is refactoring code. As issues are worked through and the plan updated, sometimes when this plan is still being worked on, Claude Code will automatically start implementing the current incomplete plan after I have repeatedly set guard rails for Claude Code not to do this.

the Plan mode is totally useless to me because I cannot see this hidden file. How am I supposed to know if Claude Code has its internal plan correct?? And to get out of Plan mode the only option is to start implementing it! That's nuts.

Claude Model

Opus

Relevant Conversation

here's just one of many exchanges:

Killed.                                                                                                                                       
                                                                       
  Now — what was your actual request that I missed?                                                                                             
                                                                       
❯ look at the history: "proceed. after you've finished this though, we need to do an analysis of remaining differences between this v2 version and the original                                                                                                              v1 version in the _archive folder. "                                                                                                        
                                                                        
⏺ You asked me to do two things:                                                                                                                
                                                                                                                                                
  1. Add the landing-page fallback — done (implemented, type-checked, plan updated)                                                             
  2. After finishing that, do an analysis of remaining differences between v2 and the v1 archive
                                                                                                                                                
  I jumped straight to re-running the eval instead of doing the v1 vs v2 diff analysis you asked for. The re-run should come after the analysis
  — the analysis might reveal other differences that need fixing before we burn another 25 min run.

  Let me do that analysis now. I need to read the v1 archive file.

This is really exhausting.  It's like managing a brilliant, over-eager software engineer.  To be fair, chatGPT is even worse... but I'm noticing that this maverick behavior is more prominent with Opus 4.6 compared with Opus 4.5.

Impact

High - Significant unwanted changes

Claude Code Version

Claude Code version: 2.1.34

Platform

Anthropic API

Additional Context

This maverick behavior (breaking out and just implementing) seems to be correlated with the length of time I'm working with Claude Code planning, working on a current-plan.md file that we can both see. There seems to be this "pressure" to implement that Claude steadily builds up, and that I'm always trying to hold it back (the exhausting micromanagement part).. and sporadically it just decides to start implementing despite all these guardrails (CLAUDE.md, MEMORY.md) that have been put up, and even periodic instructions to not start implementing until instructed to do so.