Dan Gerlanc

Agents and Engineers | Agentic AI, Software & Agentic Engineering

A Technology and Business podcast Explicit

About the show

The podcast about agentic AI, agentic software engineering, and entrepreneurship. Each episode is a conversation with people building with agentic AI. Join me as I follow the stories, the behind-the-scenes, and the people behind the code. About your host, Dan Gerlanc: Dan brings his experience as a 4x founder with 20 years of experience in ML and software to find unique insights on the impact of AI in tech, software engineering, and entrepreneurship.

Newest episodes

Delegation, Agent Router, and AI Traffic

Nov 10, 2026 1 hr 29 min

Erica Hughberg is a software engineering leader, speaker, and community advocate at Tetrate. She maintains Agent Router, formerly Envoy AI Gateway, working on documentation, the website, and community. Dan and Erica compare coding agents with engineering management, from delegating work and taking responsibility to planning and reviewing the result. They discuss missing system context, authentication mistakes, and how subject matter experts can use agents to build and learn, including a researcher's move from SPSS to R. Erica explains why she uses a scheduled Claude task for project triage and when a separately deployed agent might make sense. She also introduces Agent Router and its Envoy foundation, tracing the demands of inference and MCP traffic through provider failover, large payloads, long-running requests, and the hardware that moves and processes them. Full episode notes Transcript Chapters (00:00) - Engineering management as preparation for agents (06:38) - What agents miss about teams and systems (14:16) - Planning more and testing uncertainty (20:11) - Authentication mistakes and checking data work (23:16) - Helping a researcher move from SPSS to R (28:35) - A seven-year-old builds a game (31:14) - Learning engineering with agents (40:53) - Who needs to build and deploy an agent? (51:09) - Choosing among open source projects (53:51) - Agent Router and the engineers of arrows (58:16) - Inference costs, failover, and proxy foundations (01:04:23) - Large payloads and encryption hardware (01:10:51) - Long requests, event loops, and proxy history (01:18:54) - MCP multiplexing and session management (01:23:46) - Payload limits and planning proxy capacity ⠀ Links from the show -------------------- Agent Router Envoy Proxy OAuth SPSS R Lovable Cloud Run Kubernetes NGINX C10K problem NVIDIA BlueField DPUs eBPF MCP ⠀ Guests ------- Erica Hughberg, Maintainer of Agent Router and Manager at Tetrate LinkedIn GitHub ⠀ Follow the podcast ---------------...

From Python Core to Personal Apps: Working with AI Agents

Nov 3, 2026 1 hr 2 min

Mariatta Wijaya is a multi-award-winning open source maintainer and contributor with over 20 years of software engineering experience. A Python core developer focused on workflow and documentation, she advises and administers Global PyLadies, co-founded PyCascades, and formerly chaired PyCon US, PyCascades, and PyLadiesCon. Dan and Mariatta discuss why unreviewed AI-generated contributions burden CPython maintainers, even as Mariatta uses AI to write code. She shares how she reviews plans and results, records decisions, and builds Claude skills to prevent agents from repeating mistakes. They also discuss her self-hosted personal apps, the limits she places on AI advice, and how she uses AI to help promote community events while keeping time for speaker mentorship. Mariatta explains why agent instructions should be useful to humans and why she packages recurring work as reusable scripts. Full episode notes Transcript Chapters (00:00) - Introduction (01:35) - AI contributions and CPython maintainers (05:45) - Experience, review, and learning to code (09:16) - Migrating off Heroku with AI (12:17) - Documenting decisions and iterating on plans (19:26) - Claude skills and repeated Django mistakes (23:19) - Reviewing software as product owner and tester (28:01) - Where Mariatta prefers human judgment (34:24) - Personal apps and alternatives to subscriptions (43:43) - AI for community organizing (50:44) - Respecting project guidelines and reviewing output (53:27) - Documentation for humans and agents (55:36) - Git skills and reusable automation scripts (59:46) - Speaker management and spreadsheet parsing ⠀ Links from the show -------------------- CPython Claude skills Django Heroku Claude Calendly Doodle Sessionize architectural decision record ⠀ Guests ------- Mariatta Wijaya, Python Core Developer Website Mastodon Bluesky LinkedIn ⠀ Follow the podcast ------------------- LinkedIn Threads Instagram TikTok ⠀ Follow Dan Gerlanc ------------------- X Link...

The AI Sandwich, Agent Primitives, and Designing with AI

Oct 27, 2026 1 hr 13 min

Trevin Chow is has more than 25 years of experience in product and design, held product leadership roles at Axon, Sketchy, Nike, and Microsoft, and co-founded Chewsy. He is a core maintainer of Compound Engineering, a plugin for Claude Code, Codex, and other agent harnesses. Dan and Trevin discuss how AI changes the work of building software, especially design and product judgment. Trevin describes starting with a value proposition before generating designs, using visual references to guide exploration, and keeping humans involved in critique. His “AI sandwich” puts human attention on defining the work and polishing the result while agents handle implementation. Concrete examples include illo's character packs for consistent illustrations and Compound Engineering's reviews across model families. Trevin explains why newer models call for clearer goals and fewer prescribed steps, while extensive evaluations, changing model behavior, and outdated plugins make maintenance costly. The conversation also covers the supervised Hermes Agent setup Trevin built for his daughter, including boundaries around companionship and homework help. It closes with Jev-powered prototypes and Energon, his open source service for sharing documents and files across agents without losing control of the underlying context. Full episode notes Transcript Chapters (00:00) - Product optimism and the changing craft of software (09:53) - Design exploration with AI agents (14:24) - Start with the value proposition, then explore designs (21:21) - Agent primitives and the problem of sharing context (24:54) - Cross-model review and the AI sandwich (32:19) - illo and consistent character illustrations (40:08) - Writing skills for changing models (43:03) - Evaluations, model regressions, and maintenance costs (47:36) - Future skills and the plugin update problem (52:13) - A supervised Hermes Agent for a child (01:02:41) - Jev experiments in document analysis and book discovery (01:06:54) - Energon...

