AI Engineer · Published 2026-08-27

How Anthropic Builds: Lessons from Labs — Mike Krieger, Anthropic

privateReview: unreviewedConfidence: high
anthropicai engineeringproduct developmentworkflowslabsend-state-expressiontask-delegationagent-autonomypersevere-pivotcodebase-migrationcode-verifiabilityproactive-agentslabs-rhythm
Open on YouTube ↗

Summary

Overview

  • Speaker: Mike Krieger
  • Channel: AI Engineer
  • Main topic: Building AI products, shifting from traditional engineering paradigms to AI-first development workflows at Anthropic.
  • Purpose: Provide insights into Anthropic's internal product development, labs culture, and practical paradigms for AI engineering. Mike Krieger, Instagram co-founder and technical staff at Anthropic, discusses how model usage has evolved internally, the transition from task delegation to end-state expression, internal lab structures, and lessons learned on building products with AI models like Claude.

Topic Map

Model Usage and Workflow Shifts

  • Explanation: How Mike Krieger's usage of models shifted from being a product officer writing strategy docs to building extensively with models, leading to a shift in role and perspective.
  • Key claims:
    • Fomo of building with models increased until shifting roles became necessary.
    • Engineers moved from breaking down tasks step-by-step to expressing end states.
  • Examples:
    • Writing strategy docs and asking Claude to critique vs. spending weekends building applications.
  • Terminology:
    • Task delegation
    • End-state expression
  • Why it matters: Demonstrates the evolution of human-AI collaboration from iterative prompting to specifying outcomes.

Unreasonableness and Ambition in AI

  • Explanation: Discussing the need to be unreasonable and ambitious when using AI tools, pushing models to handle massive refactoring or porting codebases.
  • Key claims:
    • First-generation AI products put models in boxes with limited access and freedom.
    • Industry needs to teach people to be more unreasonable in their AI usage.
  • Examples:
    • Porting an entire Python codebase to TypeScript over a weekend using dynamic workflows.
  • Terminology:
    • Unreasonable usage
    • Monkey-type runtime types
  • Why it matters: Encourages developers to stretch AI capabilities beyond simple script writing to complex architectural migrations.

Anthropic Labs Structure

  • Explanation: How Anthropic structures its internal labs, balancing rapid prototyping with product viability and managing two-week review cycles.
  • Key claims:
    • Labs use a two-week review cadence where every project is evaluated to persevere or pivot.
    • Engineering manager discipline focuses on team health and matching individuals to projects they are excited about.
  • Examples:
    • The 'persevere or pivot' review cycle for internal lab projects.
  • Terminology:
    • Labs initiative
    • Persevere or pivot
    • Bet leads
  • Why it matters: Provides a template for managing fast-paced, high-uncertainty AI product experimentation.

Key Points

Moving from task delegation to end-state expression

  • Explanation: Users and developers should express the final desired outcome rather than micro-managing intermediate steps.
  • Evidence: Fable and other models perform better when given the end-state to execute on.
  • Practical implication: Reduces cognitive load on developers and leverages model autonomy.

Internal labs rhythm and cadence

  • Explanation: Anthropic labs operate on short two-week review cycles to quickly validate or kill internal experiments.
  • Evidence: Projects regularly face shutdown if they do not show traction, preventing sunk-cost fallacies.
  • Practical implication: Maintains agility and high velocity in experimental AI product development.

Avoiding burnout through balance and self-care

  • Explanation: Fast-moving AI environments risk high burnout; encouraging time off and verbalizing emotions is crucial.
  • Evidence: Mike Krieger emphasizes taking days off and acknowledging when a project failure hurts emotionally.
  • Practical implication: Ensures long-term team sustainability in high-pressure tech environments.

Frameworks, Models & Processes

Persevere or Pivot Review Cycle

  • How it works: Every project undergoes regular two-week reviews to evaluate progress, traction, and viability.
  • Components:
    • Two-week evaluation cadence
    • Bet leads
    • Decision to continue, pivot, or shut down
  • When to use: Early-stage AI product experimentation and rapid prototyping.

