Ryan Peterman · Published 2026-09-07

How Anthropic Builds And How Engineering Will Change Soon | Thariq Shihipar

Open on YouTube ↗

Summary

Overview

  • Speaker: Thariq Shihipar
  • Channel: Ryan Peterman
  • Main topic: Software engineering practices with LLMs at Anthropic
  • Purpose: To provide insights into how top AI companies like Anthropic use LLMs in software engineering and discuss the broader industry shifts expected from AI. Ryan Peterman hosts Thariq Shihipar, software engineer at Anthropic on the Claude Code team, to discuss how their engineering team makes the most of LLMs today. They cover topics including moving up abstraction levels, onboarding with AI thought partners, internal versus external perception of AI capabilities, harness engineering, knowledge work vs code, loop engineering, and what the future of software engineering and coding looks like.

Topic Map

Moving to Higher Abstractions

  • Explanation: Shifting from writing individual lines of code to building systems that build systems and operating at higher abstraction levels.
  • Key claims:
    • Software written before LLMs was not very good
    • Engineers should move up to a higher abstraction level and build the system that builds the system
  • Examples:
    • Using Claude Code as a thought partner rather than just a code generator
  • Terminology:
    • abstraction level
    • thought partner
    • Claude Code
  • Why it matters: Enables engineers to leverage AI leverage rather than getting bogged down in boilerplate syntax.

Harness Engineering vs. Model Capabilities

  • Explanation: The relationship between model quality and harness engineering to get the best results.
  • Key claims:
    • As models get better, harnesses need to become more complicated to allow models to do more things
    • Auto-mode and complex workflows require rigorous harness design
  • Examples:
    • Auto-mode classifier running after tasks
  • Terminology:
    • harness engineering
    • auto-mode
    • verification harness
  • Why it matters: Models alone are insufficient without proper scaffolding and execution harnesses.

Knowledge Work vs. Code

  • Explanation: How most knowledge work is reducible to code and coding agents.
  • Key claims:
    • Most knowledge work is reducible to code and coding agents
    • Technical people do knowledge work very differently than non-technical people
  • Examples:
    • Video editing via FFmpeg and scripts instead of graphical editors
  • Terminology:
    • knowledge work
    • coding agents
  • Why it matters: Expands the definition of software engineering to cover broad knowledge work domains.

Loop Engineering

  • Explanation: Setting up systems that prompt models in loops rather than manual one-off prompts.
  • Key claims:
    • Loop engineering involves setting up systems that prompt Claude in automated loops
    • Using Claude tag for daily loops and triage
  • Examples:
    • Morning loop checking events and PRs automatically
  • Terminology:
    • loop engineering
    • Claude tag
    • triage loops
  • Why it matters: Moves from interactive prompting to autonomous background agents.

Artifacts and Interactive Interfaces

  • Explanation: Using artifacts as a form of prompting where Claude uploads web apps or interfaces for interactive collaboration.
  • Key claims:
    • Artifacts are web apps or structured interfaces uploaded by Claude for the user
    • Moving beyond simple text in text out interfaces
  • Examples:
    • Calling MCPs and reading inboxes via artifacts
  • Terminology:
    • artifacts
    • MCP
    • interactive display
  • Why it matters: Provides richer context and interaction modalities between humans and AI.

Key Points

Treat Claude as a Thought Partner

  • Explanation: Onboarding engineers to treat Claude as an intellectual collaborator with full context rather than a simple code completion tool.
  • Evidence: Anthropic tips for onboarding engineers onto their team.
  • Practical implication: Engineers get better architectural and systems-level help.

The Importance of Verification Harnesses

  • Explanation: Writing extensive tests, verification scripts, and harnesses to ensure model outputs are correct.
  • Evidence: Writing 100x more testing code than before.
  • Practical implication: Allows trusting AI-generated code at scale.

Iterative Prompting vs One-Shot Prompts

  • Explanation: Iterating, adding context, and building feedback loops rather than expecting one-shot perfection on complex tasks.
  • Evidence: Discussion on why long PRs need extensive context and artifacts.
  • Practical implication: Reduces failure modes in autonomous coding tasks.

Frameworks, Models & Processes