Similar podcasts

The Daily The New York Times

Up First from NPR NPR

The Joe Rogan Experience Joe Rogan

Dateline NBC NBC News

Crime Junkie Audiochuck

Pod Save America Pod Save America

Pardon My Take Barstool Sports

Morbid Ash Kelley & Alaina Urquhart

All episodes

Delegation, Agent Router, and AI Traffic

Nov 10, 2026 1 hr 29 min

From Python Core to Personal Apps: Working with AI Agents

Nov 3, 2026 1 hr 2 min

The AI Sandwich, Agent Primitives, and Designing with AI

Oct 27, 2026 1 hr 13 min

Design Docs, Nightly Audits, and Vycari's Agent Development Loop

Oct 20, 2026 1 hr 8 min

Allen Hutchison is the co-founder and CTO of Vycari, building AI agents for everyday tasks with Chris Perry. He spent 21 years at Google, most recently as a Distinguished Engineer at Google DeepMind, helped found Gemini CLI, and built the Antigravity SDK. His earlier leadership work included Google's mapping products, Core ML, and the AI Developer organization. He writes Letters from Silicon Valley. Dan and Allen discuss why consumer agents need familiar interfaces. Vycari embeds agents in mini apps, including a calendar booking tool that works with meeting preferences and buffer time. Allen wants users to think about the assistant's usefulness rather than the technology behind it. Vycari's two founders have landed well over a thousand PRs in roughly a month. Planning documents guide implementation, nightly jobs keep those documents aligned with code, and review follow-ups become issues that agents can implement. Independent reviews and reflection on user trajectories help identify problems, while Allen retains the final merge decision. Their engineering choices favor quick feedback and manageable costs. Vycari is separating microservices into their own repositories and runs Python and Postgres on VPSs. Allen explains how inexpensive models, stronger models writing their procedures, and deterministic integrations support the goal of a $5 monthly subscription. Full episode notes Transcript Chapters (00:00) - Allen's path to Gemini CLI (06:46) - Open-source contributions and approval fatigue (11:08) - XLA and the infrastructure behind machine learning (13:52) - Vycari and agents inside familiar apps (21:02) - A calendar booking tool that knows your preferences (22:34) - Two founders, a thousand PRs, and startup economics (29:29) - Planning documents and the automated development loop (37:55) - Reflection agents and nightly codebase audits (39:57) - Product context and tiers of coding agents (42:24) - CI, test coverage, and smaller repositories (48:06) - Python, Postg...

Why AI Can Generate a Song but Struggles with Music Theory

Oct 13, 2026 1 hr 9 min

Ben Morss is a Developer Advocate at Mistral. He previously spent 9.5 years at Google as a Product Manager for advanced APIs in Chrome and a Developer Advocate for the web. He earned a bachelor's degree in Computer Science and Music from Harvard University and a doctorate in Music Composition from the University of California at Davis. He continues to make music and write about music theory. Dan and Ben discuss how LLMs help people learn while still missing context and intent. Their discussion of information theory and training data leads into a debate about software craft when agents make code much cheaper to produce. Ben describes Chat Invaders, a cat-themed demo game, and a reunion sing-along app that broke with forty people present. He had not load-tested the app and did not determine what caused the failure. They explore why working output does not guarantee value for a business or an audience. Ben wants musical assistance that can develop ideas and handle arranging work, but finds music theory explanations unreliable. The conversation ends with the human experience behind fiction and songs, and open questions about whether models could be conscious. Full episode notes Transcript Chapters (00:00) - Learning with LLMs and the limits of explanation (05:24) - Model progress and conversational regressions (09:02) - Keeping up with AI and understanding the mechanics (11:10) - Information theory, entropy, and model compression (19:19) - Computing, music, and understanding structure (23:35) - Software craft versus speed of iteration (30:55) - Vibe coding and educational sample code (34:22) - The sing-along app that broke live (37:38) - Software demand and the power of verification (40:58) - Human judgment and useful business adoption (48:47) - AI composition and the missing musical assistant (52:38) - Music theory and gaps in training data (59:31) - Fiction, music, and the human behind the work (01:05:14) - Thinking, consciousness, and continuity ⠀ Links from...

Agents, Engineers, and Citizen Developers

Oct 6, 2026 1 hr 17 min

