Video summary

FORGET Loop Engineering. Agentic Engineering is about THIS

Main summary

Key takeaways

Technology

Summary of Tech Concepts (Loop Engineering vs. Agentic Engineering)

Main Critique: “Loop Engineering” Is Misleading

  • The speaker argues that “loop engineering” is a hype-filled, unclear rebrand of the software development life cycle (SDLC).
  • Instead of obsessing over “loops,” the focus should be on building agentic developer workflows end-to-end.

Core Reframing: Think in “AI Developer Workflows” / “Software Factory” Terms

  • Builds with agents should resemble developer workflows inside a software factory.
  • Actors of value creation (3):
    1. Engineers
    2. Agents
    3. Code
  • Emphasis: the most reliable/cheapest component is code:
    • Code “always runs the same way” (deterministic).
    • Code steps have no token costs compared to LLM-driven agent steps.
  • Reliability order cited: code > engineers > agents.
  • Goal: accelerate beyond the AI industry by prioritizing clarity and simplicity, routing work through structured systems.

Proposed Workflow Structure (How “Scaling Loops” Becomes Workflows)

Base Workflow Pattern

  1. Engineer/agent prompts or plans (planning)
  2. Engineer reviews results (validation)
  • The speaker’s key mapping:
    • Prompting = planning
    • Reviewing = validation

How “Loops” Evolve Into Richer Pipelines

  • Start with a minimal loop:
    • LLM/agent output → code validation (e.g., linter)
    • If validation fails → send results back to a build agent
  • Scale by adding more deterministic code gates:
    • Linting
    • Formatting
    • Type checking
    • Testing
  • Introduce a single “test agent” (consolidated validation):
    • Runs until pass/fail
    • Then routes back to the build agent as needed

Don’t Add More Human Engineering Outside the System

  • Engineers should spend time building the system that builds the system.
  • Avoid manually managing every workflow execution.

Parallelism & Isolation Mechanisms

Work Trees

  • Popular pattern: each agent gets its own work tree to enable:
    • Isolation
    • Parallelism
    • Reduced interference between agents

Agent Sandboxes (Stronger Than Work Trees)

  • Stronger approach: give each agent its own sandbox/computer:
    • Full isolation
    • Engineers can inspect outputs/tests/web pages inside the sandbox
    • Results get merged and shipped

Team / Org Workflow: “Agentic Layer” and Tickets

Ticketing System Integration

  • Use a ticket board (described as “conbon board,” likely a Confluence/Kanban-type tool).
  • Tickets originate from support, product, and engineering.
  • Process described:
    1. Ticket intake → translated into prompts/pipeline inputs
    2. Agents do scout/search (codebase, docs, prior specs)
    3. Plan agent generates plan
    4. Build/test agents run validation
    5. CI/CD executes
    6. Engineer final review → ship

“Agentic Layer” vs “App Layer”

  • Best engineering effort goes to the meta-system:
    • agent prompts/skills/system prompts/routing/orchestration (agentic layer)
  • Ideally, engineers shouldn’t constantly touch the app/product layer once the system works.

Example Use Case: Production Crash / Support Crisis

Crisis Workflow Design

  • Support crisis creates a ticket (via Slack/Teams).
  • A scout agent routes the issue into a hot fix agent optimized for speed.
  • A “hot fix agent” should prioritize:
    • Fixing ASAP
    • Not optimizing for best practices
  • Human-in-the-loop gate:
    • engineer approval/rejection once the candidate fix passes validation
  • Multiple sandboxes run in parallel (“first fastest agent wins”):
    • allocate compute budget to race multiple solutions
    • failures route back into the hot fix process

“Software Factory” Architecture

  • As workflows mature, the system becomes a software factory:
    • Specialized workflows for chores, bugs, features, hot fixes, etc.
  • A factory router agent decides which workflow to execute when a ticket arrives.
  • Workflows choose model/compute appropriately:
    • heavy workflows only when needed
    • use the right “workhorse” vs “state-of-the-art” agents/models per phase

Practical Guidance / Tutorial Points from the Speaker

1) Start Simple (KISS)

  • Begin with a minimal loop:
    • prompt → agent → validation (e.g., lint/build) → feedback loop

2) Separate Agents from Code

  • Don’t blur “skills” (agent reasoning) with actual code execution.
  • Example approach:
    • Use an agent SDK / build agent for work
    • Run lint/type check/tests via code gates
    • If checks fail → send errors back to the build agent using the same session ID
  • Motivation: guardrails, reliable information flow, and test/validation.

3) Run the Workflow Yourself End-to-End First

  • Step through each node:
    • prompt, conditions, function execution, review, ship
  • Use diagrams (mentions Mermaid) to document workflows before productionizing.

4) Use Agents + Code (Not Agents-Only)

  • Code execution provides:
    • speed
    • reliability
    • reduced hallucination risk for deterministic steps
  • Classic engineering patterns still matter (and become more important at scale):
    • isolation, decoupling, single interface

Reviews / Products Mentioned (Not Exactly Reviewed, But Recommended)

  • Speaker sells/markets education:
    • agenticengineer.com
    • Product names: “Tactical Agentic Coding” and “Agentic Horizon”
  • Mentions:
    • 30-day refund policy before “lesson 4”
    • Free blog post: “Thinking in Threads” (covers similar ideas)
  • Tooling:
    • Mermaid / mermaid.live for workflow diagrams

Main Speakers / Sources

  • Main speaker: Dan Eisler (a.k.a. Indie Dev Dan), from his YouTube channel and agenticengineer.com
  • Referenced figures (mentioned without detailed content):
    • Boris Churney (Anthropic)
    • Peter Steinberg (OpenAI)

Original video