Harness & Model Co-Evolution Framework

  • How it works: As models improve, engineering harnesses must scale in complexity to unlock higher autonomy.
  • Components:
    • Model capability
    • Verification harness
    • Auto-mode loops
    • Artifacts
  • When to use: When deploying LLMs for complex software engineering workflows.

Examples & Case Studies

Transitioning from traditional accounting tools to python scripts and Claude.

  • Illustrates: Knowledge work reduction to code.
  • Lesson: Almost all knowledge work can be framed through code agents.

Actionable Takeaways

  • Immediate:
    • Treat LLMs as thought partners with deep context
    • Invest heavily in verification harnesses and automated testing
  • Strategic:
    • Move up to higher abstraction levels in software engineering
    • Embrace loop engineering and autonomous workflows
  • Questions to investigate:
    • How will code maintenance and code ownership evolve as AI velocity increases?
    • What is the limit of autonomous software engineering loops?

Claims Worth Verifying

  • Most knowledge work is reducible to code and coding agents (philosophical claim)
  • Engineers write 100x more testing code when using LLMs (empirical observation)

Notable Quotes

"Most software we wrote before LLMs was not very good." (at 0:00) "Can you move up like a higher abstraction level, you know, like can you build the system that builds the system?" (at 0:12)

Compressed Summary

  • Treat LLMs as thought partners with complete context
  • Build complex verification harnesses as model capabilities grow
  • Shift from manual prompting to loop engineering
  • Use artifacts and interactive interfaces for rich collaboration
  • Keywords: llm, software engineering, anthropic, claude, harness engineering
  • Core insight: Software engineering with LLMs requires moving up abstraction levels, building robust verification harnesses, and adopting loop engineering to manage high code velocity.

Core insights

6
Mental Modelhigh noveltymoderate evidence

Harness complexity should scale up, not down, as model capability increases: stronger models unlock more autonomy only if the surrounding harness (verification, auto-mode classifiers, workflows) becomes more elaborate. This inverts the common assumption that better models reduce scaffolding needs.

Why it matters

Teams that assume a model upgrade lets them delete harness code will under-exploit new model capability; teams that treat harness design as a co-evolving discipline unlock higher autonomy tiers. It reframes harness engineering as a durable investment, not a temporary crutch.

Generalization

For any agentic system, the ceiling on autonomy is set by the harness (verification, control flow, escalation) as much as by model quality, so harness capability must be roadmaped alongside model upgrades.

As models get better, harnesses need to become more complicated to allow models to do more things
Open source video
Auto-mode and complex workflows require rigorous harness design
Open source video
Practicemedium noveltymoderate evidence

Verification code volume inverts relative to production code: the team reportedly writes roughly 100x more testing/verification code, because generated code velocity only becomes trustworthy when output is checked by harnesses and scripts rather than by humans reading diffs.

Why it matters

If true, the primary engineering artifact shifts from the code being shipped to the verification layer around it, changing where headcount, review effort, and design attention go. It also implies code review as the main safety mechanism does not scale with model output velocity.

Generalization

Any pipeline producing machine-generated artifacts at high velocity needs a machine-checkable verification surface whose cost scales with generation rate, not with human review bandwidth.

Writing 100x more testing code than before
Open source video
Writing extensive tests, verification scripts, and harnesses to ensure model outputs are correct
Open source video
Architecturemedium noveltymoderate evidence

Loop engineering: replace one-off interactive prompts with scheduled/event-driven systems that prompt the model on a cadence (e.g., a morning loop checking events and PRs, triage loops triggered by a tag), turning the agent from a session into a background daemon.

Why it matters

Shifts the unit of agent design from 'a conversation' to 'a recurring job with state, triggers, and triage rules', which changes requirements for scheduling, idempotency, notification, and cost control in production agent systems.

Generalization

Autonomous value comes from loop topology (trigger, cadence, escalation path), not from individual prompt quality; loops are the deployable artifact.

Loop engineering involves setting up systems that prompt Claude in automated loops
Open source video
Morning loop checking events and PRs automatically
Open source video
Using Claude tag for daily loops and triage
Open source video
Architecturemedium noveltyweak evidence

Artifacts as an output/prompting modality: the model emits structured interactive interfaces (web apps) that the user manipulates and that themselves call MCPs and read data sources, replacing text-in/text-out as the human-AI interface.