Cory O'Daniel is CEO and co-founder of Massdriver, an internal developer platform and platform orchestrator for governed self-service infrastructure using Terraform, OpenTofu, and Helm. He has spent more than 20 years building teams and startups and working with cloud infrastructure. He created Bonny, an Elixir-based Kubernetes operator framework, and is a co-founder of OpenTofu. Dan and Cory discuss what infrastructure agents need to act safely. Massdriver models environments and resource relationships so agents can query context directly, while separate agent identities and attribute-based permissions constrain their access. Cory describes a staging workflow that tests infrastructure changes through real deployments before he promotes a release to production. Cory explains how a tested, consistent codebase supports his team's Claude Code workflow, why enforceable tooling matters more than long instruction files, and why human review still matters. He argues that engineers should build quality controls and deployment paths for domain experts who can now create software themselves, with collaboration and operational ownership still needing attention. Full episode notes Transcript Chapters (00:00) - Self-service infrastructure and the arrival of agents (03:11) - An API built around infrastructure context (09:03) - Agent identity and attribute-based permissions (15:54) - A four-person team, agents, and technical debt (23:12) - Future engineering roles and enforceable quality (30:20) - Backlog zero and autonomy for citizen developers (34:29) - Claude Code workflows, examples, and memory (40:54) - Testing infrastructure changes before production (48:00) - Reusable presets and shared provisioners (55:06) - Terraform is easy; organizations are complex (57:09) - Citizen developers and the future of cloud platforms (01:00:53) - When production apps run on someone's laptop (01:03:23) - Domain expertise, autonomy, and engineering's value (01:10:30) - Collaboration beyond Git...

Building a Software Factory with Gas City

Sep 29, 2026 1 hr 19 min

Stephanie Jarmak is an AI Engineer at Omni working on multi-agent orchestration and code intelligence. She is a research affiliate for NASA's Science Explorer (SciX) and a maintainer of Gas City, an open-source orchestration builder for multi-agent coding workflows. Dan and Stephanie discuss how she became a Gas City maintainer by learning from review agents, encoding contribution standards in skills, and building an issue-triage workflow. Automating those steps exposed new reliability problems, from failures across dependencies to excessive alerts and agents that overreact to hypothetical risks. Their conversation connects these experiments to Stephanie's move from planetary science into search and AI engineering. They examine the appeal of building with agents, the responsibility for maintaining what those agents produce, and the mixed emotions of seeing models solve once-difficult research tasks. Personal game projects and Omni's approach to shaping her role show how her curiosity carries across both work and home. Full episode notes Transcript Chapters (00:00) - Contributing to open source with coding agents (08:51) - Learning the review standards and becoming a maintainer (12:58) - Automating a Gas City workflow (21:02) - Astronomy, computers, and a different path into development (27:40) - Working styles and responsibility for agent output (34:46) - Production responsibility and AI skepticism (40:12) - Human judgment and agents solving science tasks (45:55) - Pre-mortems, silent failures, and too many alerts (48:34) - Slack as an agent dashboard and shareable Gas City packs (53:45) - Building games and creative projects with the kids (59:06) - From planetary science to search and Sourcegraph (01:09:48) - Omni and a role shaped around the person (01:15:03) - Decision models and making automation easier ⠀ Links from the show -------------------- Gas City Beads Gas Town Dolt Steve Yegge Claude Code Codex The Six Types of Working Genius Terminal-Bench Sc...

Agentic Data Science in a Reproducible Marimo Notebook

Sep 22, 2026 58 min

Eric Ma is a Senior Principal Data Scientist at Moderna, where he leads the Data Science and Artificial Intelligence (Research) team. Previously, he conducted biomedical data science research at the Novartis Institutes for Biomedical Research and earned his doctorate in Biological Engineering from MIT. Eric is also an open-source software developer known for leading pyjanitor and nxviz and contributing to NetworkX and PyMC. Dan and Eric discuss Eric's rapidly changing practice of agentic data science, centered on Marimo Pair and reproducible Python notebooks. Eric demonstrates an analysis of protein activity and stereoselectivity data, explains why canonical sources and inline environment metadata matter, and shows how agents make ambitious custom visualizations more approachable even when a live demo fails. The conversation then turns to design documents, testable specifications, repository conventions, and the attention-management practices Eric uses to keep agent work from becoming a context-switching trap. Full episode notes Transcript Chapters (00:00) - Why Eric's data science workflow changed so quickly (05:49) - Marimo Pair puts agents inside the notebook (07:19) - Reproducing a protein-engineering paper (10:45) - Why enzyme stereoselectivity matters (13:20) - Canonical data sources and portable environments (18:08) - Exploring activity and selectivity with interactive plots (27:47) - Finding promising regions for protein engineering (30:24) - From heat maps to a 3D protein viewer (35:54) - Learning from agent traces and preserving intent (47:13) - Opinionated structure for agent-written code (52:25) - Managing attention across agentic tasks ⠀ Links from the show -------------------- Marimo Marimo Pair OpenCode cmux Machine-Directed Evolution of an Imine Reductase for Activity and Stereoselectivity cloudscraper Polars Plotly PEP 723 uv 3Dmol.js anywidget Protein Data Bank PyMOL The Arrow of Intent Hermes Agent Obsidian ⠀ Guests ------- Eric Ma, Se...

Beads, Better Specs, and Less Rework

Sep 15, 2026 1 hr 7 min

