Reducing Entropy in Agentic Software

Dan and Jacob Young discuss what technical due diligence looks like when software teams use coding agents. Best practices have not settled, so Jacob looks less for a particular model or tool than for convergence: whether a team and its agents keep moving toward the same grounded idea of what the software should be. Shared standards, existing abstractions, language servers, linters, hooks, tests, and code review all help, but the most useful constraints arrive during development rather than after a huge pull request. The conversation turns to documentation, where Jacob sees a recurring failure mode. Teams create architecture and API documents, then let them drift out of date within weeks. Documentation helps only when the code remains the source of truth and some system can regenerate or update the documents when the code changes. He also argues that security checks belong inside the development and review workflow. Agents can apply codified OWASP practices, but they cannot be trusted to choose cryptographic parameters or recognize a subtle misuse of encryption without expert oversight. Jacob’s broader thesis is that coding agents can increase software entropy. They can quickly turn a cohesive codebase into one with duplicated logic, inconsistent abstractions, and many ways to do the same thing. He is exploring measurements that combine code size, dependency structure, cyclomatic complexity, and duplication, while acknowledging that no universal score exists. Programming-language choice becomes one practical lever. Jacob sees Go’s conventions, standard library, tooling, and small dependency surface as unusually friendly to agents, while Rust’s expressive type system is powerful but still often underused by models at the abstraction level. At the developer level, agents amplify existing judgment. Experienced engineers know what tends to go wrong and can constrain an agent before it creates trouble. Developers without production experience can use the same tools to multiply bad patterns, skip understanding, and drag down a whole team. Jacob recommends that junior developers still write code by hand, learn the fundamentals, and use models as tutors that generate quizzes, flashcards, and problem sets rather than as answer machines. The episode closes on the limits of autonomy. Jacob sees smaller teams gaining leverage by removing toil, but not teams of one replacing every specialist. Models respond best to expertise, while much of what experts know comes from undocumented failures and experience that never entered the training corpus. Working across many agent sessions can also be more tiring because the engineer must watch for many ways things can go wrong. The useful future is still human-centered: people make the decisions and outsource bounded cognitive labor while keeping their hands on the wheel. Full episode notes Click here to view the episode transcript. Chapters (00:00) - What Due Diligence Looks Like in Agentic Development (02:32) - Convergence as a Team Practice (04:19) - Codifying What Good Looks Like (06:30) - Hooks, Linting, and Feedback Timing (08:06) - When Architecture Documentation Drifts (11:19) - Security Reviews and Cryptographic Failure Modes (17:50) - Software Entropy and Measuring Complexity (25:42) - Why Go Works Well with Coding Agents (33:38) - Rust, Abstractions, and Model Limitations (37:50) - Experience as a Force Multiplier (44:16) - Using Agents to Learn, Not Just Produce (52:54) - Greenfield Autonomy versus Brownfield Reality (56:48) - Smaller Teams Still Need Specialists (01:04:12) - The Cognitive Cost of Managing Agents ⠀ Links from the show -------------------- Codex Claude Code Language Server Protocol OWASP Top 10 pandas cyclomatic complexity entropy Don't Repeat Yourself Kubernetes Andy Matuschak ⠀ Guests ------- Jacob Young, CEO & Founder, Sancho Studio Website LinkedIn ⠀ Follow the podcast ------------------- LinkedIn Threads Instagram TikTok ⠀ Follow Dan Gerlanc ------------------- X LinkedIn Threads Bluesky