Video summary

Stop Prompting Claude. Start Loop Engineering.

Main summary

Key takeaways

Technology

Main idea / thesis

  • The speaker argues you should stop “prompting coding agents” repeatedly and instead build “loop engineering”: create loops that repeatedly run until a goal is reached.
  • This is supported by quotes attributed to:
    • Boris Cherny (Claude Code creator): “I don’t prompt Claude anymore. My job is to write loops.”
    • Peter Steinberg (Open Claude creator): same concept—design loops that prompt your agents, not manual repeated prompting.

Video breakdown: “Loop Engineering” in 3 parts

Part 1 — What a loop is + when to use it

Loop vs normal prompt

  • A normal prompt runs once and stops.
  • A loop runs over and over until a specific task/goal is complete.

4-condition test to decide whether to build a loop

  1. Does the task repeat?
    • If one-time: use a prompt instead.
  2. Is there a clear definition of done?
    • Loops should have a way to quantify/verify completion.
  3. Can you afford to be wasteful?
    • Loops may repeatedly call the model → higher token usage; you may need limits/strategy.
  4. Does the loop have all necessary tools?
    • Example: when building a website, the loop should be able to check it loads/accesses correctly.

Included tutorial element

  • Mentions a prompt to audit your workspace and rank loop candidates using the 4-condition test.

Part 2 — The four building blocks of successful loops

  1. Trigger

    • Starts the loop. Three “simplest ways”:
      • /loop: runs at a set interval locally (stops if laptop is closed).
      • /schedule: runs automatically in the cloud on a cadence you choose.
      • Custom loop orchestration skills: create a single “orchestration” skill that kicks off the full loop (example: /check weather loop).

  2. Execution skills (most important block)

    • Execution skills are specialized, reusable instruction sets Claude can run consistently.
    • Key rule: don’t build loops without battle-tested skills behind them.
    • Example: without a specialized /analyze workout skill, the system might make wrong decisions (e.g., “cancel run because raining”); with the skill, it follows your preferences.

  3. Goal + Verification

    • Must be paired: you need what “done” means and a rule to confirm it.
    • Technical verification example
      • Goal: “Launch a website to this domain and ensure it loads in under 2 seconds.”
      • Verification: AI checks load time + verifies content visibility + uses an approval skill (e.g., /engineer review skill) to approve changes.
    • Non-technical verification strategy (“art, not science”)
      • Bridge abstract outcomes to something verifiable using skills.
      • Example: /draft emails loop
        • Verification includes checks like draft existence plus results approved by:
          • /email review skill
          • /writing voice skill
          • /fact checker skill
    • Anti-bias pro tip
      • Use separate analysis or multiple agents to verify output (mentions a Codex plugin / sub-agents).

  4. Output + Memory

    • Output: what the loop produces (docs, code updates, site changes, messages, etc.).
    • Memory (often missed):
      • Loops start from scratch unless you record what happened.
      • Recommend saving history/lessons learned (example guidance: write notes to a markdown file).
    • Quote principle: “The agent forgets, the repo doesn’t.”

Included tutorial elements

  • Prompts are referenced for:
    • creating an orchestration skill
    • finding which existing skills make sense
    • converting a normal skill into a verification-capable skill
    • enforcing separate agent verification
    • updating orchestration skills to write output/memory to a document

Part 3 — How to build your first loop today (even non-technical)

Core method

  • Start small with something you’ve already done successfully.
  • Apply the 4-condition test; if it passes, build the loop.

Included “starter prompts”

  • If you have an idea: a prompt that builds a loop incorporating all concepts from the video.
  • If you don’t know what to build: a prompt that uses past session history to identify loop candidates via skill-driven loop development.

Guardrail: “loop training mode” / testing mode

  • Early runs should pause at every step for your approval to avoid wasting tokens and to confirm correctness.
  • After you trust it, you can turn testing mode off to save time/money.

Rule of thumb for less-quantifiable goals

  • Break loops into smaller goals with human verification checkpoints.
  • Otherwise the AI can go off course—especially for non-measurable tasks.
  • Analogy: planning a party requires checkpoint decisions (theme, venue, date); loops need similar checkpoints.

Encouragement

  • The speaker frames loop engineering as building “problem-solving muscle,” encouraging building an orchestration skill for something small.

Main speakers / sources

  • Boris Cherny — creator of Claude Code (quoted conceptually about writing loops instead of prompting).
  • Peter Steinberg — creator of Open Claude (quoted conceptually aligning with the “build loops” stance).
  • Primary narrator/speaker of the video — the YouTube presenter (not explicitly named in the subtitles).

Original video