Andrew Zigler is a GTM Engineer at LinearB and the host of Dev Interrupted, a twice-weekly podcast and newsletter about AI-native development and agentic orchestration. A classicist by training, he previously taught in Japan, built e-learning platforms, and worked in developer relations at Mattermost. Dan and Andrew discuss how shared workflows and memory can help turn individual AI gains into team improvements. Andrew explains his Mise en Place planning methodology and how he uses Beads to translate ideas into connected tasks, while keeping human collaboration in tools such as Asana and Confluence. They examine why clear specs reduce rework without removing the need for iteration, how CI/CD and code review may adapt to agentic development, and what Andrew’s personal agent setup has changed about his work and learning. Full episode notes Transcript Chapters (00:00) - Introduction and the gap between individual and team gains (06:15) - Open source when agents become the users (10:09) - A personal agent stack built on simple primitives (17:37) - Mise en Place and planning before coding (21:58) - Connecting Beads to team workflows (26:10) - Why task graphs help agents maintain context (35:57) - Shared specs and human alignment (43:26) - Agile iteration with faster prototypes (44:52) - CI/CD and independent code review (52:12) - Humanities, learning, and managing agents (58:00) - Changing skills and software interfaces (01:02:25) - Fixing feedback loops and sharing the stack ⠀ Links from the show -------------------- Beads Beads Rust Mise en Place Andrew’s dotfiles Dev Interrupted LinearB Tailscale Agent Gateway systemd WireGuard DuckDB Wispr Flow Dolt Gas Town Steve Yegge Jeffrey Emanuel Robots Ate My Homework NumPy pandas The Diamond Age Snow Crash agile continuous integration progressive web app ⠀ Guests ------- Andrew Zigler, GTM Engineer, LinearB; Host of Dev Interrupted Website LinkedIn X GitHub ⠀ Follow the podcast ------------------- LinkedIn Th...

Programming Languages for AI Agents

Sep 8, 2026 1 hr 18 min

Julien Verlaguet is Founder and CEO of SkipLabs, the company building Skipper, a closed-loop coding agent. He created Skip, a reactive programming language, and led the design of Hack, the language Meta developed to run its code base at scale. In this episode, we discuss what the job of programming language designers becomes when AI agents write most of the code. This includes the design decisions in the language and tooling when agents are the principal user. We also discuss: - How Julien refocused SkipLabs towards AI - What it would take for AI to be able to fully replace engineers - The use of formal methods with LLMs Full episode notes Transcript Chapters (00:00) - A closed-loop coding agent (04:30) - Reactive programming and technical debt (08:40) - Why SkipLabs moved toward AI tooling (11:07) - Incremental tools and low-latency feedback (14:20) - Reactive collections versus Buck and Make (21:06) - Language design in the age of LLMs (31:01) - When human coding still matters (34:16) - Working with four to six agents (41:04) - Why code quality still needs judgment (49:48) - The hidden cost of AI-generated tests (56:24) - The junior engineer dilemma (01:04:27) - Formal methods and LLM verification (01:13:35) - A bumpy road toward a brighter future ⠀ Links from the show -------------------- Skipper SkipLabs Skip Hack reactive programming incremental computation Buck SQLite Coq Rocq Lean Curry-Howard correspondence formal methods model checking Emacs Bun ⠀ Guests ------- Julien Verlaguet, Founder and CEO, SkipLabs Website LinkedIn ⠀ Follow the podcast ------------------- LinkedIn Threads Instagram TikTok ⠀ Follow Dan Gerlanc ------------------- X LinkedIn Threads Bluesky

AI Agents for Bayesian Data Science

Sep 1, 2026 1 hr 14 min

Thomas Wiecki, Founder, PyMC Labs, is the author of PyMC, one of the most popular frameworks for Bayesian modeling, and the founder of PyMC Labs, a Bayesian AI consultancy. He holds a PhD in Computational Cognitive Neuroscience from Brown University and previously served as VP of Data Science and Head of Research at Quantopian Inc., where he built and led a team of data scientists to develop a hedge fund leveraging insights from a crowd-sourced pool of 300,000 researchers. In this episode, we explore how AI agents have made Bayesian methods more accessible to non-experts. Bayesian models are useful for both forecasting and decision-making under uncertainty. These models can act as scenario simulators, making it possible to ask what-if questions about marketing, seasonality, or health interventions while exposing the mechanisms behind an outcome. We also discuss how agentic engineering has finally helped deliver on some of the original promises of data science, how to effectively embedding agents in tools like Slack or Discord to democratize access to company information, and what parts of data science still require talking with humans to understand the problem. Full episode notes Transcript Chapters (00:00) - Agentic engineering meets Bayesian decision science (05:27) - Bayesian models versus black-box prediction (10:22) - Confounders and causal mechanisms (12:41) - From notebooks to model-aware agents (15:41) - The rise of agentic interfaces (19:18) - Alchemize and verified code translation (29:49) - Agentic data science beyond the silo (34:25) - Daimon and collaborative multiplayer AI (37:43) - Verification and unsettled methods (42:53) - Parallel agents and PyMC Forecast (51:08) - The Bayesian method of software engineering (53:59) - Agents as software's primary users (57:08) - Institutional knowledge and bus-factor risk (01:03:56) - Faster research and open source (01:12:05) - Causal models for AI's future ⠀ Links from the show -------------------- Master Agent...

Search is Eating AI

Aug 25, 2026 41 min

