Video summary

How I Plan, Build, and Run Loops with Claude Code in 40 Minutes | Thariq Shihipar

Main summary

Key takeaways

Technology

Overview

The video is a discussion and demo with Tharic Shihipar (Claude Code team, Anthropic) on using Claude Code “loops” and workflows to make AI agents run longer with better control and verification—reducing issues like premature stopping.

1) “Loops” for long-running agent execution

The team uses “loops” broadly to mean orchestration patterns that let an agent receive feedback and continue working for extended periods.

Key mechanisms mentioned

  • /loop Referenced as part of the toolbox for long-running agent behavior.

  • /goal Used to help the agent remember the exit condition so it doesn’t stop early. Designed for complicated tasks where the agent should keep going until the task is truly complete.

  • Workflows (described as the most powerful pattern) Workflows can:

    • spin up sub-agents to perform work (optionally in parallel),
    • verify results before finishing. This is especially useful for non-technical or non-deterministic tasks by converting them into more deterministic steps.

2) Planning as iterative “unknowns removal” (not one-shot specs)

A major theme: “planning” isn’t simply “one prompt then execution.” Instead, it’s iterative exploration:

  • Investigate what you don’t know
  • Learn edge cases and limits
  • Refine/reprompt until the implementation is reliable

Example: video recognition/editing planning

  • Understand transcription behavior using Whisper
  • Identify edge cases such as:
    • mis-heard “silence”
    • word splitting issues
    • lack of speaker recognition
  • Use that knowledge to avoid building a workflow on incorrect assumptions (i.e., avoid “unknown unknowns”)

3) Concrete demo: video workflow (captions + overlays) using /goal

A walkthrough shows a “non-technical work” pipeline for video editing.

Pipeline (conceptual input prompt)

  • Start from a repo for a podcast recording
  • Transcribe using Whisper
  • Use Reelotion to:
    • generate UI that highlights words individually
    • add overlays
  • Use goal so the agent does not stop until the full video render is produced

Outcome behavior

A “one-shot” attempt can:

  • automatically generate transcription
  • generate caption + overlay assets
  • continue rendering until “fade to black”

Noted imperfections and improvement direction

  • Overlay placement can depend on where the agent believes the hand is pointing
  • Improvement suggestion: add more metadata, such as tracking fingers/face, to improve alignment accuracy

4) Using artifacts: HTML as a reusable, reviewable planning object

The team relies on Artifacts, specifically HTML artifacts, as a shared medium for planning and iterative design exploration.

Why artifacts matter

  • Claude generates an artifact (e.g., plan/report/PR/status/incidents)
  • Humans/teams can review and collaborate on it

In the demo

  • Claude generates overlay style HTML with multiple design variations

Emphasis

  • The design doesn’t need to be “pretty”—it must be readable and usable for decision-making.
  • A failure mode: people may “glaze over” long markdown plans, so HTML/design exploration improves understanding.

5) Specs evolve with implementation (back-and-forth, not handoff)

Instead of a one-time handoff:

  • The agent may discover unexpected issues during implementation
  • The agent is asked to keep implementation notes as it goes
  • The team can then respec/revise if needed

This creates a loop: spec → implementation → revised spec

6) Skills vs repositories vs workflows (and what to use when)

Guidance on structuring work:

Skills

  • Packaged instructions
  • Sometimes used to generate a workspace or a “video editing harness”
  • For repeated pipelines (e.g., thumbnail/post workflows), chaining skills is common

Workflows (vs plain scale/one-off runs)

Workflows are useful because they:

  • enable sub-agent fan-out (e.g., generate multiple clips in parallel)
  • keep context cleaner per subtask
  • add verification using a rubric
  • reduce “self-referential bias” by separating roles:
    • a coordinator agent chooses tasks
    • worker agents generate outputs
    • verifier agents assess outputs against rubrics

7) Slash/Slack usage and “multiclothing”

The speaker describes how Claude work is operationalized across products:

  • Cloud Code: terminal/desktop sessions for execution and iterative coding
  • Cloud Tag: Slack threads, DMs, and team/project channels

“Multiclouding” means multiple tasks run concurrently, for example:

  • one active Cloud Code session
  • several Cloud Tag sessions in the background (PR babysitting, fixing tests, tagging reviewers, etc.)

There’s also ongoing work on how to trigger features like “scale” when using Cloud Tag.

8) Product/behavior improvement: trimming system prompts/context

A specific internal change is mentioned:

  • Their Cloud Code system prompt was cut by ~80%
  • Rationale:
    • models work better with fewer examples
    • fewer constraints
    • and more free context

Why: examples can unintentionally constrain behavior, and strict “never” constraints can be counterproductive compared to “prefer/usually don’t.”

9) Learning agents: get technical by learning trade-offs/constraints

Advice for viewers who want to become more technical:

  • Not about TypeScript syntax
  • Instead, learn the constraints and trade-offs behind:
    • backend services
    • libraries for video encryption/transcription
    • local vs remote implementations

Claude can help brainstorm/teach, but the process requires effort—“education should feel like work.”

10) Repo cleanup / organization

There are utilities like “simplify” to clean up messy workspaces.

Organization is framed as:

  • more about improving the user’s comfort
  • less about being strictly required for the agent

However, repeated tasks can accumulate “slop” without periodic review/cleanup.

Main speakers / sources

  • Tharic Shihipar — Claude Code / Cloud team (primary demo and explanations)
  • Peter Yang — host/interviewer (drives questions and examples)

Additional mentions (contextual, not primary speakers):

  • Jared — Rust rewrite + workflows
  • Boris — mentioned with “simplify” and other product commentary
  • Jess — used as an example for an interview skill

Original video