Why it matters

Generated UI becomes both context-gathering device and control surface, so the interaction contract is no longer a message list but a rendered application; this has implications for how much context can be captured per turn and how tool calls get routed.

Generalization

When model output can be executable interfaces rather than prose, the human-interaction layer becomes a generated app that can itself invoke tools — a general pattern for high-context collaboration.

Artifacts are web apps or structured interfaces uploaded by Claude for the user
Open source video
Calling MCPs and reading inboxes via artifacts
Open source video
Moving beyond simple text in text out interfaces
Open source video
Predictionmedium noveltyweak evidence

Knowledge-work reduction: the claim that most knowledge work is expressible as code plus coding agents, evidenced by substituting scripted pipelines (FFmpeg, Python scripts) for GUI tools in domains like video editing and accounting.

Why it matters

If even a large fraction of knowledge work is reducible this way, the addressable surface of coding agents expands well beyond software repos, and the engineer's skill becomes modeling a workflow as a code-executable pipeline.

Generalization

Domains currently served by interactive GUI tools are candidates for agent-driven scripted pipelines whenever their operations are deterministic and scriptable.

Most knowledge work is reducible to code and coding agents
Open source video
Video editing via FFmpeg and scripts instead of graphical editors
Open source video
Transitioning from traditional accounting tools to python scripts and Claude.
Open source video
Mental Modelmedium noveltymoderate evidence

Abstraction shift: the engineer's target artifact becomes the system that builds the system, with the model used as a full-context thought partner for architectural work rather than a completions engine for boilerplate.

Why it matters

Redefines the leverage point in engineering: value accrues to those who design generation/verification pipelines, not those who hand-write the produced code. It also implies onboarding should teach context-rich collaboration patterns, not prompt tricks.

Generalization

As generation cost drops, competitive advantage moves up one abstraction layer to whoever defines the pipeline and its constraints.

Can you move up like a higher abstraction level, you know, like can you build the system that builds the system?
Open source video
Treat Claude as a thought partner rather than just a code generator
Open source video
Onboarding engineers to treat Claude as an intellectual collaborator with full context rather than a simple code completion tool
Open source video

Deep dives

5

Harness-model co-evolution and harness ablation across model generations

Research question

Which harness components (verification steps, auto-mode classifiers, escalation rules, context-injection) retain marginal autonomy contribution as model capability increases, and which become dead weight that should be deleted?

Why

The claim that harnesses must grow more complex as models improve is a directional prediction with no evidence about which parts survive. If some harness layers are absorbed by the model and others are not, teams need a repeatable ablation method to decide what to keep. Otherwise harness complexity compounds as a permanent maintenance tax while silently degrading the autonomy ceiling it was built to raise.

As models get better, harnesses need to become more complicated to allow models to do more things
Open source video
Auto-mode and complex workflows require rigorous harness design
Open source video
Source video

Inverting the verification-to-production code ratio

Research question

Does verification code volume scale with generation rate rather than human review bandwidth, and what ratio of verification-to-production code is required before agent-generated output becomes trustworthy at scale?

Why

If the primary engineering artifact truly shifts from shipped code to the verification layer, then headcount, review process, and design attention must be reallocated accordingly. The ~100x claim, if directionally right, invalidates diff-reading as the main correctness gate and makes harness coverage the real correctness guarantee. But verification code itself can drift and create false confidence, so the ratio needs to be measured, not asserted.

Writing 100x more testing code than before
Open source video
Writing extensive tests, verification scripts, and harnesses to ensure model outputs are correct
Open source video
Source video

Loops as the deployable unit of agent design

Research question

What infrastructure properties (scheduling, idempotency, deduplication of triage items, per-loop cost ceilings, escalation paths) are necessary before a recurring agent loop can run unattended, and where does autonomous success rate collapse into mandatory human escalation?

Why

Reframing the agent from a conversation to a recurring job with triggers and triage state changes the entire requirements surface: idempotency, notification, cost control, and escalation become first-class. The limit of autonomous loops is explicitly open, and without boundary conditions there is no principled rule for when a loop must defer to a human.

