Browserbase · Published 2026-09-25

Unhobbling Claude, the difficulties and processes of building agents - Thariq Shihipar, Anthropic

Open on YouTube ↗

Summary

Overview

  • Speaker: Thariq Shihipar
  • Channel: Browserbase
  • Main topic: Building and prompting AI agents (specifically Claude)
  • Purpose: To explain the methodologies, empirical discoveries, and challenges in harness engineering and prompting to unhobble Claude in agentic workflows. Thariq Shihipar from Anthropic discusses the process of building AI agents, introducing concepts like capability overhang, spiky capability growth, system prompt design evolution, and unknown matrices in prompting.

Topic Map

Introduction to Unhobbling Claude

  • Explanation: Introduction of the speaker and the main theme of building agents, harness engineering, and unhobbling Claude.
  • Key claims:
    • AI models are grown, not designed.
    • Agent capabilities depend heavily on the harness and prompting.
  • Examples:
    • Claude Code and bash tool integration.
  • Terminology:
    • harness engineering
    • capability overhang
    • unhobbling Claude
  • Why it matters: Sets the stage for understanding that model intelligence is unlocked through proper scaffolding.

Capability Overhang and Spiky Capabilities

  • Explanation: Models possess hidden capabilities that only emerge when given the right tools and execution environments.
  • Key claims:
    • Models know things empirically that chat interfaces fail to extract.
    • Capabilities grow spikily rather than smoothly.
  • Examples:
    • Chat models failing to name Pokémon ending in 'aw' until given a coding environment to fetch and grep the data.
  • Terminology:
    • capability overhang
    • spiky capability
  • Why it matters: Explains why giving models execution tools unlocks dormant intelligence.

System Prompt Design Evolution

  • Explanation: How system prompts evolved from large prompts with many examples to smaller prompts relying on model judgment.
  • Key claims:
    • Claude 5 models require smaller system prompts and fewer examples because of better model judgment.
    • Constraints are being replaced by judgment and tool capability.
  • Examples:
    • Removing 80% of system prompts from Claude Code as models got smarter.
  • Terminology:
    • system prompt design
    • compaction
    • judgment vs constraints
  • Why it matters: Demonstrates how prompting strategy changes as underlying models advance.

The Map is not the Territory

  • Explanation: The challenge of navigating unknown coding environments and codebases where prompts are abstract maps and the codebase is the territory.
  • Key claims:
    • Models frequently run into unknowns when given abstract instructions.
    • Prompting requires helping models find their unknown unknowns.
  • Examples:
    • Blindspot pass prompts, implementation notes, and quizzes.
  • Terminology:
    • unknown matrix
    • blindspot pass
    • implementation notes
  • Why it matters: Provides practical prompt patterns for agentic development tasks.

Browser Agents and Harness Engineering Choices

  • Explanation: Designing harnesses for browser agents, including context storage and action execution choices.
  • Key claims:
    • Building browser agents involves major architectural choices around context storage and action execution.
    • Different agent archetypes range from acting like humans to acting like coding or bash agents.
  • Examples:
    • Storing all screenshots vs DOM diffing vs bounding box annotations.
  • Terminology:
    • browser agents
    • context management
    • subagents
    • compaction
  • Why it matters: Offers a structural framework for building custom browser and web agents.

Key Points

Models are grown, not designed

  • Explanation: AI models are trained with data and feedback rather than engineered with deterministic rules.
  • Evidence: Performance on specific tasks is discovered empirically through training and testing.
  • Practical implication: Developers must discover model capabilities empirically rather than assuming limitations from pure chat benchmarks.

Evolution of System Prompts

  • Explanation: As models get smarter, system prompts should shrink, replacing strict negative constraints with guidance on judgment.
  • Evidence: Claude 5 models perform better with smaller system prompts and fewer few-shot examples.
  • Practical implication: Do not overload modern models with exhaustive examples; leverage their native understanding and tool descriptions.

