Agents and Engineers | Agentic AI, Software & Agentic Engineering

Dan Gerlanc

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. 2h ago

    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

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

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

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

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

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

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

  8. Jul 21

    The AI Skill Flip

    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, but open-ended evaluation is the hard part, and he watched engineers struggle with it while building his first RAG and QA systems. His QA team's honest response was that the system was generating text all the time and they had no idea how to test it. Above the engineering layer, judgment comes down to domain expertise and knowing what good looks like. He tells a story about generating a thirty-page contract with Claude Code, sending it to his lawyer for a quick review, and getting billed ten hours anyway, because the lawyer still had to read every word and apply their own judgment. The other half of teaching judgment is teaching people how AI actually works, so they neither trust it completely nor dismiss it. Once you see it as sophisticated pattern recognition rather than magic, the failure modes become predictable. It works well on established APIs and badly on new libraries. He'd asked Perplexity that morning for the top twenty personal AI frameworks and got Gemini and other Google products instead of OpenClaw and the other recent entrants. Dan asks whether prompt design still matters now that agentic loops can ask their own clarifying questions, and both agree the vocabulary has moved faster than the practice. People stopped talking about context engineering and started talking about the harness, but skills and memory are still context engineering wearing different clothes. Sheamus's view is that prompt engineering, context engineering, and skills are all the same underlying muscle, and the people who learned the first are quick at the third. Most teams are still doing a poor job of it, partly because the models are good enough to paper over sloppy input and hand back generic, unoptimized, expensive results. He describes users bouncing from the $20 plan to the $100 plan and still running out of tokens with no idea where they went. The deeper problem, and the one he spends a chapter on, is that knowledge work is both open-ended and unstructured. You get stuck debugging, a five-minute task becomes two hours, and workflows you assumed were deterministic turn out not to be. His own research pipeline pulling papers from Google Scholar and arXiv keeps hitting that wall, because author institutions appear below the names on one paper, on the left-hand side of another, and not at all on a third. His own use of AI changed substantially over the two and a half years he spent writing the book, which included interviews with about thirty people. The first version of Cortical's VC sourcing pipeline was hand-architected, with AI slotted into specific stages, ChatGPT or Claude to read reports and Perplexity to search. Now a single agent with the right skills and system prompts can do the whole thing end to end. He runs a personal assistant built from Claude Code and a bit of Codex that pulls attachments from his Google Calendar, cross-references his CRM and the Crunchbase API, and prepares the monthly list of two hundred startups he has to review. What used to be three hours of review is now thirty minutes of review plus a couple of hours improving the skills, which he readily admits is not obviously a time saving yet. He's also building a speaker CRM for ODSC, which has around eight thousand speakers in its database and about a thousand submissions per conference, using planning mode and Replit, sometimes adding features live during the meeting where they're requested. That leads to the conversation's real tension. Sheamus calls it the AI credit card, and warns that AI technical debt is piling up fast. He is emphatic that this means more engineers, not fewer, ranting about a post he'd seen that morning claiming software engineering wouldn't exist as a role by 2027. If you can produce code at 10x or 100x, someone has to evaluate, judge, and maintain all of it. Dan agrees on maintenance being the dominant cost but presses on a different point: not every piece of software is worth owning. Sheamus pushes back and they agree to disagree. His counterargument is that the gatekeepers on software development are gone, and the spreadsheet, still the most-used application in most companies, is going to be replaced by generated software and generative UI, interfaces that appear when you ask for them and get thrown away afterward. Dan draws the line at company size, where a startup should build and a large company already paying for tools has to weigh marginal value against maintenance cost. On junior engineers, Sheamus introduces the idea of cognitive debt alongside technical debt. Every task you offload, you also stop practicing, and he offers himself as evidence that his Python is worse than it was two years ago. His advice to juniors is uncompromising: learn the classical skills anyway, including how languages handle memory and which libraries matter, because that's what makes you good at reading and judging generated code. Then learn how AI works on top of that, which he thinks makes juniors potentially more employable than mid-level engineers because they can be AI-native from the start. He's also more hopeful than most about the junior hiring market, attributing much of the slowdown to pandemic over-hiring and, per a study he'd read, possibly to remote work leaving nobody in the office to train new staff. He closes on what he wants from companies, which is real training rather than buying a tool and declaring victory. His model is a matrix: universal skills like prompt engineering, governance, risk assessment, and evaluation across the top, then domain-specific practice underneath. He also makes a pitch for data literacy, having watched software engineers stare at a loss function or an R-squared with no idea what to do with it. Full episode notes

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.

You Might Also Like