Video summary

Code with Claude 2026 | London

Main summary

Key takeaways

Educational

Main ideas and lessons conveyed

1) “Learning to code” feeling is returning—now scaled with modern AI

  • Early coding experiences (e.g., programming a TI-83 calculator, tinkering, and HTML for selling Pokémon cards) created a “magic” moment: you build something and it runs.
  • The speaker argues that modern AI coding/agents recreate that same feeling—except now the “calculator” can run complex, distributed systems.
  • This is framed as a new capability pattern: From “distance between idea and running code” getting longer → to collapsing again because AI can instantiate working systems from natural-language descriptions.

2) Model capability is accelerating faster than real-world deployment (the “gap”)

  • Model progress is described as exponential (e.g., Claude generating code, running end-to-end agents overnight, finding long-lived vulnerabilities).
  • Meanwhile, organizations adopt AI more linearly.
  • Developers are positioned as the ones who must translate model capability into usable production systems.

3) Cloud is structured as a multi-layer solution to productionize agents

The keynote breaks the story into layers:

  • Model layer: research/frontier models improving planning, tool use, longer context, and judgment.
  • Platform layer: secure, scalable agent infrastructure (e.g., Claude Manage Agents; controls, observability, sandboxing).
  • Developer experience & workflow layer: Cloud Code (agent views, routines, autofix, verification, async workflows, etc.).
  • Recurring theme: most people will never call APIs directly; they experience AI through products built on top of these layers.

Methodologies and “how to build” instructions

A) Building “agentic” systems: what to design for

  • Close the capability-to-usage gap
    • Assume model capabilities improve faster than adoption.
    • Invest in tooling/architecture that can absorb model upgrades.
  • Design for emerging capabilities, not today’s best-case
    • Build architecture that can take the “next big jump.”
  • Treat model upgrades as a business opportunity
    • Automate evaluations and testing.
    • Do hands-on tests to understand improvements for end users.

B) Frontier model behavior improvements to leverage (from research talk)

Prefer agent behaviors that enable:

  • Planning and reasoning before acting
  • Error recovery / adapting to failure (avoid doom loops)
  • Sustained attention over long runs (long-horizon coherence)

Practical implication:

  • Give models time and use higher “reasoning effort” when needed.
  • Don’t over-fragment tasks purely out of fear of context limits.

C) Cloud Managed Agents: core primitives for reliable agent execution

  • Agent definition (bundle of configuration)
    • system prompt
    • model choice
    • skills and tools
    • permissions / identity assumptions
  • Execution environment
    • sandboxing environment
    • network allowlist / preinstalled packages
  • Session execution + event streams
    • observe user events, agent events, session events, and span events
  • Advanced orchestration features
    • multi-agent orchestration (delegation to specialized agents)
    • outcomes (rubrics/goals guiding iterative loops)
    • memory (long-lived memory stores)
    • dreaming (research preview; reflection/codification across many sessions)
  • Safety/controls
    • human-in-the-loop where needed
    • safe tool execution patterns
  • Key new upgrades announced
    • Self-hosted sandboxes (run code/tools inside customer-controlled infrastructure)
    • MCP tunnels (securely expose private MCP servers without public internet exposure)

D) Cloud Code: workflow-oriented development patterns

  • Developer experience interfaces
    • CLI (including a TUI full-screen mode to reduce terminal flicker and support clickable elements)
    • IDE extension / desktop app
    • agent view for monitoring parallel sessions
  • Verification-first approach
    • Let agents run while you work, but ensure they verify changes (including browser-based checks in demos).
  • Automation primitives
    • Routines
      • schedule or trigger via webhooks/API calls
      • run tasks asynchronously (including GitHub-triggered PR/issue workflows)
    • Autofix
      • listen to review/CI/security events and proactively fix issues so PRs stay green
    • Code review product
      • multi-agent review across changed code/auxiliary files
    • CI autofix
      • diagnose flakes/infra timeouts and fix root causes when possible
  • Asynchronous agent loop concept
    • default becomes: “Claude prompts Cloud Code” and verification completes the loop.

