{"type":"rich","version":"1.0","provider_name":"Transistor","provider_url":"https://transistor.fm","author_name":"Agents and Engineers: Agentic AI, Software, and Agentic Engineering","title":"Reducing Entropy in Agentic Software","html":"","width":"100%","height":180,"duration":4005,"description":"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.\nThe 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.\nJacob’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.\nAt 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...","thumbnail_url":"https://img.transistorcdn.com/TK0Nqa_Yt1Nidvhw7SvORku00Quhyrr-EpS6aCekMzA/rs:fill:0:0:1/w:400/h:400/q:60/mb:500000/aHR0cHM6Ly9pbWct/dXBsb2FkLXByb2R1/Y3Rpb24udHJhbnNp/c3Rvci5mbS9hMmU5/YmJlYjNlY2E2ZThh/OGYwZmExY2M5MGMz/MDQyNC5wbmc.webp","thumbnail_width":300,"thumbnail_height":300}