Examples & Case Studies

Porting a large Python codebase to TypeScript over a weekend using dynamic workflows.

  • Illustrates: Unreasonable AI usage and end-state expression.
  • Lesson:

Actionable Takeaways

  • Immediate:
    • Push models to handle larger chunks of work (e.g., full migrations rather than small scripts).
    • Embrace short review cycles for experimental projects.
  • Strategic:
    • Foster a team culture that encourages vulnerability and acknowledges burnout.
    • Design products with multiplayer, asynchronous, and proactive AI interactions.
  • Questions to investigate:
    • How do we balance code verifiability with AI agent autonomy?
    • What is the right boundary between human code review and AI-driven development?

Claims Worth Verifying

  • 60% or more of code is written today using tools like Cursor and tags. (Statistic / Market Claim)

Notable Quotes

"Mike, thank you for releasing fable just in time for us." "We're all learning how to delegate better."

Compressed Summary

  • Shift from task delegation to end-state expression in AI development.
  • Anthropic labs use a disciplined two-week 'persevere or pivot' review cycle.
  • Encourage unreasonable AI usage for complex tasks like massive codebase migrations.
  • Manage team burnout by prioritizing mental health and open communication.
  • Keywords: anthropic, ai engineering, product development, workflows, labs
  • Core insight: Successful AI engineering requires shifting from micro-managing task delegation to expressing end-states while maintaining rigorous, rapid experimentation cycles.

Core insights

5
Mental Modelmedium noveltymoderate evidence

The key human-AI workflow shift in AI engineering is moving from task delegation to end-state expression: a human should specify the desired outcome instead of orchestrating steps, because models perform better when handed the end-state.

Why it matters

It changes where engineering attention goes: instead of investing in step-level prompts, chain-of-thought scaffolding, and manual decomposition, builders should invest in end-state specs, acceptance checks, and enough model autonomy for the model to determine its own path.

Generalization

Any harness or runtime that exposes a human-model loop can treat the model's own plan as an implementation detail and make the end-state the unit of contract between human and agent.

Engineers moved from breaking down tasks step-by-step to expressing end states.
Open source video
Users and developers should express the final desired outcome rather than micro-managing intermediate steps.
Open source video
Fable and other models perform better when given the end-state to execute on.
Open source video
Architecturehigh noveltyweak evidence

First-generation AI products 'put models in boxes' with limited access and freedom; the more productive usage pattern is to be deliberately unreasonable and task models with architecture-level work, such as porting an entire Python codebase to TypeScript in a weekend using dynamic workflows and monkey-type runtime types as intermediate scaffolding.

Why it matters

The model's apparent ceiling may be imposed more by the scaffold around it than by its intrinsic capabilities. Agent platforms should expose broad codebase and runtime access, with safety and review applied at the outer boundary, rather than gating the model behind narrow tools.

Generalization

Wider agent access with appropriate containment reclassifies large migrations, refactors, and other whole-system transformations as tractable agent work rather than human-planned multi-week projects.

First-generation AI products put models in boxes with limited access and freedom.
Open source video
Porting an entire Python codebase to TypeScript over a weekend using dynamic workflows.
Open source video
Monkey-type runtime types
Open source video
Practicemedium noveltymoderate evidence

Anthropic Labs manages high-uncertainty experimentation with a two-week 'persevere or pivot' review cadence: every project is evaluated for traction, and projects are shut down if they do not show it, structurally preventing sunk-cost fallacies while keeping velocity high.

Why it matters

Under uncertainty, waiting longer to evaluate increases the cost of bad bets. A short, pre-agreed review cadence with explicit kill criteria makes project termination part of the process instead of a failure of it.

Generalization

Fast-moving AI research and agent R&D portfolios should be decomposed into small reversible bets, each with a review date and traction criteria, rather than being run as open-ended long-horizon efforts.

Labs use a two-week review cadence where every project is evaluated to persevere or pivot.
Open source video
Projects regularly face shutdown if they do not show traction, preventing sunk-cost fallacies.
Open source video
Predictionmedium noveltyweak evidence

