Just stop looking at the code - Kent C. Dodds

Main themes (agents, “software factories,” and consistency)

• Avoid “surprises” and nondeterminism: Kent argues that autonomous agent work should be deterministic where possible, so outputs are repeatable and safe for real business use (not “randomly different” results every run).
• Shift focus from coding to problem/product outcomes: Instead of hand-crafting code, teams (or individuals) should love solving users’ problems and rely on agent-driven systems.
• “Slop is a choice”: Poor outputs come from avoidable decisions; good systems use craft + repeatable primitives rather than ad-hoc one-offs.

What Kent C. Dodds builds: Kodi (aka Cody)

• Kodi is an MCP server (not “an agent” itself).
  • Kent’s analogy: the agent is like a person; Kodi is the agent’s “smartphone”—a place where agent tool access becomes dependable.
• Runs in the cloud for safety and uptime
  • Designed to run autonomously without requiring a continuously-on local machine.
  • Does not expose secret tokens to agents (to prevent accidental leakage via bugs or misdirected calls).
• Execution model: deterministic “software factory”
  • Agents create work, but Kodi turns it into durable, repeatable software rather than repeatedly executing nondeterministic token workflows.
  • Triggered via webhooks or cron jobs.

“Primitives” as the core architectural concept

Kent treats primitives as Lego-like building blocks that make features predictable:

• Span data models, infra, auth/authz, UI components, styling, infrastructure utilities, etc.

Why primitives matter for agents

• Without strong primitives, agents may produce inconsistent patterns (each agent making its own design choices).
• With good primitives, agents assemble features coherently and users don’t experience “fix in one place but broken in another” fragmentation.

Example: consistent reporting

• Kent wants agent-generated reports to render consistently (e.g., read as HTML) rather than varying formatting/structure/language every time.

Primitive layering (agreement with Joel’s framing)

• Even higher-level UI components can be primitives if they’re reusable without modification.

Practical analogy

• Lower-level utilities up through frameworks/platform are layers in an abstraction “layer cake.”

How Kodi achieves safety + repeatability (security mechanisms)

Kodi uses MCP tools with a model where:

• search = read-only discovery of available packages/primitives
• execute = agent can run code, but inside controlled environments

Cloudflare-based sandboxing

• Code is executed in a dynamic worker environment.
• Kodi bundles the code with allowed packages, then lints it for type errors to provide better error feedback.

Secret handling via request interception

• Kodi intercepts outgoing fetch requests and checks for authenticated markers.
• It validates:
  • the secret exists, and
  • the destination domain is approved for that secret.

Kent acknowledges a residual risk: agents could potentially exfiltrate data by writing code that intentionally sends sensitive data elsewhere—so some trust remains, but exfiltration is constrained/guard-railed.

Operational model: agent counts, orchestration, and bottlenecks

Scale/concurrency

• Kent reports typically running ~6–10 agents at once directly.
• With orchestration, he can reach ~40 agents concurrently, including sub-agents.
• He uses a “conductor” concept to spawn sub-agents in isolated cloud environments.

Big bottleneck: human input

• The constraint is not compute; it’s that he doesn’t have time to dictate every idea to a phone.

No hard theoretical limit

• He suggests thousands of agents could be feasible given good primitives and a solid “software factory” foundation.

Testing, deployment, and review automation

Current practice (for Kodi)

• For many incoming tasks, Kodi work is automerged with bot-based reviews.
• Uses Sentry:
  • Sentry root-cause analysis triggers webhooks to Kodi.
  • Kodi spawns a Cursor Cloud agent to fix issues.
• Higher-risk changes (e.g., adding primitives / major system direction shifts):
  • Kent reviews system diagrams/communication to ensure correct direction.

Deployment gating plan

• Currently trusts early access usage (no major issues beyond a DNS migration).
• Plans feature flags/nightly releases once user numbers grow.

Product restraint: pruning complexity in primitives

Kent emphasizes active pruning to prevent “fractal sprawl” of features/abstractions:

• remove unused features
• delete overlapping abstractions
• delete primitives ruthlessly

Concrete example

• He removed/changed the “connector” primitive because users were confused by it.
• Replaced it with a simpler, more secure approach:
  • use an MCP server plus Cloudflare Tunnel with Zero Trust / Cloudflare Access,
  • enabling him to delete an entire primitive while maintaining security.

Responsibility/ownership for agent actions

The discussion highlights a key accountability distinction:

• Agents themselves lack human ownership/concern about consequences.
• Therefore, a human accountable party remains responsible for harm or operational impact.

Kent’s stance: humans (operators) are still the accountable owners; agents can’t fully carry legal/ethical accountability.

Learning and teaching: “taste” / product engineering

Kent argues:

• Implementation may be automated, but product decision-making and system design remain the last durable skill.

Teaching via simulations

• Product engineering can be taught via simulations:
  • meetings are central
  • evaluate codebases/primitives
  • practice constraints, user research, and agent-assisted decision-making

Workshops and tooling

• Mentions “Epic Product Engineer” workshops.
• Notes Zephyr provides a multi-role agent simulation environment (Discord-like) to practice frameworks (e.g., Mom Test, Jobs theory, Kano model, OST/solution mapping).

Key “tutorial/guide-like” takeaways embedded in the talk

• Build deterministic, repeatable outputs from agents (avoid nondeterministic “token docs” as the final form).
• Invest in primitives (design-system-like approach) so agents assemble coherent systems.
• Convert agent processes into durable software (security + performance + predictability).
• Use guardrails for secrets and allowed network destinations.
• Automate low-risk fixes; keep human review for high-risk architectural changes.
• Maintain “product restraint” by deleting primitives that confuse users or add unnecessary surface area.
• Avoid nitpicking code; review systems/diagrams/diffs and primitive boundaries instead.

Main speakers / sources

• Kent C. Dodds (primary speaker; author/engineer, builder of Kodi/Cody)
• Joel (interviewer; recurring questioner)