#llms

4 Takeaways From Anthropic on Context Engineering for Next-Gen LLMs

When testing Claude Opus 5 and Claude Fable 5, Anthropic removed over 80% of Claude Code's system prompt with no measurable loss in coding evaluations.

As AI models evolve, over-constraining them with rigid guardrails creates conflicting instructions and wastes context space. Here are 4 direct shifts in how to approach context engineering:

1. Shift from Hard Rules to Model Judgment Older models required strict rules (e.g., "never write multi-paragraph comments") to prevent bad outputs. Advanced models have better judgment. Replace micromanagement with contextual guidance, like "write code that matches the comment density and style of the surrounding file".

2. Interface Design Over Few-Shot Examples Providing exhaustive examples for tool usage can inadvertently constrain the model's exploration space. Focus instead on well-designed tool interfaces with clear parameter definitions and enumerations that signal intended behavior naturally.

3. Use Progressive Disclosure Over Upfront Context Avoid cramming every spec, workflow, and verification check into a central system prompt or CLAUDE.md file. Use dynamic loading, modular skills, or deferred tool definitions so context is only loaded when a specific task requires it.

4. Eliminate Instruction Duplication Repeated instructions across system prompts and tool descriptions are no longer necessary. Consolidate tool-specific guidance directly within the tool's description rather than repeating it globally.

4 Takeaways From Andrej Karpathy on Software 3.0 and Agentic Engineering

Andrej Karpathy recently said he's never felt more behind as a programmer — a strange thing to hear from someone who helped build modern AI. His point: sometime around December, agentic coding tools crossed a line from "occasionally helpful autocomplete" to "I can't remember the last time I corrected it." Four ideas from the conversation worth sitting with:

1. Software 3.0: Prompting Is the New Programming Software 1.0 was explicit code, 2.0 was learned weights from training data, and 3.0 is prompting an LLM directly — the context window becomes your lever over what's effectively a general-purpose, programmable computer. The clearest example: installing a tool used to mean running a shell script; now it can just be a paragraph of instructions handed to an agent, which reads your environment and figures out the rest.

2. Jagged Intelligence Comes From What's Verifiable Models are superhuman at math and code because labs can throw massive reinforcement learning at anything with a verifiable reward signal — and stay strangely weak outside that footprint. The same model that can refactor a 100,000-line codebase or find zero-day vulnerabilities will confidently tell you to walk 50 meters to a car wash instead of driving. The gap isn't random noise; it's roughly the boundary of what actually got reinforcement-learned.

3. Vibe Coding Raises the Floor; Agentic Engineering Protects the Ceiling Vibe coding means anyone can get software working. Agentic engineering is the harder discipline underneath it — coordinating powerful, inconsistent agents to move fast without dropping the quality bar professional software always required. Karpathy's read: people who are genuinely good at this aren't 10x faster, they're well past it.

4. You Can Outsource Thinking, Not Understanding Agents can execute almost anything now, but someone still has to know what's worth building and why — write the spec, catch the agent's weirder mistakes (like matching payment accounts by email instead of a real user ID), and hold the taste and judgment the model doesn't have. That's the actual bottleneck now, and it doesn't disappear just because the code got faster to produce.