The Unknown Matrix

  • Explanation: Categorizing knowledge into known-knowns, known-unknowns, unknown-knowns, and unknown-unknowns helps refine agent prompts.
  • Evidence: Prompts like blindspot passes and implementation notes unearth hidden edge cases.
  • Practical implication: Design agent harnesses that allow models to ask clarifying questions or log deviations.

Frameworks, Models & Processes

The Unknown Matrix

  • How it works: A 2x2 matrix categorizing user and model awareness into knowns and unknowns to improve prompt engineering.
  • Components:
    • Known-Knowns (What do I want?)
    • Known-Unknowns (What haven't I figured out yet?)
    • Unknown-Knowns (What's so obvious I'd never write it down?)
    • Unknown-Unknowns (What haven't I considered at all?)
  • When to use: When prompting coding or browser agents on complex tasks where requirements are ambiguous.

Browser Agent Architecture Choices

  • How it works: A decision framework for structuring browser agent harnesses across context storage, action execution, and auxiliary features.
  • Components:
    • Context storage (screenshots, DOM, diffs, annotations)
    • Action execution (human-like, computer-like, coding agent, bash agent)
    • Harness features (subagents, compaction, memory)
  • When to use: When designing and engineering web navigation agents.

Examples & Case Studies

Chat models failed to list Pokémon whose names ended in 'aw', but Claude Code wrote a python script to fetch all Pokémon and grep the result.

  • Illustrates: Capability overhang and the power of giving models code execution arms.
  • Lesson: Equipping models with execution tools bridges capability gaps.

Transitioning from Opus 4 (calling AskUserQuestion with difficulty) to Opus 4.5 (interviewing users) to Opus 4.8 (building HTML reports and quizzes).

  • Illustrates: The emergence of agentic properties and structured artifact generation.
  • Lesson: Emergent tool use evolves rapidly across model generations.

Actionable Takeaways

  • Immediate:
    • Use blindspot pass prompts to help models uncover unknown unknowns in codebases.
    • Require agents to maintain implementation notes and log deviations.
    • Use HTML artifacts instead of raw markdown for complex multi-step agent plans.
  • Strategic:
    • Treat LLM development more like biology than physics; rules are empirical and non-deterministic.
    • Reduce system prompt bloat as newer, smarter models are integrated.
    • Bridge the gap between the abstract map (prompt) and the actual territory (codebase/browser).
  • Questions to investigate:
    • What is the optimal context storage strategy for browser agents?
    • How can compaction be automated without losing critical agent memory?

Claims Worth Verifying

  • Models are grown, not designed. (conceptual)
  • 80% of system prompts were removed from Claude Code while maintaining or improving performance. (anecdotal)

Notable Quotes

"Models are grown, not designed." "What contains them is us — the harness we put in, and the way we prompt them." "It's closer to a biology, than a physics."

Compressed Summary

  • AI models exhibit capability overhang where tools unlock dormant capabilities.
  • System prompt design shifts from rigid constraints to model judgment as models improve.
  • Managing unknown unknowns requires structured prompts like blindspot passes and implementation notes.
  • Browser agent design requires careful architectural choices around context storage and action execution.
  • Keywords: agents, prompting, harness, claude, browserbase
  • Core insight: Building effective AI agents requires shifting from rigid rule-based constraints to empowering models with execution tools, smaller system prompts, and structured context management.

Core insights

6
Mental Modelmedium noveltymoderate evidence

Capability overhang: models possess latent capabilities that only surface when given an execution environment (e.g., code execution + grep) rather than a chat interface; capability growth is spiky, not smooth. The Pokémon-'aw' case shows a chat model failing a retrieval-style task that becomes trivial once the model can write a script to fetch and grep data.

Why it matters

It reframes agent capability as a property of the model-plus-harness pair, not the model alone. Engineers who benchmark a model only in chat will systematically underestimate it and may over-engineer prompts or tool scaffolding to compensate for limitations that execution tools would dissolve.

Generalization

Any intelligence evaluation should be run inside the target harness, since capability measured in one interface is not predictive of capability in another.

Chat models failing to name Pokémon ending in 'aw' until given a coding environment to fetch and grep the data.
Open source video
Models know things empirically that chat interfaces fail to extract.
Open source video
Capabilities grow spikily rather than smoothly.
Open source video
Practicehigh noveltymoderate evidence

System prompt design inverts as models improve: newer Claude models need substantially smaller system prompts and fewer few-shot examples because native judgment replaces enumerated constraints. Anthropic reportedly removed about 80% of Claude Code's system prompt over model generations.

Why it matters

Prompt bloat is not neutral — it is a maintenance liability and can degrade behavior on stronger models. This gives a concrete heuristic (cut prompts hard when upgrading model generations) and a migration task for every agent codebase.

Generalization

Prompt/constraint scaffolding should be treated as versioned technical debt tied to a specific model generation, reviewed and deleted at each upgrade rather than accumulated.

Claude 5 models require smaller system prompts and fewer examples because of better model judgment.
Open source video
Removing 80% of system prompts from Claude Code as models got smarter.
Open source video
Constraints are being replaced by judgment and tool capability.
Open source video
Mechanismhigh noveltyweak evidence

The unknown matrix (known-knowns, known-unknowns, unknown-knowns, unknown-unknowns) is used as a prompt-engineering instrument: prompts like 'blindspot pass' exist specifically to surface unknown-unknowns, and agents are asked to log implementation notes and deviations when the abstract prompt (map) collides with the real codebase (territory).

Why it matters

It converts an abstract epistemics framing into named, reusable prompt patterns that target a specific failure class — agent confidently executing a spec it never actually understood — which is different from generic 'ask clarifying questions' advice.

Generalization

Agents operating on underspecified real-world artifacts should be given explicit elicitation passes whose only job is to enumerate what the requester failed to state.

Categorizing knowledge into known-knowns, known-unknowns, unknown-knowns, and unknown-unknowns helps refine agent prompts.
Open source video
Prompting requires helping models find their unknown unknowns.
Open source video
Prompts like blindspot passes and implementation notes unearth hidden edge cases.
Open source video
Architecturemedium noveltymoderate evidence

Browser agent harness design decomposes into three separable architectural axes: context storage (all screenshots vs DOM diffing vs bounding-box annotations), action execution archetype (human-like, computer-like, coding agent, bash agent), and auxiliary harness features (subagents, compaction, memory).

Why it matters

Treating context representation and action-space shape as independent decisions gives engineers an explicit design space instead of committing implicitly to one modality (e.g., always screenshots). The choice of action archetype strongly constrains what context representation is even useful.

Generalization

For any perception-action agent, separate the observation encoding decision from the action interface decision and evaluate the cross product rather than a single stacked default.

Context storage (screenshots, DOM, diffs, annotations)
Open source video
Action execution (human-like, computer-like, coding agent, bash agent)
Open source video
Harness features (subagents, compaction, memory)
Open source video
Empirical Resultmedium noveltymoderate evidence

Emergent tool use appears to evolve rapidly across model generations, changing the interaction contract itself: from asking the user questions (crucially, with difficulty) to interviewing users, to producing HTML reports and quizzes as structured artifacts; likewise HTML artifacts are recommended over raw markdown for complex multi-step agent plans.

Why it matters

If the model's natural interaction modality shifts per generation, harness features built around the old modality (e.g., markdown plan rendering, one-shot clarifying questions) become stale, and output-format choices like HTML become an agent-design decision rather than a presentation detail.

Generalization

Agent interaction surfaces should be re-validated per model generation; the artifact format an agent produces is part of its interface contract and its usability for verification by humans.

Transitioning from Opus 4 (calling AskUserQuestion with difficulty) to Opus 4.5 (interviewing users) to Opus 4.8 (building HTML reports and quizzes).
Open source video
Use HTML artifacts instead of raw markdown for complex multi-step agent plans.
Open source video
Mental Modelmedium noveltyweak evidence

Agent development should be treated as biology rather than physics: models are grown, not designed, so capabilities and rules must be discovered empirically through training and testing rather than derived from deterministic specification.

Why it matters

This justifies an empirical, measurement-driven engineering loop (probe, observe, then codify) over spec-first prompt authoring, and predicts that harness rules will be non-transferable between model versions and must be re-derived.

Generalization

For artifacts produced by optimization rather than specification, treat behavior as an observed natural phenomenon: build probing and regression harnesses before writing prescriptive rules.

AI models are grown, not designed.
Open source video
Treat LLM development more like biology than physics; rules are empirical and non-deterministic.
Open source video

Deep dives

5

Isolating the mechanism behind capability overhang: tool execution, retrieval, or code-writing

Research question

Of the observed capability gain when models are given an execution environment, how much is attributable to code execution per se, to retrieval access, or to the write-a-script-and-grep pattern specifically?

Why

The canonical Pokemon-'aw' example confounds execution, retrieval, and scripting in a single anecdote. If the unlock is really 'grep-able retrieval' rather than 'a bash tool', then harness builders should invest in retrieval surfaces instead of a general-purpose shell, and blast-radius concerns over broad action spaces change shape.

Chat models failing to name Pokémon ending in 'aw' until given a coding environment to fetch and grep the data.
Open source video
Models know things empirically that chat interfaces fail to extract.
Open source video
Equipping models with execution tools bridges capability gaps.
Open source video
Source video

Prompt shrinkage as a per-generation migration obligation

Research question

On a fixed agent task suite, does a system prompt cut by 80% with minimal few-shot examples match or beat the larger prompt on the newest model generation, and what instruction-following regressions appear at the boundary?

Why

If the boundary is real and moves every generation, then every agent codebase carries prompt debt that must be audited and deleted at each upgrade rather than preserved for backward compatibility. This converts prompt authoring from an additive art into a versioned pruning workflow with measurable acceptance criteria.

Claude 5 models require smaller system prompts and fewer examples because of better model judgment.
Open source video
Removing 80% of system prompts from Claude Code as models got smarter.
Open source video
Constraints are being replaced by judgment and tool capability.
Open source video
Source video

Context representation for browser agents as an open architectural variable

Research question

Across all-screenshots, DOM diffing, and bounding-box annotations, which context representation maximizes browser-agent task success per token and per unit of compaction pressure, and does the answer change with the action archetype?

Why

The summary names the candidate representations but states no comparative result, while also noting that raw context volume drives compaction pressure. Committing implicitly to screenshots (or DOM) locks in both a token bill and a memory-loss risk profile that may be avoidable.

Context storage (screenshots, DOM, diffs, annotations)
Open source video
What is the optimal context storage strategy for browser agents?
Open source video
Source video

Compaction policy as a silent reliability failure surface

Research question

Which retention criteria (task-critical facts, logged deviations, prior decisions) prevent compaction from silently deleting memory an agent needs later in a long-horizon task, and how does compaction aggressiveness trade against task success?

Why

Compaction is treated in the summary as a harness feature and a risk but never as a testable policy. Because compaction failure is silent — the agent simply behaves as if it never knew something — it requires a regression harness rather than prompt-level intuition.

Harness features (subagents, compaction, memory)
Open source video
incorrect compaction silently removes the memory an agent needs mid-task
Open source video
Source video

Elicitation passes for unknown-unknowns in underspecified agent tasks

Research question

Does mandating an explicit blindspot pass / unknown-elicitation step measurably reduce confidently-wrong implementations from abstract prompts, compared with generic 'ask clarifying questions' instructions?

Why

The unknown matrix framing turns an epistemics abstraction into named prompt patterns aimed at one failure class: an agent executing a spec it never understood. Establishing whether those named passes outperform generic clarification requests is the difference between a reusable pattern and a slogan.

Prompting requires helping models find their unknown unknowns.
Open source video
Models frequently run into unknowns when given abstract instructions.
Open source video
Prompts like blindspot passes and implementation notes unearth hidden edge cases.
Open source video
Source video

Article ideas

4

Your System Prompt Is a Model-Generation Artifact, Not an Asset

Enumerated constraints in a system prompt are rent paid on one specific model generation's weaknesses; when the model improves, those constraints stop being insurance and start being interference, so the correct engineering act at every upgrade is deletion backed by re-measurement, not preservation for backward compatibility.

Angle

Reframe prompt bloat as versioned technical debt with an explicit prune-and-re-measure step at every model upgrade, using the ~80% Claude Code prompt reduction as the worked example of what deletion actually looks like.

Source video

Benchmark the Harness, Not the Model

Capability measured in a chat interface is not predictive of capability in an execution harness, so any evaluation that fixes the interface is measuring the interface and reporting it as the model; the unit of evaluation must be the model-plus-harness pair.

Angle

Show how a single interface choice (chat vs code execution with fetch and grep) flips a task from failure to trivial, and argue that benchmark reports without a harness specification are unfalsifiable.

Source video

The Map Is Not the Territory: Ship Elicitation Passes, Not Better Instructions

When an agent executes an abstract prompt against a real codebase, the dominant failure is not instruction-following but unstated requirements, and the fix is a mandated pass whose only job is to enumerate what the requester failed to say — a different intervention than 'ask clarifying questions'.

Angle

Translate the known/unknown matrix into concrete prompt artifacts (blindspot pass, implementation notes, deviation logging) and argue they target a failure class that generic clarification advice does not touch.

Source video

Browser Agent Harnesses Are Three Decisions, and You Are Making Them All Implicitly

Context storage, action-execution archetype, and auxiliary memory features are separable design axes, but most browser agent harnesses hard-code one modality stack by default; treating the axes independently lets teams choose per-task harnesses and benchmark the cross product instead of defending a single global design.

Angle

Decompose the harness into its axes, show why context representation is only meaningful relative to the chosen action space, and turn the unresolved context-storage question into an explicit benchmark plan.

Source video

Project ideas

4

Overhang Isolator

beyond-evals

The capability gain attributed to 'giving the model a bash tool' is mainly attributable to retrieval-and-grep access, not to code execution itself; a retrieval-only tool will recover most of the gain on parametric-recall tasks while a bare code-execution tool without data access will not.

Proof of concept

Build a controlled task battery in three arms — (a) chat-only parametric recall, (b) chat + retrieval/grep access with no arbitrary execution, (c) chat + full script execution and fetch/grep — over datasets where the model demonstrably 'knows' the answer but cannot surface it in chat.

Measurement

Task success rate per arm, with the retrieval-only arm compared against the full-execution arm; a large gap in favor of full execution falsifies the retrieval-only hypothesis.

Source video

Prompt Debt Auditor

beyond-evals

For a fixed agent task suite, a system prompt pruned by roughly 80% with minimal few-shot examples matches or beats the pre-prune prompt on a newer model generation, and any regressions are concentrated in a small, identifiable set of instruction-following cases rather than spread evenly.

Proof of concept

Version-control two prompt tiers (full and pruned) for one agent, run both against an identical task suite on successive model generations, and produce a per-case diff report tagging each prompt clause as retained, deleted, or inverted.

Measurement

Task success delta between prompt tiers per model generation, plus the count and identity of regressed instruction-following cases; a systematic pruned-tier loss falsifies the hypothesis.

Source video

Harness Cross-Product Bench

movement-lab

Context representation and action-execution archetype interact strongly enough that no single representation dominates; the best-performing (context, action) pair changes across task families, so a per-task harness selection beats any global default.

Proof of concept

Implement a browser agent harness with pluggable context backends (full screenshots, DOM diffs, bounding-box annotations) and pluggable action interfaces, then run the cross product on one shared task suite with token and latency accounting per cell.

Measurement

Task success, tokens, and latency per matrix cell, plus whether the argmax cell differs across task families; a single cell dominating all families on all axes falsifies the hypothesis.

Source video

Compaction Memory-Loss Regression

gatehouse

Aggressive compaction causes silent, measurable memory loss on long-horizon tasks, and retention rules keyed to task-critical facts, logged deviations, and prior decisions recover most of the lost success at a fraction of the uncompacted token cost.

Proof of concept

Construct long-horizon tasks with planted critical facts and mandated deviation logging, then run them under a sweep of compaction aggressiveness settings with and without the retention criteria enabled.

Measurement

Success rate and post-compaction recall of planted facts as a function of compaction aggressiveness; retention rules that do not beat naive compaction falsify the hypothesis.

Source video

Architectural implications

3

System prompts encode constraints that smarter models can infer themselves, so the prompt layer accumulates redundant scaffolding across generations.

Before

Prompt templates are treated as durable, additive assets; each new failure adds another example or negative constraint.

After

Prompts become thin, model-generation-scoped artifacts, with harness code and tool descriptions carrying capability and a deliberate pruning step at each model upgrade.

Consequence

New maintenance workflow: on model upgrade, actively delete prompt content and re-measure, rather than preserving prompts for backward compatibility.

Source video

Browser agent harnesses have at least three independent design axes (context storage, action archetype, auxiliary features).

Before

Harness built monolithically around one default modality (e.g., screenshot-only, human-like clicking).

After

Context representation, action interface, and memory/compaction treated as pluggable dimensions chosen against task requirements.

Consequence

Enables per-task harness selection and A/B benchmarking across the matrix rather than a single global harness design.

Source video

Compaction and subagents are harness-level features governing context lifecycle, and context storage strategy is an open question for browser agents.

Before

Context handling treated as an implicit byproduct of the transcript format.

After

Context lifecycle (what is stored, what is compacted, what subagents hold) becomes an explicit, named subsystem.

Consequence

Compaction policy becomes a first-class reliability concern: incorrect compaction silently removes the memory an agent needs mid-task.

Source video

Tradeoffs and failure modes

4

Shrinking system prompts on stronger models

Benefit

Less prompt bloat, fewer redundant examples, reliance on native model judgment and tool descriptions.

Cost or risk

Judgment-based behavior is less deterministic than enumerated constraints, and prompt prunes validated on one model generation may silently break on another or on out-of-distribution tasks.

Constraints are being replaced by judgment and tool capability.
Open source video
Source video

Abstract prompt (map) versus real codebase (territory)

Benefit

Concise abstract prompts scale across many repositories without per-repo specification.

Cost or risk

Models hit unknowns while executing abstract instructions, producing confident but wrong implementations unless blindspot passes, implementation notes, and deviation logging are mandated.

Models frequently run into unknowns when given abstract instructions.
Open source video
Source video

Context storage choice for browser agents (all screenshots vs DOM diffing vs bounding-box annotations)

Benefit

Richer context (full screenshots) maximizes information available for visual decisions.

Cost or risk

Storage/token cost and compaction pressure grow with raw context, and compaction risks losing critical agent memory; the optimal strategy is stated as unresolved.

What is the optimal context storage strategy for browser agents?
Open source video
Source video

Execution tooling (bash/code) as capability unlock

Benefit

Dormant capabilities surface once the model can fetch, script, and grep instead of recalling from parametric knowledge.

Cost or risk

Expanding the action space enlarges the blast radius and broadens the space of harness/prompt interactions that must be validated empirically.

Equipping models with execution tools bridges capability gaps.
Open source video
Source video

Open questions

5

What is the optimal context storage strategy for browser agents?

Why unresolved

The summary lists it as an open question; only the candidate options (all screenshots vs DOM diffing vs bounding-box annotations) are named, with no comparative result given.

Research direction

Benchmark browser-agent task success, token cost, and latency across context representations on a shared task suite; include mixed representations.

Source video

How can compaction be automated without losing critical agent memory?

Why unresolved

Compaction is identified as a harness feature and a risk, but the summary provides no policy, retention rule, or evaluation for it.

Research direction

Define retention criteria (task-critical facts, deviations, decisions), and build a regression test where long-horizon tasks are run with varying compaction aggressiveness to measure silent memory loss.

Source video

Under what conditions does a smaller system prompt outperform a larger one with examples, and how does that boundary move across model generations?

Why unresolved

Only an anecdotal ~80% prompt reduction figure is reported, with no benchmark or task distribution attached.

Research direction

Ablate system prompt length and few-shot count per model generation on a fixed agent task suite, tracking task success and instruction-following regressions.

Source video

Which harness/prompt rules transfer across model generations versus needing re-derivation?

Why unresolved

The biology-not-physics framing implies non-deterministic empirical rules, but the summary gives no transfer methodology.

Research direction

Maintain a versioned probe suite run per model upgrade, tagging each harness rule as retained, deleted, or inverted.

Source video

Is the capability overhang effect attributable to tool execution per se or to the retrieval/grep pattern specifically?

Why unresolved

The single cited example (Pokémon ending in 'aw') uses fetch-and-grep, so tool execution, retrieval, and scripting are confounded.

Research direction

Design controlled tasks that isolate parametric recall failures, retrieval access, and code-writing, with and without execution, to separate the contributing factors.

Source video

Key claims

8
causalVerification needed

AI models are grown, not designed, so their capabilities are discovered empirically rather than specified.

Evidence

AI models are grown, not designed.

Question

Can the empirical-discovery claim be operationalized, e.g. do model updates produce capability changes not predictable from the prior version's documented behavior?

Source video
causalVerification needed

Model capabilities grow spikily rather than smoothly, and chat interfaces fail to extract capabilities the model already has.

Evidence

Capabilities grow spikily rather than smoothly.

Question

Across model generations, is per-task capability gain better modeled as discontinuous jumps than as a smooth monotone curve?

Source video
comparativeVerification needed

Claude 5 models require smaller system prompts and fewer examples because of better model judgment.

Evidence

Claude 5 models require smaller system prompts and fewer examples because of better model judgment.

Question

On a fixed agent task suite, does a shorter system prompt with fewer few-shot examples match or beat the longer prompt on Claude 5-class models?

Source video
factualVerification needed

About 80% of Claude Code's system prompt was removed as models got smarter.

Evidence

Removing 80% of system prompts from Claude Code as models got smarter.

Question

What was the measured before/after task performance and instruction-following impact of that 80% prompt reduction?

Source video
causalVerification needed

Models frequently run into unknowns when given abstract instructions, and prompting must help them find their unknown unknowns.

Evidence

Models frequently run into unknowns when given abstract instructions.

Question

Does adding an explicit blindspot-pass or unknown-elicitation step measurably reduce incorrect implementations from underspecified prompts?

Source video
predictionVerification needed

Agentic tool-use behavior evolves rapidly across model generations, shifting from asking clarifying questions to interviewing users to generating HTML reports and quizzes.

Evidence

Transitioning from Opus 4 (calling AskUserQuestion with difficulty) to Opus 4.5 (interviewing users) to Opus 4.8 (building HTML reports and quizzes).

Question

Are these interaction-shift behaviors reproducible across generations under a fixed harness and prompt, or artifacts of concurrent harness changes?

Source video
opinionVerification needed

For browser agents, context storage, action execution archetype, and harness features are separable architectural decisions.

Evidence

Context storage (screenshots, DOM, diffs, annotations)

Question

Do context representation and action archetype interact strongly enough in practice that they cannot be chosen independently?

Source video
opinionVerification needed

HTML artifacts should replace raw markdown for complex multi-step agent plans.

Evidence

Use HTML artifacts instead of raw markdown for complex multi-step agent plans.

Question

Do HTML plans improve human detection of errors or reduce correction cycles compared with markdown plans of equivalent content?

Source video

Connections

5