Anthropic's product direction for AI interactions is multiplayer, asynchronous, and proactive rather than single-user synchronous chat.

Why it matters

The interaction model determines the runtime and architecture: persistent agent state, event delivery, permissions, notifications, and human-agent coordination become first-class infrastructure concerns rather than chat-session plumbing.

Generalization

AI is becoming a collaborative worker across time and multiple humans; agent systems should be designed with durable execution, asynchronous messaging, and the ability to initiate work, not merely respond to prompts.

Design products with multiplayer, asynchronous, and proactive AI interactions.
Open source video
Practicelow noveltymoderate evidence

Sustaining a high-velocity AI product organization requires explicitly counteracting burnout: engineering managers should prioritize team health and fit rather than pure delivery, encourage time off, and allow project-failure emotions to be verbalized.

Why it matters

A persevere-or-pivot lab cadence will produce repeated project shutdowns; without deliberate emotional and health management, the process is psychologically unsustainable regardless of technical productivity.

Generalization

Any organization running fast agent or AI experiments should include human recovery capacity as a first-class operational resource, not treat team health as a side effect of engineering discipline.

Fast-moving AI environments risk high burnout; encouraging time off and verbalizing emotions is crucial.
Open source video
Engineering manager discipline focuses on team health and matching individuals to projects they are excited about.
Open source video

Deep dives

4

End-state expression vs step-by-step delegation in AI-assisted coding

Research question

Under what task conditions is specifying a desired outcome superior to breaking the task into explicit steps, and does the observed gain come from planning freedom, reduced compounded errors, or better credit assignment?

Why

Anthropic's internal shift suggests agent harnesses should treat the end-state spec as the contract and stop requiring step-level orchestration. We need to know when and why this holds before redesigning Gatehouse workflows and review UI around outcome acceptance rather than process inspection.

Engineers moved from breaking down tasks step-by-step to expressing end states.
Open source video
Users and developers should express the final desired outcome rather than micro-managing intermediate steps.
Open source video
Fable and other models perform better when given the end-state to execute on.
Open source video
Source video

Access-bounding tradeoffs for autonomous agents

Research question

What happens to agent task success and failure severity when access moves from narrow boxed tools to broad read/write/execute permissions with only outer-boundary review?

Why

If the agent performance ceiling is scaffold-imposed, every product that wraps models in safe APIs leaves value on the table, but broad access shifts the safety burden to review, sandboxing, and rollback. We need empirical answers on the size of productivity gain versus safety cost.

First-generation AI products put models in boxes with limited access and freedom.
Open source video
Source video

Whole-system codebase migration by AI agents

Research question

Can a model-driven agent port an entire codebase across languages when type correctness is temporarily relaxed into dynamic/duck typing, and what verification process validates the end-state quality?

Why

The Python-to-TypeScript weekend hack is dramatic evidence that large architecture migration is no longer a human-plan-only activity. Replicating it requires building dynamic intermediate representation and migration tooling, plus robust acceptance-testing and final-type-tightening harnesses.

Porting an entire Python codebase to TypeScript over a weekend using dynamic workflows.
Open source video
Source video

Persevere-or-pivot cadence as a portfolio control

Research question

Which traction signals and review cadence optimally terminate non-viable AI experiments while preserving team motivation?

Why

The two-week kill cycle may be Anthropic's best practice for avoiding sunk costs; its portability depends on identifying signals that predict long-term success and preventing burnout from repeated shutdowns.

Labs use a two-week review cadence where every project is evaluated to persevere or pivot.
Open source video
Source video

Article ideas

3

Stop Micromanaging AI: Specify the Outcome, Not the Steps

End-state expression should be the default for AI coding: engineers should write a precise contract for the result and accept the agent's internal plan, because model autonomy reduces overhead and produces better outcomes than forcing models through explicit task decompositions.

Angle

Hard shift from prompt engineering to outcome engineering; challenge the common advice to break tasks down

Source video