Dan is joined by Hugo Bowne-Anderson and Doug Turnbull. Hugo is an independent data and AI scientist who has advised and taught teams at Netflix, Meta, and Amazon. Doug is an independent consultant and search expert with experience at Shopify, Reddit, and Wikipedia, and the author of "Relevant Search" and "AI Powered Search." In this episode, they discuss what agentic search actually means and the 3 primary ways to implement agentic search. Hugo argues that search is becoming a core skill because agents can handle questions that require repeated retrieval and synthesis. To improve agentic search, most teams should start with evals. Establish a retrieval baseline, find areas for improvement, and iterate. Defining a “good” retrieval baseline is product-specific as a healthcare assistant may need its first result to be correct, while an e-commerce system may succeed by offering several useful options. Doug and Hugo argue that the lack of good training examples means its often useful to read and write your own search code. As to other code, Hugo describes the "dark factory" pattern, where code is written by AI agents but cannot be directly read by humans. How do we design systems for a world where the primary consumers of code are AI agents, not humans? Full episode notes Transcript Chapters (00:00) - Agents, engineers, and reverse centaurs (01:24) - Three paths for agentic search (05:32) - Teaching production-ready enterprise agents (07:06) - Why search is eating AI and data (10:24) - Start with evals and retrieval baselines (16:08) - Writing code to build judgment (18:45) - Learning and building beyond code (24:39) - Verification in a world of abundant code (29:52) - Resisting agent-driven feature sprawl (33:38) - Specialized models and better agent interfaces ⠀ Links from the show -------------------- Build Production-Ready AI Agents for the Enterprise Vanishing Gradients retrieval-augmented generation BM25 NDCG Terence Tao dark software factories lights-o...

The Handoff Packet for Local Agentic AI

Aug 18, 2026 1 hr 5 min

Paul Everitt is a Python and Web Developer Advocate at JetBrains. He previously co-founded Zope Corporation, helped bootstrap the Python Software Foundation and Plone Foundation, and served as a US Navy officer who started www.navy.mil in 1993. Paul and Dan discuss how local agentic AI could reshape software engineering, from smaller models supported by static analysis and better tool calling to workflows built around specs, tests, and focused handoff packets. They compare local, cloud, and hybrid model setups and examine what happens when agents work with less supervision. The episode's titular handoff packet sits at the center of a three-level workflow. A large model understands the project, a medium model creates an execution plan, and a small local model carries out a tightly scoped task. The packet gives that smaller model the context, constraints, tools, and success criteria it needs. They also discuss spec drift, Markdown debt, community-maintained Python training data, and the responsibility developers retain to read, test, and own the code they ship. Full episode notes Transcript Chapters (00:00) - A profession changing by the hour (02:54) - Why Python still matters with humans in the loop (04:37) - Static analysis for small local models (11:51) - DwarfStar and the local inference stack (17:28) - Apple's on-device AI push (23:29) - Why unsupervised agent runs fall apart (28:46) - The big brain, medium brain, little brain (41:19) - Spec drift and Markdown debt (47:45) - Pyrefly and duck typing for agents (51:22) - Better tool calling for local coding models (01:00:10) - Community-maintained Python training data (01:03:42) - Bring back the engineering ⠀ Links from the show -------------------- arXivPydantic AILM StudioOpenRouterDeepLearning.AI spec-driven development courseSpec KitSuperpowersPyreflyMellumFlowerLiquid AI⠀ Guests ------- Paul Everitt, Python and Web Developer Advocate at JetBrains WebsiteLinkedInDeepLearning.AI: Spec-Driven Development with Co...

How AI Agents Change the Work of an ML Engineer

Aug 11, 2026 1 hr 1 min

Dan and Niels Bantilan discuss how AI agents are changing Niels's work on two open-source projects, Flyte and Pandera. Flyte began as an MLOps orchestrator and is evolving into an AI runtime for the code, compute, and execution systems around models and agents. Pandera remains a smaller, community-focused data-validation project. Niels finds agents most useful in mature codebases with strong structure, linters, type checks, and tests. He estimates that his coding velocity has increased at least threefold. Local models handle small fixes, while commercial tools perform better on longer tasks that require broad codebase analysis. Pull requests and code review remain central, with reviewers checking for code smells, security problems, and performance issues. Agents now participate in Niels's debugging loop inside live Kubernetes clusters. Through Flyte's MCP server, an agent can inspect logs, identify an out-of-memory error, update the Flyte configuration, and retry the workload. In one case, an agent found an off-by-one error in tensor loading within five minutes, fixing a model that had been emitting garbage symbols. The experience also exposed a risk: Niels has started skimming the agent's report instead of reconstructing every bug himself. At Union, internal agents have narrow responsibilities and return reviewable artifacts. Nody handles customer requests to change node-pool limits and opens pull requests for engineers to review. Doxy monitors SDK changes and proposes documentation updates. Niels applies the same pattern to PRDs, go-to-market writing, and code examples. Agents should have clear access boundaries and produce work that people can inspect. Niels imagines Flyte letting agents assemble workflows instead of following fixed DAGs. Typed tasks define the available building blocks, while Pydantic Monty safely runs the control-flow code an agent writes. Flyte can move files between pods, route heavy work to suitable compute, and resume a 100-step pipelin...

Reducing Entropy in Agentic Software

Aug 4, 2026 1 hr 6 min

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...

Unharness Your Agents

Jul 28, 2026 1 hr 5 min