E) Lovable self-healing platform concepts (product talk)

  • Define and detect “stuck” user states (signals like repeated failures or user abandonment).
  • Categorize stuckness into:
    1. fixable by prompting differently / platform-side improvements near the surface
    2. “easy in theory” but the platform lacks the capability (edge improvement needed)
    3. platform gap requiring larger investment (e.g., server-side rendering for SEO)
  • Self-heal mechanisms
    • Lovable Overflow (StackOverflow-like knowledge corpus)
      • inject relevant solution context when users are stuck
      • prune stale knowledge based on success ratio/half-life
    • Venting / send feedback tool
      • agent reports frustration to Slack
      • separate agent filters/deduplicates and opens PRs for engineers to merge
      • results: bug fixes before paging systems catch them; improved platform/tooling reliability
  • Metrics observed
    • reduced “stuck rate”
    • increased “publish rate”
    • multiple production fixes per day and early incident signals

F) “How to get the most out of the Cloud platform” (prompt caching + context engineering + advisor strategy)

This is a concrete methodology with steps.

Step 1: Prompt caching (cost, latency, rate-limit benefits)

  • Measure prompt cache hit rate
    • start with knowing the cache hit rate
  • Implement prompt caching
    • ensure prompt segments are stable so cache keys match
    • avoid breaking caching by changing system prompts over time (e.g., timestamps in the system prompt)
  • Use console analytics
    • see why cache breaks
  • Target performance
    • aim for ~80%+ hit rate (examples given: companies reaching 90%+)

Step 2: Context engineering (keep only relevant tokens)

  • Tool search
    • define tools, but only inject tool definitions when needed
    • reduces context bloat and can improve model performance
  • Programmatic tool calling (curate tool outputs)
    • run a script to summarize/strip irrelevant tool results
    • provide only what’s necessary back to the model
  • Compaction
    • when conversation grows (e.g., ~400k tokens in demo), summarize and remove irrelevant terms
    • continue the conversation “as if unlimited” with bounded context costs
    • optionally choose starting thresholds (e.g., 500k/400k depending on model)

Step 3: Advisor strategy (trade cost vs. intelligence safely)

  • Use smaller executor model most of the time (e.g., Haiku/Sonnet class)
  • When the executor encounters an odd case or risk:
    • request advice from a stronger frontier model (Opus)
  • Benefit pattern:
    • cheaper execution for most tasks
    • expensive model used only for guidance/deep checks
  • Outcome demonstrated:
    • detect “watermelon” cases (green on surface, red on deeper constraint)

Speakers / sources featured (as named in subtitles)

Anthropic / event speakers

  • Boris (Journey) — co-founder / exec introducing the event (spoken as “Boris Journey”)
  • Lisa — Research PM (model foundation/frontier trajectory)
  • Angela — Cloud managed agents / platform talk (appears with Caitlyn)
  • Caitlyn — Cloud managed agents / platform talk (paired with Angela)
  • Kat — Cloud Code features (paired with Boris)
  • Ralph Ramos — Technical staff at Anthropic (what’s new in Cloud Code)
  • Miklas — Spotify (AI transition overview)
  • Michael Cohen — Technical staff at Anthropic (cloud managed agents)
  • Harrison Stall — Technical staff at Anthropic (cloud managed agents)
  • Jeremy Hadfield — Product manager at Anthropic (coding behaviors & model capabilities)
  • Punit Sha — Product manager on Anthropic platform team (prompt caching/context engineering/advisor strategy)
  • Fabian Hadi — Co-founder and CTO at Lovable
  • Jacob Emiling — Staff software engineer at Legora
  • Rebecca — Anthropic go-to-market team (moderator of panel; named as “Rebecca”)

Technical staff / guests / partners mentioned

  • Nicholas Gustiffson — team at Spotify (migration example)
  • Felicia Coruru — Co-founder and CEO of Binty (foster care placement system)
  • Andrew McNamera — Director of Applied AI at Shopify
  • Oscar Mullen — Technology lead at Marcato Libre
  • Luke — from Verscell (in sandbox partner panel)
  • Ivonne — from Daytona
  • Ashot — from Modal
  • Mike — from Cloudflare
  • Ben — CTO at Hero Corp (demo co-presenter)
  • Gabe — colleague in the fictional “Counter” demo (mentioned during demo dialogue)

Panelists (enterprise pivot / Anthropic customers)

  • Rlan Simunov — Engineering Director at monday.com
  • Alex Kusni — Chief Technology Officer at Dr. Lib
  • Rodrigue — Vice President Platforms at Delivery Hero
  • Urik Shifa — VP for tech foundations at Delivery Hero

Other organizations/tools referenced

Spotify, Canva, Lora, GitHub, OpenBSD, Asana, Cloudflare, Daytona, Modal, Verscell, MCP, GitLab, AWS, Vercel, Backstage, Jira, Slack, Gong, GitHub Actions (and similar product/tool names).

Original video