Loop engineering involves setting up systems that prompt Claude in automated loops
Open source video
Morning loop checking events and PRs automatically
Open source video
Using Claude tag for daily loops and triage
Open source video
Source video

Task taxonomy for knowledge-work reduction to code pipelines

Research question

Which classes of knowledge work resist reduction to code and coding agents when scored on determinism, context locality, and verification cost, and does the technical/non-technical split predict adoption success?

Why

The reduction claim is philosophical and backed only by selective examples. A scored taxonomy converts an opinion into a testable predictor of where coding agents generalize beyond repos. It also tests whether the technical/non-technical gap narrows as agent tooling matures, which determines whether code-based knowledge work stays an engineering privilege or becomes general.

Most knowledge work is reducible to code and coding agents
Open source video
Video editing via FFmpeg and scripts instead of graphical editors
Open source video
Transitioning from traditional accounting tools to python scripts and Claude.
Open source video
Technical people do knowledge work very differently than non-technical people
Open source video
Source video

Generated artifact interfaces as untrusted, tool-bearing surfaces

Research question

What permissions, observability, and trust boundaries are required when model-generated interactive artifacts can themselves invoke MCPs and read data sources instead of returning plain text?

Why

If the interface becomes a rendered application that gathers context and routes tool calls, context acquisition turns into a UI design problem and the artifact becomes an attack surface with its own capability grants. Treating generated interfaces as trusted transcripts would leak permissions and hide tool-call provenance.

Artifacts are web apps or structured interfaces uploaded by Claude for the user
Open source video
Calling MCPs and reading inboxes via artifacts
Open source video
Moving beyond simple text in text out interfaces
Open source video
Source video

Article ideas

4

Your Model Upgrade Is Not a Harness Deletion Event

The intuition that better models let you remove scaffolding is backwards: rising model capability raises the autonomy ceiling only when the harness grows with it, so harness engineering is a durable discipline with its own roadmap, not a temporary crutch to be retired at the next model release.

Angle

Contrast the 'delete the scaffolding' reflex with concrete harness layers (verification steps, auto-mode classifiers, escalation rules) and argue that each model generation should trigger harness ablation experiments, not harness demolition.

Source video

Verification Is the Product: Why the Verification-to-Shipped-Code Ratio Flips

When agents generate code faster than humans can read diffs, code review stops being the correctness gate and the verification layer becomes the primary deliverable; teams that keep optimizing for reviewer throughput will ship faster and trust less, while teams that invest in machine-checkable verification surfaces convert velocity into reliability.

Angle

Argue the ratio inversion (~100x verification code) as a structural consequence of generation velocity, then examine the failure mode where verification code itself drifts and manufactures false confidence.

Source video

The Conversation Was Never the Artifact: Loops Are

Designing an agent as a chat session under-specifies everything that matters in production; when the unit of design becomes a recurring loop with triggers, cadence, triage state, and escalation, the hard problems move from prompt quality to scheduling, idempotency, deduplication, and per-loop cost ceilings.

Angle

Reframe agent design around loop topology and use the morning-check and tag-driven triage patterns as the concrete case that exposes the missing infrastructure requirements.

Source video

Most Knowledge Work Is a Pipeline You Have Not Written Yet

The reduction of knowledge work to code and coding agents is not a philosophical curiosity but a practical selection rule: domains whose operations are deterministic and scriptable are candidates for scripted pipelines, and the engineer's new skill is modeling a workflow as a code-executable, verifiable pipeline rather than operating a GUI.

Angle

Test the reduction claim against the FFmpeg/scripting and accounting-script examples, then propose determinism and verification cost as the two filters that predict which workflows convert and which do not.

Source video

Project ideas

4

Harness Ablation Rig

beyond-evals

Given a fixed agentic task suite, a measurable subset of harness components (auto-mode classifiers, verification steps, escalation rules) becomes redundant as the underlying model improves, and ablating those components without loss of task success rate identifies removable scaffolding; harness complexity therefore does not need to grow monotonically.

Proof of concept

Run the same task suite across two successive model versions with a configurable harness where each component can be toggled; measure success rate, escalation frequency, and cost per task for every harness subset to locate the ablation frontier.

Measurement

Marginal task-success contribution and cost delta per harness component per model version; number of components that can be removed with no statistically significant success-rate loss.