Dan and John Berryman discuss why today’s terminal- and IDE-centered agent harnesses are too narrow. John argues that agents should be able to see and act across the applications, websites, files, and physical environments that make up a person’s life. His Rook project is an attempt to make those contexts addressable while allowing people to keep using the agent harnesses they already trust. The conversation turns to a future in which websites expose agent-facing capabilities and applications reshape themselves around conversations. John imagines an assistant that can combine a person’s notes and shopping list with location, store inventory, and aisle information. He says feasibility is the major barrier that recently moved into reach, while security, transparency, trust, and standardization remain unresolved. That tension becomes concrete in the discussion of permissions and sandboxing. John expects people to begin with constrained, read-only access and gradually grant more authority, with dry runs, approvals, and reversibility helping determine when an agent can act on its own. He also points to emerging conventions such as skills files, AGENTS.md, and llms.txt as ways for agents to discover what they can do in a given domain. John’s strongest practical advice is to replace bespoke workflow code with skills written in plain English whenever the model is capable enough to follow the instructions. He describes building a Zoom assistant and a candidate-vetting workflow this way, arguing that subject-matter experts may eventually be able to read and rewrite the software directly. In his view, the agent is increasingly just a loop around a model and tools, with frameworks such as LangGraph becoming less necessary for many applications. The discussion of memory is more skeptical. John argues that chunking old conversations and retrieving them by textual similarity does not reproduce the way human experience turns mistakes into procedural knowledge and taste. For now...

The AI Skill Flip

Jul 21, 2026 1 hr 3 min

Sheamus McGovern founded ODSC roughly twelve years ago and now splits his time between the conference business and a role as venture partner and Head of AI at Cortical Ventures. His book, The AI Skill Flip, came out of a pattern he kept hitting: data scientists and software engineers coming to him asking whether AI was going to take their jobs and what they should do about it. He wanted to write something that sat between the doom narrative and the utopian one, both of which he thinks are wrong. The "flip" in the title is the observation that the balance of skills has shifted rather than disappeared. Five years ago a software engineer spent most of their time writing raw code. Now much of that time goes to judging and evaluating what the model produced and thinking further up the stack. The same flip applies in marketing, where the skill becomes knowing what good looks like and what persona you're targeting rather than producing the asset yourself. Asked what separates people who get real value from AI from people who don't, Sheamus lands on three things. First is passion, the plain will to get a good outcome, which he compares to what separates a strong startup founder from an average one. Second is creativity, which he argues AI increases rather than eliminates, because models are sycophantic and will happily build exactly what you asked for. His example is watching people reach for Replit, Base44, or Lovable and build a dashboard, when the real question is whether a dashboard is even the right artifact in a world of agentic workflows. Dan pushes the point further, noting that dashboards existed because software was expensive to build, so you built one thing and maintained it. Third is judgment. AI is excellent at producing output and terrible at judging its value, which Sheamus frames as another instance of the automation paradox. On whether judgment can be taught, Sheamus starts at the engineering level with evaluations. Traditional numeric metrics still apply...

The New Sport of Programming

Jul 14, 2026 55 min

Matthew Rocklin is an open-source software developer best known for creating Dask, a Python library for scalable parallel and distributed computing. He has contributed to projects including Toolz, SymPy, and Theano, worked at Anaconda and NVIDIA on the RAPIDS ecosystem, and founded Coiled, a company focused on running Dask in the cloud. He has a PhD in computer science from the University of Chicago. Dan and Matthew discuss how Coiled changed after Matthew stepped away from its ambitious, VC-backed growth path. The company went from roughly fifty people at its peak to three part-time engineers, while making more money and operating more smoothly. Matthew now connects agents to Slack, email, QuickBooks, the bank, the calendar, the codebase, and company context, which lets them spot problems that cross disciplines. Matthew describes a lightweight operating system for the company. The structure is simple, a Git repository of Markdown files records customers, employees, systems, and his own context. Agents answer ad hoc questions, produce a daily brief, and run a separate monthly cadence for close and overages. They remain read-only for now. Matthew is willing to have them issue invoices when asked, but not to cut checks or reboot virtual machines on their own. The conversation turns to the personal cost of this new leverage. Matthew does not miss writing every line of code, but he has had to reshape his attention around seven parallel agent sessions and long-running turns. He compares agentic programming to a new sport. The work demands more inspiration and creates a more addictive waiting state, so walks, breaks, and deliberate distance from the screen matter as much as technical skill. Agents have fovever changed the culture of OSS. Matthew expects conservative open source projects to protect stability while more experimental projects split off and evolve quickly. His own Frisky project rebuilds parts of Dask in Rust, runs about a hundred times faster in his earl...

Skills, Context, and Trust: The New Agentic Coding Stack

Jul 7, 2026 1 hr 17 min

Dan and Jonathan Bown open with the talk Jonathan gave at ODSC, "Practical Agent Ops: From POC to Prod with MLflow 3.0." MLflow 3.0 arrived last summer as the first stable release built for generative AI rather than traditional machine learning, and Jonathan's team used it to build an agent for pre-enrollment students. The centerpiece of that work was evaluation-driven development. Instead of jumping straight into a working prototype they aligning the business up front on what quality actually looks like before signing off on a model with inherently non-deterministic output. The initial key to success was an Excel file. In it, the data science team had already assembled 150 ground truth examples, but left them untested and set aside while engineers focused on code. Jonathan's team paused the coding work and ran a simple foundation model against those examples first, landing at what amounted to a coin flip of useful versus hallucinated answers. From there they refined the examples with the business, loaded them into MLflow's evaluation datasets built from live traces, and iterated by versioning prompts and agent configurations. Tooling came up repeatedly. MLflow's open source repo now ships a skill file that plugs into coding tools like Claude Code, which Jonathan called a game changer for keeping up with an API that changes at roughly a release a month. The Databricks AI Dev Kit, released around March, bundles skills for the Databricks SDK, CLI, data engineering, and analytics work, usable either inside Databricks' Genie Code pane or in outside tools such as Claude Code, AWS Kiro, or Google Antigravity. Jonathan said installing it produced a dramatic jump in output accuracy compared to coding assistants working from stale or incomplete context about Databricks and MLflow APIs. Dan raised the idea that LLMs and agentic tools are becoming users of software in their own right, alongside humans, and Jonathan tied that to broader changes at WGU: more of the business,...