Unbox the Model: Why Giving AI Agents the Whole Codebase Beats Filtered Tools

Anthropic's Python-to-TypeScript port shows that agents are strongest when granted full-environment access; product teams should stop putting models in safe boxes and instead build guardrails, sandboxing, and outer-loop review around broad permissions.

Angle

Architecture criticism of first-gen AI products plus a concrete prescription for agent platform builders

Source video

Persevere or Die: Anthropic's Two-Week Review Cadence

Short review cycles with explicit kill criteria are the most underused management practice in AI R&D; they turn bets into reversible options and prevent sunk-cost commitment, but they will burn teams out unless leaders treat emotional recovery as part of the process.

Angle

Org process with a leadership caution about burnout and team health

Source video

Project ideas

3

OutcomeSpec

gatehouse

For a fixed set of repository refactoring tasks, an agent given a natural-language end-state spec plus acceptance tests will complete the task with half the required human interventions and at least the same code-correctness rate compared with an agent given explicit step-by-step task instructions.

Proof of concept

Build a small task-driving service that prompts Claude in two modes: outcome-mode (end-state contract) and step-mode (task decomposition). Run it against three single-service repos, collecting traces from execution and human approval checkpoints.

Measurement

Human intervention count, diff correctness score, time-to-task-completion

Source video

AgentAccessA/B

gatehouse

Granting an agent broad write/execute access within a sandbox improves multi-file refactoring task success by at least 30% compared to a narrowly scoped tool-using agent, while the number of critical rollback incidents stays below one per five tasks when an outer review gate is applied.

Proof of concept

Create the two runtime configurations in Gatehouse: one with a small set of editing tools and one with a full shell/sandbox. Run a benchmark migration and refactoring suite, applying an outer-boundary approver for both modes.

Measurement

Task completion rate, normalized test pass rate, rollback incidents per task, mean human review time

Source video

PivotPulse

movement-lab

Teams using a two-week 'persevere or pivot' board will cut the average months spent on failing experiments from over six months to less than three months in a longitudinal comparison.

Proof of concept

Prototype a Kill/Optimize/Pivot tracker for Movement Lab projects: each project enters with a traction target and due date; a dashboard sends a decision prompt every two weeks and logs whether project was kept, killed, or reprioritized, and later links that to outcome.

Measurement

Average time-to-kill, project portfolio ROI, qualitative team energy surveys

Source video

Architectural implications

4

If models perform better from end-state specifications, the agent harness should become an end-state evaluator rather than an interaction shell that forces step-by-step decomposition.

Before

Engineers decompose the task into fine-grained steps and drive the model through them one by one.

After

Engineers write a concise end-state contract and the model owns decomposition, planning, and execution.

Consequence

Human review must shift toward acceptance tests, final diff review, and outcome evaluation; inspecting the model's intermediate reasoning becomes less central.

Source video

The whole-codebase Python-to-TypeScript migration example with monkey-type runtime types shows that type correctness can be deferred while an agent executes a sweeping architectural change.

Before

Large migrations are broken into small, fully type-safe steps because the running system must remain statically correct at every moment.

After

Agents can keep the system executable in an intermediate dynamically-typed form and then tighten types iteratively.

Consequence

Type strictness becomes an incrementally managed property of agent-produced migrations rather than a hard precondition, trading some early safety for end-state velocity.

Source video

The claim that first-generation AI products put models in boxes with limited access and freedom identifies a common architectural mistake.

Before

Models are wrapped as special-purpose tools with limited file system, execution, and tool access.

After

Models receive broad, composable access to real developer environments, with safety enforced through sandboxing, permissions, and outer-loop review.

Consequence

The risk surface moves from 'agent can't do enough' to 'agent can do a lot, so guardrails, observability, and rollback matter more.'

Source video

Multiplayer, asynchronous, and proactive AI interactions imply agents that outlive individual user sessions and act on their own.

Before

An agent exists only in a synchronous chat request-response cycle.

After

Agent services run persistently, receive events, coordinate with multiple human stakeholders, and push results proactively.

Consequence

