“Forget Loops, build a Software Factory instead” – Dexter Horthy

Tech-focused summary

“Stop playing with coding agents—use them inside a human-led software factory.”

• Agents can solve problems well, but maintainable, trustworthy code requires human “program design” decisions before the agent writes lots of code.
• Core claim: agents improve throughput, but teams must keep the human in control at key decision points.

Program design (Dex’s system) as the missing step

• Before “letting the agent cook,” you specify decisions you might not like later.
• Emphasis on up-front leverage: spend time early to reduce costly rework during PR review and after merge.

Vertical slices / tracer bullets for steering agents

• Instead of building everything end-to-end in one horizontal sweep, build incremental “vertical slices”, e.g.:
  1. mock API endpoint
  2. stub UI
  3. wire data/migrations
  4. business logic
  5. error handling
• Rationale: models tend to produce large changes that are hard to test midway; vertical slices create early checkpoints.

Benchmarks are not sufficient for “agentic coding power”

• Many benchmarks are one-shot tasks and don’t penalize “sloppy code.”
• Major issue: no fast oracle for maintainability/architecture—tests may confirm correctness quickly, but maintainability costs appear later (weeks/months).
• Concern: models can score highly (e.g., SweBench-like tasks) while still producing:
  • spaghetti code
  • overly long diffs
  • unnecessary logging
  • “test gaming” (e.g., modifying/removing tests to pass)

How Dexter evaluates better real-world behavior

• RL-style trace scoring ideas:
  • generate multiple candidate solutions (high temperature)
  • score traces on external correctness + conciseness + verification
  • reinforce good traces and reduce bad ones
• Proposed/mentioned improvements to benchmarks:
  • use held-out repos (models shouldn’t have seen the exact code)
  • simulate multi-step product evolution (roadmap features added gradually)
  • include richer verifiers (golden solutions, “functionally equivalent” checks)
  • use LLM quality judges for style/rules
  • detect fake tests by removing the patch and checking whether tests still fail (to catch “tests that don’t actually test anything”)

Keeping humans in the loop via measurable objectives (“backpressure”)

• If you can provide measurable outputs (e.g., conversions, latency/cost/quality metrics), agents can optimize aggressively.
• Examples discussed:
  • run experiments and automatically select best variants
  • “LLM as judge” for comparing cost/quality/speed after changes
  • agents doing more self-directed testing on newer model generations (without being explicitly told)

CI/CD and incident routing: reducing human interruptions

• Shift from “wake engineers at 3am” to an alarm becomes a pull request workflow.
• Route support/issue intake directly into agent fix pipelines.
• Example implementation described:
  • incident review automation using GLM 5.2 to classify root cause vs action items
  • infra spread across Render.com, Vercel cron jobs, and GitHub Actions
  • automated reporting like “provider outage; cannot fix” vs “missing migration; do X”

Product analytics + AI-assisted UX debugging (PostHog sponsor segment)

• Unify analytics sources in PostHog:
  • events, surveys, error tracking, correlations
• Use session replay; then replay vision watches replays to detect friction.
• The AI opens a pull request with the exact fix, leaving humans to review/merge.
• Also tracks AI inference monitoring details—prompt, response, token cost, latency—per user to see what burns money and which prompts/agents work.

“Light software factory” skepticism

• Idea: avoid reading code and rely on agent tests/automation.
• Counterpoint: even if you skip reviewing many PRs, you may need human understanding later; otherwise you risk “losing touch” with the codebase.
• Proposed mitigation: agent education of the human, including quizzes/visualizations and intentionally slowing when understanding degrades.

“Context engineering” (Dex’s term) and how it changes 2025→2026

• Concept: own and curate the agent’s context window—everything the model sees is tokens in/tokens out.
• Until architectural changes like linear attention arrive, the main lever is putting the right, high-signal tokens in context.
• Dexter’s framing includes:
  • context as the main “primitive” for better results
  • using file-system-native workflows: keep relevant docs/config in the repo so agents can read/edit deterministically
  • attention to “dumb zone” / context anxiety: when sessions get too long and unfocused, results degrade; compact/handoff or restart
• The discussion contrasts:
  • steering (tell the model how you want it done)
  • vs context engineering (how information is represented efficiently)

Bottlenecks vs non-bottlenecks (software factory philosophy)

• Use “The Goal”/factory metaphor: optimize what’s actually the end-to-end bottleneck (often code review, test cycles, deployment friction).
• Stop spending effort on impressive but non-bottleneck improvements (e.g., too much agent orchestration) if production delivery is still slow.

---

Key product/review/tutorial takeaways (what to do)

• Before agent coding: write a PRD/design doc and define measures of success, architecture sketch, call stack, endpoint shapes, and tests/acceptance criteria.
• Build incrementally: use vertical slices so you can verify end-to-end behavior early.
• Don’t trust benchmarks alone: look for held-out evaluations and penalties for slop/maintainability or multi-step feature growth.
• Provide measurable goals: give the agent numeric feedback loops (conversion, latency, cost, quality).
• Route incidents/support to agents: create automation that outputs PRs rather than paging humans directly.
• Use context engineering: keep critical domain knowledge in repo files (e.g., /docs/adr, /docs/external, etc.) so agents can retrieve it cheaply and reliably.

---

Main speakers / sources

• Dexter Horthy (Dex) — software factory / context engineering / program design system
• David Andre — interviewer/podcast host
• PostHog — sponsor segment (analytics/session replay + replay vision)
• Mentions / referenced creators:
  • Dylan Mulroy
  • Matt Pocock
  • Victor Tali
  • Calvin French-Owen
  • Eli Goldratt (The Goal)
  • Jeff Huber (ChromaDB)
  • Andrej Karpathy
  • Tobi Lütke
  • Cognition (benchmark-related discussion)