When Software Gets Cheap, Focus Gets Expensive

Jul 2, 2026 1 hr 7 min

Dan and Greg open with how agentic development has changed since the early days of Copilot. At the time, Greg was at GitHub, and he saw AI mostly help with boilerplate and editor completions. Cursor-style agents were the next widely-used advancement bringing session history and integrated team-wide practices. By June 2026, capable models and harnesses are common inside engineering teams, so the gap between teams increasingly comes from context engineering, repository structure, and whether old team shapes still align with the new ways of building software. For small teams and startups, the leverage of AI is a double-edged sword. Greg describes how SpecStory's original extensions required real sweat equity to reverse engineer chat-log formats across Cursor, Copilot, Claude Code, Amp, and other tools. Now, much of that surface can now be maintained by a fraction of one person's time. The danger is that easy MVPs can trick founders into believing they have validated a market. When the marginal cost of software falls, founders have to spend more of their scarce attention on demand, willingness to pay, distribution, and the routes to customers. The conversation turns to Greg's book, 25 Patterns in Agentic Engineering. He explains how he mined roughly 1,300 preserved SpecStory sessions and nearly 5,000 commits to extract durable patterns from his own agentic practice. Two patterns stand out. First, when code becomes free, verification becomes the bottleneck. Second, between agents turns, docs are the persistent API of the system. For Greg, as-built architecture documents are practical maps that let both humans and agents recover the shape of a subsystem without re-reading the entire codebase every time. Greg's development practice has changed accordingly. He favors trunk-based development and says his team uses almost no pull requests for everyday development, partly because agent-generated diffs arrive at a volume he does not want to review line by line. He prefers lo...

From Supervising AI to Building Systems for It

Jun 18, 2026 59 min

Dan and Eleanor open by discussing how fast software engineering has changed. In the last six months, Eleanor's practice flipped from treating AI as a messy assistant that needs close supervision to building systems that put the agents on the path to success. She now writes essentially no code herself, arguing that the models have become good enough that her involvement mostly makes the results worse. This journey starts from babysitting agents locally to delegating to async, cloud-based agents like GitHub Copilot, Cursor, Devin, OpenHands, or Factory. Eleanor warns that the home-grown terminal "loops" everyone is building right now are great for learning but too brittle to scale. Next up, what does an agent engineering system actually need? Eleanor recommends starting with a sandboxed, execution environment (usually containers), careful configuration over how the agent reaches the outside world (MCP servers and selective network access), a way to see across multiple repositories, and layered rules via AGENTS.md and skills. Eleanor makes the case that async delegation is a forcing function for better specifications. Deterministic feedback like static analysis and test suites are the single biggest factor in work quality because "you can't control AI with AI." She has moved to fully test-driven development and notes that current-generation models no longer find unintended workarounds to tests (e.g., deleting them) the way Claude 4 and early GPT-5 once did. Dan and Eleanor turn to adoption and skills, including how to get better at using AI with deliberate practice. Eleanor explains why she moved using Python, which she was most familiar with from use over her career, to statically typed languages like TypeScript and Go for agent work, why supply chain risk at her healthcare company has her questioning every dependency, and why she dislikes the term "junior developer." Curiosity and systems thinking, not tenure, are what matter now. The episode closes on verifica...

Are We All Managers Now?

Jun 4, 2026 1 hr 4 min

