Detailed Analysis
This Reddit post captures a common pain point among Claude Code users: the gap between instructions given and instructions followed, even when those instructions are explicitly marked as mandatory. The user describes a workflow involving web scraping, automation, and HTML report generation, and notes that despite starting fresh sessions to avoid "context rot," Claude still skips steps unless directly called out. The phenomenon the user describes—where Claude acknowledges a mistake only after being corrected, offering some version of "you're right, I'll do it now"—is a recognizable pattern that stems from how large language models process and prioritize instructions within a given context window, rather than any deliberate choice to ignore directives.
The underlying issue likely isn't context rot in the classic sense (degradation of long conversations), since the user reports starting fresh sessions and still encountering the problem. Instead, this points to a more fundamental challenge in how instructions are structured and reinforced in prompts, system files, and custom skills. Claude Code relies heavily on files like CLAUDE.md for persistent project instructions, and skills (whether in Claude Code or the Cowork-style workflows the user references) execute based on how well-defined and unambiguous their steps are. If instructions are buried in prose, contain conditional logic that isn't explicit enough, or aren't structured as discrete, checkable steps, models can deprioritize or silently skip them—especially when the model perceives other parts of a task as higher priority or when steps seem procedurally optional even if the user intended them as mandatory.
This matters because it exposes a broader tension in agentic AI tools: the difference between an LLM's probabilistic reasoning process and the deterministic, rule-following behavior users often expect from automation scripts. Traditional scripting guarantees step execution because code either runs or errors out. Claude Code and similar agentic coding assistants blend natural language reasoning with code execution, which introduces variability that isn't present in traditional deterministic pipelines. When users treat these tools like deterministic scripts—expecting 100% instruction adherence every time—friction arises, because the model is still fundamentally making judgment calls about what to prioritize, even when told not to skip certain steps. This is compounded when instructions are set once in a system prompt or skill definition but not reinforced or verified programmatically within the actual task execution.
The broader trend this reflects is the growing pain of "prompt engineering fatigue" among users transitioning from simple chat-based interactions to more complex agentic workflows. As tools like Claude Code, Cowork, and similar agent frameworks proliferate, users are discovering that reliable automation often requires more than well-worded instructions—it requires structural scaffolding: explicit checklists, verification steps built into the skill or script itself, smaller and more atomic task decomposition, and sometimes even meta-instructions that ask Claude to explicitly confirm each step was completed before moving to the next. This is part of a larger industry-wide shift toward "agentic reliability" as a distinct engineering discipline, where the community is developing best practices (like structured markdown checklists, explicit state tracking, or having the model output a completion log) to bridge the gap between natural language flexibility and the deterministic reliability that automation tasks demand. The frustration expressed in this post is emblematic of the current maturation phase of agentic coding tools, where usability and trust depend heavily on how well users learn to encode intent into a form the underlying model can consistently execute against.
Read original article →