"Stop prompting, start building LOOPS." - swyx

AI products must be ROI- and human-driven, not token-driven

• Token-heavy use is easy to “max,” but that doesn’t guarantee value.
• Warning: shipping “slop” (junk code/config/features) can make apps unusable and can kill startups even if token usage is high.
• Core management mindset: spend tokens only when real target users are actively using the app.

Adoption & usage reality check (tokens as a business signal)

• Example proxy program: “token billionaire”
  • Spend: 1B tokens/week
  • Expected: ~50 people out of ~7,000 attendees
  • Actual: ~300 “token billionaires”
  • Takeaway: token spend may be growing, but ROI/efficiency varies widely.
• Claimed frontier usage example from “cursor”/labs:
  • 8–10B tokens/day
  • (Speaker notes “8 is very high,” but implies it happens.)
• Business implication:
  • Free tokens → more exploration
  • Once patterns emerge, engineering teams must focus on efficiency, quality, and usability.

Agent operations: manage “threads” but keep a verification loop

Recommended working model (behavior/ops)

• Keep one high-focus task while running multiple background tasks for repetitive work/research/prototyping.

Tooling trend

• IDE value declines:
  • shift toward file editor + review workflow (vs IDE-centric development)
• Emphasis on agent-based coding workflows:
  • e.g., “Codex”/terminal-first vs richer GUIs

Concrete example: Slack + DevOps/agent workflow

• Bug reporting → direct line to the CTO (an operational shortcut)
• Mentions Devon and terminal multi-agent coding tools (e.g., “Mox”)
• Suggests a pragmatic multi-tool stack.

Product interface strategy: choose visualization level based on team cognition

Suggested spectrum

• Flat list / board / conductor-style view
• Full graphical simulation UI (example: AgentCraft / “Warcraft-like” simulation)

Principle

• Visualization helps when it matches how your brain thinks; otherwise threads + lists are enough.

Where AI labs vs “agent labs” should play

(strategy: model choice vs domain execution)

Two categories

• Model labs
  • Accumulate GPU research to pursue frontier/AGI
• Agent/domain labs (e.g., Cognition)
  • Solve domain-specific enterprise coding
  • Can train/continue-train models for coding use cases

Training insight (execution/engineering, not investing)

• Emphasizes continue training / post-training becoming stronger vs “thin fine-tune layers”
• Mentions compute parity ideas:
  • post-training compute may approach pre-training compute
  • Example claim: Composer disclosures ~4x compute pre-train vs post-train

Prompting → loops: a “loopcraft” operating system

Central playbook

• Move from writing prompts to writing agent loops.

Loopcraft framing

• Loops that generate prompts/outputs repeatedly until done (conditions/termination)
• Loops that generate loops (meta-automation)

Checklist for a “great agent loop” (speaker-derived)

• Enough specification: agent must know what you’re looking for
• Verification/termination: how to know when “done” and what “good” looks like
• Explicit “what not to do” (often omitted):
  • Prevent pathologies like massive unmaintainable code dumps (e.g., 10k-line files)
  • Use garbage collection/refactor/deduplication patterns periodically
  • Add output self-review (e.g., verify UI behavior like mobile vs desktop)

Common anti-pattern

• “One-shot everything” and assume output is correct without checking.

Baseline “agent SDLC” loops to implement first (actionable operations)

1. Grill me / interview me loop (weekly; more “rhythm” than literal loop)

   • Model interviews the user to extract requirements
   • Treats humans as bad at articulating forks/constraints
   • Forces structured clarification

2. Competitor research + idea brainstorming loop (weekly)

   • Generate 3 ideas, prototype, implement
   • Accept that ~most code is trash
   • Key: logging/feedback so wins compound

3. Close the SDLC (self-healing direction)

   • Connect production logs / error logs to the agent
   • Agent reads logs and proposes/responds with fixes
   • Goal: self-healing app (detect bug → propose fix via loop)

4. Goal-driven optimization loops (multi-month)

   • Example goals: more sales, more conversions, more time on site
   • Treat like continuous experimentation using a loss function
   • Rollback-friendly iterations described like “gradient descent” over outcomes

Long-project risk management

• Avoid losing understanding of the codebase/data layer after big agent-driven efforts
• Ensure deep grasp of:
  • what data gets recorded
  • how it’s reported
  • what the UI/workflows can act on
  • frequency/access patterns of key data
• For serious production longevity: invest in the data layer and system invariants.

Human testing remains non-negotiable (quality & UX ops)

Agent limitations called out

• Doesn’t naturally apply “human intuition” for UI/behavior (e.g., button placement on resize, validation placement)
• Doesn’t handle “trust & control” expectations well:
  • audit logs
  • org/team structure
  • access patterns

Management directive

• Have real users dogfooding + manual testing clicking through every button
• Ask continuously:
  • “Is this what users actually want, or what the model felt like coding today?”

Product strategy warning

• Incentives can cause too many configuration options
  • users partially use them
  • users delete features
• Design for selectivity and taste.

Founder/leadership strategy: “taste,” honesty, and mission framing

Taste = selectivity + craftsmanship

• Don’t ship everything the model can generate
• Premium comes from minor design details and disciplined scope

Founder traits (framework, implicit)

• Don’t lie about capability/benchmarks
  • e.g., claims like “small model beats Fable class”
• Be mission-driven, not competitor-scoring
  • explain why (first principles, long-term human/company mission), not just “we’re better”
• Share only the most relevant “trace secrets”
  • a few key insights vs a full marketing dump

Hiring leadership tactics

• Build a mix: experienced supervisors + younger creative/spiky builders
• Use work trials (e.g., 1–3 months) before hiring
• Hire carefully and fire quickly if a hire is net negative (bad hires drag performance)
• In-person hiring still matters for subtle signals missing on Zoom.

GTM/recruiting narrative strategy (high-level)

• Successful founders “teach” the market with coherent vision and roadblocks/insights—not only benchmarks.
• Mission helps recruitment:
  • people support good missions even after setbacks or delayed deadlines.

Near-term execution outlook (business impact of faster inference)

KPI/throughput direction (speaker examples)

• Historic: 50–100 tokens/second
• New hardware (Cerebras examples): ~1,000 tokens/second
• Demos: 10,000 tokens/second to hundreds of thousands tokens/second

Business implication

• Product patterns change when inference cost/latency drops by orders of magnitude
• Enables more agentic workflows.

Presenters / Sources

• Presenter/guest: swyx (interviewed founder; described as founder of the biggest AI engineer conference)
• Interviewee: not explicitly named in the subtitles
  • quotes include: “I think…,” “I published it…”
  • references being an adviser/customer to Cognition / CTO line / agent-lab thesis on Latent Space
• Mentioned sources/figures/tools: Boris Churnney; Tariq Shipar (field guide to Fable); Sam Altman; Elon Musk; Bejian Stostroke (C++ creator); Versel; Supabase; Black Forest Labs; Thinking Machines; Core Automation; Flappy Airplanes; Engram; 11 Labs; lovable; Modal; E2B; Daytona; MCP/REST/GraphQL; Codex/Cursor/Devon/Mox; Warcraft-like simulation UI concept; Latent Space newsletter/podcast; AgentCraft