Dexter Horthy: Why We Stopped Trusting AI to Write the Plan

The podcast discusses the evolving landscape of agentic coding and AI-driven software development, highlighting both the potential and pitfalls of relying on AI for system design and implementation. Early attempts at agentic development often resulted in overly complex, unmaintainable codebases due to unchecked AI autonomy, leading to performance degradation and technical debt. These challenges underscored the need for human oversight, especially in architectural decisions, as AI models lack the judgment to balance simplicity and functionality effectively. As a result, teams have shifted toward rebuilding systems with simpler, more deterministic foundations - emphasizing real-time data sync, unidirectional data flow, and maintainability over clever but fragile designs.

Over time, best practices in AI-assisted development have evolved to focus on intent capture, context engineering, and structured planning rather than full automation. The role of specifications is increasingly central, with a vision of executable, verifiable specs replacing traditional code as the primary development artifact. While AI can accelerate prototyping and task execution, challenges remain in ensuring long-term code quality, particularly as current models struggle with sustained maintainability despite improvements in generation accuracy. The discussion also explores the importance of codifying engineering "taste" - subjective preferences and policies - through automated agents and deterministic detectors, advocating for a hybrid approach where human insight guides AI implementation. Ultimately, the future of software development may center less on writing code and more on defining outcomes, refining feedback loops, and building systems that compound improvements over time.

• What if you codified your engineering taste into automated review agents?

  • Move: Identify 3 recurring code quality preferences (e.g., no nested APIs, max file length, error handling style), then build a GitHub Action with a lightweight LLM agent to flag violations in PRs. Use deterministic rules where possible and supplement with short-context prompts focused only on those policies.
  • Why Now?: AI models still struggle with long-term maintainability, and generic outputs lead to undifferentiated systems; capturing your unique taste now creates a defensible edge before tools standardize.
  • Expected Upside: Reduces drift from AI-generated "slop code," ensures consistency without manual reviews, and compounds quality by preventing bad patterns from entering the codebase.

• What if you shifted from reviewing code to verifying executable specs as your primary output?

  • Move: For your next feature, write a verifiable spec in markdown that includes acceptance criteria, data schema, and expected behaviors - then have an AI generate code against it. Set up automated checks (tests, linters, schema validation) that must pass before merging. Treat the spec as the source of truth, not the implementation.
  • Why Now?: The industry is moving toward spec-driven development where prompts and intent matter more than raw code; starting now builds muscle memory for future AI factories while reducing rework.
  • Expected Upside: Lowers review burden, enables parallel work, and creates reusable, auditable artifacts that improve alignment and reduce regressions over time.

• What if you treated your existing codebase as the main prompt for all AI development?

  • Move: Before any new AI-assisted coding, extract and curate a 32K-token context bundle of your most critical files (schema, core workflows, key patterns), strip away technical debt examples, and use this as the foundational context for all agent sessions. Rebuild this bundle weekly.
  • Why Now?: Models degrade when exposed to bloated or inconsistent contexts ("dumb zone" effect); actively managing input context prevents AI from amplifying bad patterns at scale.
  • Expected Upside: Improves output relevance, reduces debugging time, and aligns AI-generated code with actual architecture - turning your codebase into a self-reinforcing, high-signal feedback loop.

• Implement strict architectural guardrails early by manually defining core systems (e.g., data models, unidirectional flows) before introducing AI agents to prevent over-complexity and maintainability issues.
• Replace ad-hoc prompting with structured spec-driven development: write executable or verifiable specifications as the primary artifact, then use AI to generate code from them, reducing rework and alignment gaps.
• Build lightweight, automated maintenance agents (e.g., linters, policy enforcers) that run nightly via CI/CD to detect and correct deviations in code quality, style, and architecture based on codified team preferences.
• Focus planning effort proportionally on high-leverage decisions (e.g., database schema, API contracts) while accepting higher rework risk for low-impact areas - use a spectrum from YOLO prompts to full specs based on task criticality.
• Curate context deliberately in AI workflows by summarizing intent into concise markdown plans (<100K tokens) and using sub-agents for modular tasks, avoiding cognitive overload and performance degradation in long-running agent sessions.