Source video

Verification Ratio Meter

beyond-evals

Verification-to-production code ratio scales with machine generation rate rather than human review bandwidth, and pipelines below a threshold ratio exhibit rising defect escape rates that are not detected by human diff review.

Proof of concept

Instrument a repo or pipeline to track verification lines, production lines, generation volume, and post-merge defect escapes per time window; plot escape rate against verification-to-production ratio and detect the knee where escapes fall off.

Measurement

Correlation between verification-to-production ratio and defect escape rate per generation-volume bucket; ratio threshold at which escape rate stops improving.

Source video

Loop Ops Harness

movement-lab

Recurring agent loops can run unattended only when explicit idempotency keys, triage-item deduplication, per-loop cost ceilings, and a defined escalation path are enforced, and loops missing these properties fail at a predictable task-ambiguity threshold.

Proof of concept

Build a scheduled loop runner (cadence trigger plus tag-triggered triage) for a morning-check style job over events and PRs, with toggleable idempotency, dedup, cost ceiling, and escalation controls; escalate task scope and ambiguity until autonomy collapses.

Measurement

Unattended run success rate, duplicate-action rate, cost per loop run, and the task-ambiguity level at which human escalation becomes mandatory.

Source video

Generated Artifact Capability Sandbox

gatehouse

Model-generated interactive artifacts that invoke MCPs and read data sources leak capability unless permissions are granted per artifact instance, and per-instance capability grants reduce unauthorized tool-call surface without reducing task completion rate.

Proof of concept

Wrap generated artifacts in a sandbox where each instance receives an explicit scoped capability manifest for its MCP calls and data reads; compare unauthorized-call incidence and task completion against an unscoped baseline.

Measurement

Rate of tool calls outside the granted scope, task completion rate, and observability coverage of tool-call provenance per artifact instance.

Source video

Architectural implications

4

Verification moves from a downstream step to the primary construction surface when agents generate code at high velocity.

Before

Tests and review are a fraction of engineering effort; humans read diffs as the main correctness gate.

After

Verification harnesses, scripts, and auto-mode classifiers are a first-class deliverable, reportedly written at ~100x the volume of prior testing code.

Consequence

Review-bandwidth bottlenecks are replaced by harness-maintenance cost; correctness guarantees become a function of harness coverage rather than reviewer attention.

Source video

The agent runtime is reframed from an interactive session to a scheduled/event-driven loop with triage state.

Before

A human opens a chat, prompts, and closes the session; agent state lives inside the conversation.

After

Loops fire on cadence or triggers (morning checks, tag-driven triage) and prompt the model autonomously.

Consequence

New infrastructure requirements appear: scheduling, idempotency, deduplication of triage items, cost ceilings per loop, and escalation paths when the loop is uncertain.

Source video

The human-AI interface becomes a model-generated interactive artifact that can itself call tools, rather than a text transcript.

Before

Interface is text-in/text-out; context is limited to what the user types.

After

Model emits web apps/interfaces that call MCPs and read data sources, capturing richer context per interaction.

Consequence

Context acquisition becomes a UI design problem; generated interfaces must be treated as untrusted, tool-bearing surfaces with their own permissions and observability needs.

Source video

The engineer's deliverable shifts from produced code to the generation-and-verification pipeline that produces it.

Before

Engineer writes systems directly; the system is the output.

After

Engineer builds the system that builds the system, using the model as a high-context thought partner.

Consequence

Skill and tooling investment concentrates on pipeline design, harness quality, and loop orchestration rather than individual implementation work.

Source video

Tradeoffs and failure modes

4

Harness complexity scaling with model capability

Benefit

More elaborate harnesses (auto-mode classifiers, verification steps) let better models take on more autonomous work.

Cost or risk

Harness complexity becomes a maintenance burden and may be tuned to the current model generation, creating coupling that must be revised as models improve.

As models get better, harnesses need to become more complicated to allow models to do more things
Open source video
Source video

Massive verification code investment

Benefit

Writing far more tests and verification scripts makes machine-generated code trustworthy at scale.

Cost or risk

Sustaining ~100x verification code volume is its own engineering and maintenance load, and verification code itself can become a source of drift or false confidence.

