Video summary

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

Main summary

Key takeaways

Technology

Summary of technological concepts & product/engineering takeaways (Anthropic / Claude Code)

Treat Claude as a “thought partner,” not just an autopilot

  • Best practice for onboarding/usage:
    • Provide the right context.
    • Ask whether Claude can do the task.
    • Iterate on system-level steps.
  • Key shift: move from “build the product” to “build the system that builds the system” (higher abstraction).

Onboarding changes: less technical ramp-up, more cultural/social

  • Claude can cover many “trivial setup” gaps via Q&A.
  • Onboarding buddies still matter for:
    • Team context
    • How work gets approved
    • Social/cultural alignment

Why internal experience can differ from external AI perception

  • The speaker argues enterprise teams often don’t directly “type code all day” anymore; work is higher-level.
  • They emphasize:
    • Automation investment has risk/cost.
    • Model capability improvements increase the likelihood ROI over time.

Knowledge work is increasingly “reducible to code”

Recommended examples:

  • Accounting via Python scripts instead of Excel
  • Video editing via FFmpeg and libraries

General idea:

  • If tasks can be expressed as code steps, code agents (e.g., Claude Code) can do substantial work.

Harness engineering is load-bearing even as models improve

  • The harness (tools, workflows, safety, permissions, sandboxing, verification) becomes more complex as models run more autonomously.
  • Example: Auto Mode / Auto Code
    • Requires a more sophisticated permission model and safety.
    • Runs can last hours, not minutes.
  • Artifacts matter because they’re more than output:
    • They act as a form of structured prompting that helps Claude represent long-running work.

Autonomy and “fully autonomous changes” depend on what counts

  • Different functions vary:
    • Designers may contribute assets (e.g., Figma), which Claude Code can leverage via MCP.
  • Anthropic’s goal:
    • Claude handles more glue work.
    • Humans focus on unique daily work and decision-making.

Limits of “one sentence ticket → don’t interrupt until done”

  • Works only when the ticket/spec is already well-shaped.
  • Real GitHub issues often have:
    • Ambiguity
    • Multiple concerns
  • Autonomy fails when users don’t provide enough structure/unknowns.

New work replacing old “write React line by line”

  • Intern-style tasks shift from implementation toward:
    • Research and measurement
    • New processes such as evals across large user bases
    • Trade-offs and verification

Computer/browser use: better, but still edge-case heavy and latency-limited

  • Reported issues:
    • Stuck flows (e.g., inability to type passwords due to integrations like 1Password)
  • Latency framing:
    • Computer interaction is harder than code because it resembles a state machine
    • Less control and harder reversibility

Loop engineering / workflows

  • “Loop engineering” means:
    • Instead of prompting each time manually, build a system that repeatedly prompts/monitors (often via Claude Tag and scheduled automations).
  • Example workflow concepts:
    • Daily triage/feedback
    • Morning loops that check fired events and suggest ideas
    • Monitoring funnels and improving them
  • Trade-off:
    • Setup can be expensive.
    • Verification + value-focused loops can increase velocity.

Where the industry is headed: loops across the full SDLC

  • Claude Code ≈ implementation
  • Claude Tag / Claude-as-agent ≈ broader SDLC:
    • Feedback
    • Code review
    • CI/CD incidents
    • Incident “babysitting,” etc.
  • Expect more generative interfaces using artifacts:
    • Interactive reports, plans, diagrams, code snippets

Artifacts explained as interactive web app-like outputs

Claude artifacts can:

  • Display plans (diagrams, file snippets, schemas)
  • Present reports readable on devices (e.g., phone)
  • Call MCPs to fetch data and render views
    • Example: inbox reading/tagging
  • Core emphasis:
    • Move beyond text-in/text-out
    • Stay in the loop

Model usage philosophy: planning/implementation split

Rather than “always pick the smartest model,” use models by role:

  • Fable (smaller/planning) for:
    • Planning/brainstorming/spec discovery (finding unknowns)
  • Opus 5 (larger/execution) for:
    • Implementation
  • Harness/verification reduces the need to obsess over model switching.

Prompting skill is broader than “write a prompt”

What matters is the accumulated setup:

  • Skills
  • Verification harness
  • Added context/data

Example improvements:

  • Remove ~80% of system prompt in Claude Code
  • Remove examples from tool descriptions (examples were often negative and counterproductive)

How to “nudge” compute usage

Instead of generic advice (“believe in yourself”), explicitly grant permission to:

  • Use workflows/agents
  • Brainstorm first, then execute
  • Run overnight (with goals)

Note:

  • Default model behavior tends to be efficient/fast; deeper work requires steering.

Verification and evals for product changes

They use:

  • User metrics (e.g., how much people like outputs)
  • Internal/external evals across tasks

Hard problem:

  • Some undesirable behaviors may not be caught by typical evals
    • Example: telling users to “go to sleep”

Style/taste control for subjective domains (e.g., UI/design)

Recommended approach:

  • Stay in the loop and supply references in machine-readable formats:
    • Figma > screenshots for extracting attributes (e.g., border radius)
    • HTML mockups > images for iteration

The hard part:

  • Knowing when output is “good enough” requires domain expertise (“becoming more tasteful”).

Code ownership/maintenance under high code generation

Maintenance emphasis shifts:

  • Less focus on superficial style/naming
  • More focus on:
    • Verification harnesses
    • Scaffolding
    • Vision for what the codebase is good at

Testing recommendations:

  • About ~100x more testing code than before
  • Use:
    • Fixtures/mocks
    • Storybooks
    • Production-data-derived fixtures

Human element still matters:

  • Direction
  • Replay/undo in multiplayer
  • Decisions about code evolution

Caution on tech debt waiting for “next model”

  • Deferring some refactoring/tech debt can be reasonable if the timeline allows it (startup-style: deliver value in months vs. years).
  • But it depends on circumstances—deliver value on short cycles.

Reliability with higher velocity

  • Increased AI-driven code volume correlates with more incidents/sevs in large orgs.
  • Countermeasure theme:
    • Build the “dream testing + deployment environment,” including:
      • Replay requests
      • Chaos testing
      • Fixtures and mock databases
    • Use Claude to improve uptime.

Internal tooling culture

  • Many engineers maintain custom scripts/tools/harnesses.
  • Claude Tag scheduling examples mentioned:
    • Personal scheduling
    • Email workflows
    • Multi-tenant/display setups for viewing multiple Claude Code sessions
  • “Hackable” tooling is encouraged so people create variants.

External visibility and career advice

  • Strong recommendation:
    • Share work externally (Twitter/X, Reddit, etc.)
    • Write about shipped projects
    • Treat it as expanding your “luck surface area.”
  • Authentic posting/engagement beats “ask an AI to generate everything” shortcuts.
  • Still learn fundamentals:
    • Computer systems, constraints, memory allocation
    • Backend services, etc.

Sponsorship note (mentioned in subtitles)

  • Work OS described as an API layer to quickly implement enterprise SaaS requirements such as SSO, SCIM, audit logs, rather than building them from scratch.

Main speakers / sources

  • Thariq Shihipar — interviewer/host (asks questions)
  • Dark — engineer at Anthropic (cloud code team; primary interviewee)

Original video