The application substrate needs durable job queues, long-running runtime semantics, conflict resolution, and user-facing audit trails.

Source video

Tradeoffs and failure modes

3

End-state expression vs agent controllability

Benefit

The model can take large independent initiatives and avoids the brittleness of following human-ordered micro-steps.

Cost or risk

When the human no longer sees the agent's intermediate plan, verification of the final result becomes the bottleneck.

How do we balance code verifiability with AI agent autonomy?
Open source video
Source video

Fast persevere-or-pivot process vs team sustainability

Benefit

Traction-gated shutdowns prevent sunk-cost fallacies and keep the lab portfolio moving.

Cost or risk

Frequent project shutdowns elevate burnout unless time off and emotional acknowledgment are deliberately engineered into the team.

Fast-moving AI environments risk high burnout; encouraging time off and verbalizing emotions is crucial.
Open source video
Source video

Broad agent freedom vs failure containment

Benefit

Models with wider access can achieve architecture-scale results such as full codebase migrations in days.

Cost or risk

A wrong decision will have a much larger blast radius; safety must be designed at the outer boundary instead of by pre-boxing the model.

First-generation AI products put models in boxes with limited access and freedom.
Open source video
Source video

Open questions

4

How do you balance code verifiability with AI agent autonomy when end-state expression hands the agent the entire plan?

Why unresolved

The summary does not specify which checkpoints, guardrails, or review policies catch errors in an autonomously planned and executed change.

Research direction

Compare end-state-only, checkpointed, and human-in-the-loop review policies on large refactoring or migration tasks, measuring defect rate, time-to-merge, and human effort.

Source video

What is the right boundary between human code review and AI-driven development?

Why unresolved

This is central to trusting agents with large-scale changes, but it is posed as an open question in the talk rather than an answer.

Research direction

Design experiments that vary the review unit (line-by-line, diff-summary, acceptance tests only) and measure both product reliability and engineer time.

Source video

Why do models perform better when given an end-state instead of step-by-step delegation?

Why unresolved

The summary reports the effect but gives no mechanism for why it is better.

Research direction

Run controlled evals holding task content constant while varying instruction granularity to isolate whether gains come from planning freedom, fewer compounding errors, or better credit assignment.

Source video

Is the statistic that 60% or more of code is written with tools like Cursor and tags accurate?

Why unresolved

It is flagged as a claim worth verifying and is a market statistic with no clear measurement methodology.

Research direction

Needs a precise definition of 'written using tools', per-language coverage, and an audit of usage telemetry across representative engineering teams.

Source video

Key claims

6
causalVerification needed

Fable and other models perform better when given the end-state to execute on than when managed via detailed task breakdown.

Evidence

Fable and other models perform better when given the end-state to execute on.

Question

What is the measured comparison between end-state prompts and step-by-step delegation on a controlled coding benchmark?

Source video
factualVerification needed

An entire Python codebase can be ported to TypeScript over a weekend using dynamic workflows.

Evidence

Porting an entire Python codebase to TypeScript over a weekend using dynamic workflows.

Question

What was the size and complexity of the codebase, and what was the agent's actual contribution versus human effort?

Source video
comparativeVerification needed

First-generation AI products put models in boxes with limited access and freedom.

Evidence

First-generation AI products put models in boxes with limited access and freedom.

Question

What specific access and freedom limitations were present in early AI product architectures that are absent in current Anthropic workflows?

Source video
factualVerification needed

Anthropic Labs evaluates every project on a two-week persevere-or-pivot cadence.

Evidence

Labs use a two-week review cadence where every project is evaluated to persevere or pivot.

Question

Is this cadence consistently applied across all lab projects, or only a subset?

Source video
factualVerification needed

60% or more of code is written today using tools like Cursor and tags.

Evidence

60% or more of code is written today using tools like Cursor and tags.

Question

What is the source and measurement methodology behind this statistic?

Source video
opinionVerification not requested

The whole industry is still learning how to delegate well to AI.

Evidence

We're all learning how to delegate better.

Source video

Connections

5