Agents and Engineers | Agentic AI, Software & Agentic Engineering

Dan Gerlanc
  • 5.0 (13)
  • Technology
  • Updated Weekly

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.

  1. 1d ago

    Beads, Better Specs, and Less Rework

    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 Threads Instagram TikTok ⠀ Follow Dan Gerlanc ------------------- X LinkedIn Threads Bluesky

  2. Sep 8

    Programming Languages for AI Agents

    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

  3. Sep 1

    AI Agents for Bayesian Data Science

    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 Agentic Data ScienceShow Us Your Agent SkillsPyMCPyMC LabsBayesian modelingcausal questionsmedia mix modelingDaimonAlchemizePyMC Forecastprior data fitted networksNumPyro ForecastStanJAXPyTorch⠀ Guests ------- Thomas Wiecki, Founder, PyMC Labs WebsiteLinkedInGitHubTwitter⠀ Follow the podcast ------------------- LinkedInThreadsInstagramTikTok⠀ Follow Dan Gerlanc ------------------- XLinkedInThreadsBluesky

  4. Aug 25

    Search is Eating AI

    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-out manufacturing Unix philosophy OpenClaw Simon Willison ⠀ Guests ------- Hugo Bowne-Anderson, Independent Data and AI Scientist Website LinkedIn X GitHub Bluesky ⠀ Doug Turnbull, Principal, SoftwareDoug Website LinkedIn X GitHub Bluesky ⠀ Follow the podcast ------------------- LinkedIn Threads Instagram TikTok ⠀ Follow Dan Gerlanc ------------------- X LinkedIn Threads Bluesky

  5. Aug 18

    The Handoff Packet for Local Agentic AI

    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 Coding Agents⠀ Follow the podcast ------------------- LinkedInThreadsInstagramTikTok⠀ Follow Dan Gerlanc ------------------- XLinkedInThreadsBluesky

  6. Aug 11

    How AI Agents Change the Work of an ML Engineer

    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 pipeline at step 98 instead of starting over. Niels sees this as the foundation for an AI runtime that combines agents with training, inference, and reinforcement-learning rollouts. Agents have also made it easier for Niels to maintain Pandera while raising a young family. He is exploring validation schemas for vectors, images, and tensor containers, with Narwhals and LanceDB as possible paths into multimodal data. The design remains open. Pandera's concise plain-text errors work well for agents, while HTML reports may better serve people. Across both projects, Niels sees a continuing human responsibility: understand enough of the system to decide whether an agent's output is worth keeping. Full episode notes Click here to view the episode transcript. Chapters (00:00) - How agents are changing Flyte and Pandera (01:29) - Why agents work best in mature codebases (05:38) - Local models for small fixes, Claude for longer tasks (08:44) - Agents triple coding velocity (11:39) - Flyte MCP keeps Kubernetes out of the debug loop (13:53) - From model training to inference and rollouts (17:17) - Flyte's role in reinforcement-learning workloads (22:08) - Moving tensors between pods and GPUs (23:48) - An off-by-one bug made the model output garbage (25:48) - The risk of losing technical understanding (30:39) - Nody and Doxy: agents with narrow permissions (37:20) - When to move an agent from a terminal into Flyte (45:26) - Agents build execution graphs from typed tools (48:06) - Flyte as a durable AI runtime (51:02) - The case for human ML engineers (52:31) - Extending Pandera to vectors and images (55:10) - Narwhals opens a path to multimodal validation (57:45) - Plain-text errors for agents, HTML reports for people ⠀ Links from the show -------------------- Flyte Pandera Union AI Pydantic Monty Narwhals LanceDB Kubernetes RustFS ⠀ Guests ------- Niels Bantilan, Chief Machine Learning Engineer, Union LinkedIn ⠀ Follow the podcast ------------------- LinkedIn Threads Instagram TikTok ⠀ Follow Dan Gerlanc ------------------- X LinkedIn Threads Bluesky

  7. Aug 4

    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

  8. Jul 28

    Unharness Your Agents

    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, he prefers explicit, visible review of a completed task followed by packaging the generalized process as a skill. That approach is also his answer to the limits of AI-generated writing: agents can remove ums, edit dead space, and produce polished drafts, but they still do not know what a particular person considers good. Looking ahead, John expects more agentic applications, just-in-time custom software, and world models that simulate environments for robotics. He is optimistic but clear-eyed about the risks, closing with a plea to direct the technology toward useful and humane outcomes rather than dystopia. Full episode notes Click here to view the episode transcript. Chapters (00:00) - Why agents should be unharnessed (03:32) - Rook and context-aware agents (13:23) - Agent-facing applications and trust (18:23) - Sandboxing, dry runs, and reversibility (21:29) - The new programming language is English (30:28) - Why bespoke agent frameworks are fading (34:13) - What agent memory gets wrong (42:50) - Explicit memory through skills (51:07) - Taste as the final frontier (57:49) - World models and the future ⠀ Links from the show -------------------- Arcturus Labs Blog The AI Product Era You're Building For Might Already Be Over Unharnessed Agents Power the Future of AI Products Relevant Search Prompt Engineering for LLMs Agent Client Protocol OpenClaw Hermes Pi LangGraph Pydantic AI Tailscale OpenStreetMap Model Context Protocol ⠀ Guests ------- John Berryman, Founder, Arcturus Labs Website LinkedIn X YouTube ⠀ Follow the podcast ------------------- LinkedIn Threads Instagram TikTok ⠀ Follow Dan Gerlanc ------------------- X LinkedIn Threads Bluesky

See All (17)

Trailer

5
out of 5
13 Ratings

About

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.

Information

You Might Also Like