Writing 100x more testing code than before
Open source video
Source video

One-shot prompting on complex, long-horizon tasks

Benefit

One-shot prompts are fast and cheap when the task is simple and self-contained.

Cost or risk

Complex tasks such as long PRs fail without iterative prompting, added context, and feedback loops or artifacts; expecting one-shot perfection is a recurring failure mode.

Iterating, adding context, and building feedback loops rather than expecting one-shot perfection on complex tasks
Open source video
Source video

Autonomous loop engineering

Benefit

Automated loops (daily checks, tag-driven triage) move the agent from interactive to background autonomous operation.

Cost or risk

The limits of autonomous loops are unknown, and open questions remain about how code maintenance and ownership behave as AI-driven velocity increases.

How will code maintenance and code ownership evolve as AI velocity increases?
Open source video
Source video

Open questions

4

How will code maintenance and code ownership evolve as AI velocity increases?

Why unresolved

The summary raises the question but provides no mechanism for ownership assignment when generation outpaces human authorship; no empirical data on maintenance load is offered.

Research direction

Instrument agent-authored changes with ownership attribution and measure defect, review, and rework rates per owning team over time.

Source video

What is the limit of autonomous software engineering loops?

Why unresolved

Loops are described operationally (morning checks, triage) but no boundary conditions are given for when a loop must escalate to a human.

Research direction

Stress-test loops with escalating task scope and ambiguity to identify the point where autonomous success rate collapses and human escalation becomes mandatory.

Source video

Does harness complexity keep growing with each model generation, or is it eventually absorbed into the model?

Why unresolved

The claim that better models require more complex harnesses is a directional prediction; no evidence is given about which harness components survive across model upgrades.

Research direction

Ablate harness components across successive model versions to measure which still contribute marginal autonomy and which become dead weight.

Source video

Which classes of knowledge work actually resist reduction to code and coding agents?

Why unresolved

The reduction claim is explicitly flagged as philosophical and is supported only by selective examples (FFmpeg video editing, accounting scripts).

Research direction

Build a task taxonomy scoring determinism, context locality, and verification cost, then test agent reduction rates per class.

Source video

Key claims

7
causalVerification needed

As models improve, harnesses must become more complicated to let models do more.

Evidence

As models get better, harnesses need to become more complicated to allow models to do more things

Question

Does harness complexity actually increase with model capability in practice, or does part of the harness become redundant and removable across model generations?

Source video
comparativeVerification needed

The team writes roughly 100x more testing/verification code than before LLM usage.

Evidence

Writing 100x more testing code than before

Question

How is the 100x ratio measured (lines, effort hours, cost), and is it reproducible across other teams and codebases?

Source video
opinionVerification needed

Most knowledge work is reducible to code and coding agents.

Evidence

Most knowledge work is reducible to code and coding agents

Question

What fraction of knowledge-work tasks can be expressed as verifiable code pipelines, and which categories resist reduction?

Source video
opinionVerification needed

Software written before LLMs was not very good.

Evidence

Most software we wrote before LLMs was not very good.

Question

Is there any measurable basis (defect rates, maintainability metrics) for comparing pre-LLM and LLM-era software quality?

Source video
comparativeVerification needed

Most knowledge work is reducible to code, while technical and non-technical people perform knowledge work very differently.

Evidence

Technical people do knowledge work very differently than non-technical people

Question

Does the technical/non-technical split predict who successfully adopts code-based knowledge-work pipelines, and does that gap narrow or widen over time?

Source video
causalVerification needed

Auto-mode and complex workflows require rigorous harness design.

Evidence

Auto-mode and complex workflows require rigorous harness design

Question

What harness properties (classifier coverage, escalation rules, verification depth) are necessary before auto-mode can be trusted unsupervised?

Source video
causalVerification needed

Long or complex tasks fail under one-shot prompting and require iteration with added context and feedback loops.

Evidence

Iterating, adding context, and building feedback loops rather than expecting one-shot perfection on complex tasks

Question

How does success rate on complex tasks scale with number of iteration/context rounds, and where does the curve plateau or degrade?

Source video

Connections

5

artifactsMCP

Generated interfaces act as tool-calling surfaces that can invoke MCPs and read data sources, merging output modality with context acquisition.

Source video