Claude Code Just Changed Forever (6 NEW Rules by Anthropic Engineers)

Overview

The video breaks down an Anthropic engineer’s article on “the new rules of context engineering for Claude 5 models” and explains how these changes affect Claude Code (agentic programming/workspace setup). The goal is to make Claude-based systems faster, cheaper (lower token use), and more capable.

Source & framing

• The speaker cites Tariq (Anthropic lead engineer) as the author of a viral X article: “the new rules of context engineering for Claude 5 models.”
• The video translates that long article into six “new rules/shifts” and demonstrates how to apply them in real Claude Code setups.

---

Core technological concept: Context Engineering

• The prompt you type is only a small portion of what the model sees.
• Most output quality depends on how your overall “context package” is organized, including:
  • connected tools
  • stored artifacts
  • routines
  • other supporting material

ARMS framework for agent context

The speaker uses an ARMS framework to structure agent context:

• Applications / tools connected via MCPs, APIs, and CLIs
• Routines (scheduled tasks/cron-like jobs)
• Memory (generated reports/artifacts over time)
• Skills (SOPs/processes invoked via skill commands)

---

Evidence of model capability improvements

• Anthropic reportedly removed 80%+ of system prompt content for models like Opus 5 / Fable 5 with no measurable loss on coding evaluations.
• Benchmark reference: artificialanalysis.ai, where top models are around 60/100 intelligence (vs ~31/100 previously). Implication: models are better, so they may require less over-specification.

---

The “6 new rules/shifts” explained (with actionable implications)

1) Let Claude use judgment (less rigid instructions)

• Earlier advice: enforce tight rules (e.g., avoid comments, avoid multi-paragraph docstrings).
• New advice: too many constraints can hurt with smarter models.
• Example change: replace many formatting restrictions with a simpler style instruction, such as:

  “write code that reads like the surrounding code, match comment density, naming, and idiom.”

Product/setup takeaway: shorten or relax system-level constraints; trust the model more for style/format decisions.

---

2) Prefer design interfaces over giving lots of examples

• Earlier advice: provide examples to teach tool usage/style.
• New advice: examples can constrain exploration and reduce differentiation.
• Instead, encode behavior through a design system Claude follows via rules.

Speaker’s implementation example:

• A skill like /robo (brand/design interface) references brandbook.html that defines:
  • color palettes
  • fonts/voice guidance
  • a specific visual style (e.g., dot-matrix look)
• Claude then generates consistent branded outputs without being boxed into copied examples.

Takeaway: encode style in an interface/brandbook, not in many static examples.

---

3) Use progressive disclosure (don’t dump all context up front)

• Earlier approach: put everything in one big context file (e.g., a thick claw.md).
• New approach: act like a router that loads the right subset of files only when needed.

Token/cost implication

• A thick claw.md consumes tokens immediately at session start.
• A thin “router” claw.md reduces token waste and can improve practical efficiency.

Implementation pattern

• claw.md points to a tree of folders/files (“departments” like content/community/product/personal).
• Add sub-routers (e.g., content.md router) to further narrow retrieval.

---

4) Use simpler tool descriptions

• Earlier: repeat instructions in multiple places (system prompt and tool descriptions).
• New: with stronger models, you can reduce duplication and keep tool descriptions simpler.
• Also connected to reducing context rot: newer models supposedly follow recent instructions better, decreasing the need to restate everything.

Takeaway: remove redundant tool documentation and shorten tool specs.

---

5) Embrace automatic memory

• Previously: ask users to manually store memory (e.g., via hotkeys writing to claw.md).
• New: Claude Code can automatically save relevant memories during work.

Speaker’s example

• A /{slash} calibrate skill that:
  • reviews the session
  • updates skills
  • updates claw.md routing
  • updates memory files
  • updates workflow/prompt packs

Takeaway: don’t rely only on manual memory dumps; automate capture/update when appropriate.

---

6) Move from simple specs to richer references (HTML over-only-markdown when useful)

• Earlier: markdown was the main way to create plans/assets/specs.
• New: models can leverage more complex references.
• Preferred richer artifacts: HTML for visual/structured presentation (e.g., brand books with palettes, typography, styling).

Why it matters

• Humans can review visual references more easily than long markdown.
• Claude can parse richer structured documents better than purely text-only artifacts.

Speaker’s example

• Uses an HTML/infographic-like approach to explain the new rules visually—faster than reading a “wall of text.”

---

How to apply these changes: “Doctor” skills inside Claude Code

Built-in: {slash} doctor

After updating Claude Code, invoke {slash} doctor to:

1. check for broken/duplicate installs and path issues
2. find dead weight (unused skills/MCP servers, bloated cloud.md)
3. detect slow hooks
4. summarize findings and apply/offer fixes
5. report version status (the speaker noted being behind)

Custom/free add-on: {slash} doctor plus

The speaker created a more thorough skill that:

• runs the core {slash} doctor checks
• additionally checks the six shifts/rules
• flags specific skills/artifacts to optimize

Example reported issue: a research skill was “too thick” (e.g., ~2,090 lines) and should be turned into a router instead of dumping all context.

Automation idea: set a routine (e.g., monthly) to run “doctor plus” checkups.

---

Main speakers / sources

• Main speaker: Jay (video host)
• Primary external source: Tariq (Anthropic engineer; author of “new rules of context engineering for Claude 5 models”)
• Benchmark source referenced: ArtificialAnalysis (artificialanalysis.ai)
• Community/product references used as examples: Robo Nuggets community; Claude Code; MCPs/APIs/CLIs; skills like /robo and /calibrate; doctor skills (/doctor, /doctor plus)