Dan, Angie Jones, and Demetrios Brinkman open with a discussion of the Agentic AI Foundation ("AAIF"), founded by Anthropic, OpenAI, and Block in December 2025 and now home to roughly 180 member companies. AAIF recently launched an ambassador program (apply [here](https://aaif.io/ambassadors/)) and has upcoming events across the globe from [AGNTCon](https://events.linuxfoundation.org/agntcon-mcpcon-north-america/) in San Jose to gatherings in Amsterdam, India, Tokyo, and Seoul. A recurring theme is that the whole industry is learning agentic engineering together. So get out of your "lab" and compare notes! You don't have to do all of this R&D on your own (well, maybe some of it, but it doesn't hurt to collaborate). Everything is changing. And quickly. Angie marks the release of Claude Opus 4.5 as when agentic engineering became viable. Where engineers once obsessed over context engineering and priming a repo so an agent had a chance, the latest frontier models often just need to be pointed at a codebase and told the problem. Drawing on her time leading agentic AI at Block, Angie describes the agent they build that can hold a world model across 25,000 codebases. They paired this agent with cloud workstations where an agent picks up a Jira ticket, clones the repo, and opens a PR without anyone babysitting a terminal. With this kind of firepower comes new problems that look less like coding and more like management. Demetrios argues the unglamorous topic of governance — keeping teams aligned, codifying security practices, deciding what belongs in "the harness" — are the new challenges companies are grappling with. Sandboxes and cloud workers have gone mainstream. The group pushes back on the wave of AI-justified layoffs, worrying that companies are cutting the very mentorship and middle-layer "glue" needed to steer agents. They also dig into tokenomics: budgets blown by mid-year, tools that can cost more than the engineer using them, and Angie's hard-won lesson at...

Claude-maxxing: Burning $10K in tokens for only $50 with a custom software factory

May 21, 2026 1 hr 7 min

Dan and Ian Stokes-Rees, founder and CEO of PNI AI Studio, open by discussing the thesis of Ian's company: an opinionated stack of open-source tools wrapped in agentic AI so business analysts, managers, and finance teams can get the capabilities of a senior data scientist without learning Python, SQL, or R. Ian's primary target is financial services, where an estimated 200+ million weekly Excel users still run human-driven, tacit-knowledge processes. He frames a second opportunity, capturing the "AI exhaust" coming out of those workflows, as the seed for a follow-on product. The conversation turns to how Ian actually builds his product. Ian walks through a three-phase evolution: Cursor as a coding assistant, prompt-based Claude Code generation, and finally a full agentic team modeled on Steve Yegge's "Gas Town" post. Today he runs six to ten Claude Code agents in named roles. Xavier and Yasmin are Agile Process Managers, Anne is the Principal Architect. Now add in software engineers, QA engineers, a test engineer, and a release manager. The agents' operating manual is a roughly 5,000-line AGENTS.md tree spread across about 45 markdown files and served via MkDocs. The Kanban lives in GitHub Projects, milestones serve as sprints, story points and labels drive the workflow, and a "kaizen accumulator" task captures learnings each sprint that get translated into process changes at the start of the next one. Next up, diving into token-maxxing. Ian explains why he keeps hitting Claude Max 20x weekly limits on day three of a sprint — five software engineering agents plus two QA agents burning tokens in parallel — and the management tricks he's adopted: Caveman to enforce terse prompts, templated processes, a catalog of deterministic scripts behind self-documenting skills, pre-commit hooks, and roughly a dozen CI gates that run Claude and Codex reviews against PR templates. Still, not everything is perfect in agent-land. Ian describes his agents as "solid second quartile...

Vibe Coding in the Physical World: Robotics, Circuits, and Dangerous Permissions

May 9, 2026 1 hr 12 min

Dan and Greg discuss Revise Robotics, where Greg serves as founding engineer building robotic systems that refurbish discarded corporate laptops for donation. The episode opens with a description of how AI vision models allow robots to navigate unfamiliar BIOS screens and unpredictable laptop states dynamically — a capability that wasn't feasible a few years ago. Greg reflects on how LLM-powered vision surprised even him as a "second gift," enabling a kind of general adaptability that previously would have required exhaustively pre-coded state machines. The conversation digs into Greg's hands-on experience using Claude for hardware projects, most vividly illustrated by an Arduino RPC library he built on a Raspberry Pi in under five minutes — a task he estimates would have taken a full day by hand. Greg draws a sharp distinction between projects where AI delivers near-100x speedup (well-defined problems with existing patterns and a testable harness) versus cases where it gets confidently stuck in loops. His Minivac 601 circuit simulator project becomes the central cautionary example: months of fruitless AI-assisted attempts to simulate relay circuits collapsed once he realized he needed a real physics engine rather than asking the AI to re-derive Kirchhoff's laws from scratch. A recurring theme is the tension between speed and trust. Greg describes his journey from clicking "yes" to every Claude permission prompt, to briefly trying sandboxing tools like Nono, to ultimately running Claude with dangerously-skip-permissions locally — partly out of pragmatism, partly because he concluded the permission theater wasn't actually catching anything. He shares his "committee of elders" technique, routing important decisions through Claude, Gemini, and ChatGPT simultaneously and only proceeding when all three agree. Dan shares his MMI hook tool, which intercepts Claude's bash calls to enforce conventions like always using uv instead of raw Python. The episode closes with a c...

Welcome to Agents and Engineers

May 7, 2026 1 min

Welcome to Agents and Engineers: The podcast about Agentic AI and Software Engineering. I'm your host, Dan Gerlanc. Each episode is a conversation with people whose daily lives most intersect with AI and agentic systems. These are the people building the agents we interact with every day, like Claude and Codex. They are the engineers building software in a radically new way, by written spec and probabilistic iteration, repeated until the program works. Beyond the technical deep dives, we explore what AI and Agents mean for the future of software engineering. We discuss the psychological and philosophical implications of our interactions with this technology. Join me as I follow the stories, the behind-the-scenes, and the real people behind the code, the agents and the engineers.

–

0 ratings from members

Rate this podcast

No reviews yet — be the first member to rate "Agents and Engineers | Agentic AI, Software & Agentic Engineering".

This podcast, its content and its artwork are not owned by, affiliated with, or endorsed by Castquire.

Delegation, Agent Router, and AI Traffic

Share this podcast

Podcast details

Created by: Dan Gerlanc
Status: Active
Latest episode: Nov 10, 2026
Episodes: 25
Release period: Weekly
Avg. episode length: 1 hr 5 min
Explicit: Yes
Language: English

Links

Official website ↗ Apple Podcasts ↗ RSS feed ↗

Is this your podcast?

Claim it to show it on your profile. Using the email from your RSS feed approves it instantly.

Keep listening

Discover more podcasts like this.

Browse podcasts See the charts