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

    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:49) - Pyrefly and duck typing for agents (51:29) - Better tool calling for local coding models (01:00:23) - Community-maintained Python training data (01:03:48) - 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 WebsiteLinkedIn⠀ Follow the podcast ------------------- LinkedInThreadsInstagramTikTok⠀ Follow Dan Gerlanc ------------------- XLinkedInThreadsBluesky

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

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

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

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

  6. Jul 14

    The New Sport of Programming

    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 early testing, and exposes telemetry so agents can understand distributed state. It is promising but still breaks often, which makes it a useful example of the stability and speed trade-off. Matthew argues that software has no intrinsic value. It matters because it cures a disease, helps someone find a home, or automates a useful outcome. When agents make implementation cheap, programmers must let go of much of the craft they built and focus on problem selection, system design, and judgment. He sees the same opening in front-end work, where agents helped him explore TypeScript, visual design, and user workflows that he had previously avoided. Dan and Matthew discuss strategies for verifying agentic output. Matthew gives agents tests, benchmarks, telemetry, line-count signals, and independent reviews, then asks them to demonstrate that his specific concerns are handled. He says the bottleneck is now his own ability to make decisions across many threads, not agent intelligence. Good context and feedback systems matter more to him than a more capable model, and he ends by encouraging programmers to play, take bigger swings, and build their own things. Full episode notes Click here to view the episode transcript. Chapters (00:00) - Coiled after the VC-backed growth phase (04:01) - A repository of context and a daily company brief (07:25) - Opportunity cost in a high-churn era (10:29) - Rewiring attention for agentic programming (15:43) - Seven sessions, long turns, and more walks (18:34) - What happens to work relationships (21:49) - Open source stability versus AI-driven change (23:56) - Frisky and the Rust rewrite of Dask (25:40) - What software is worth when it is cheap to build (29:31) - Why Matthew started building front ends (32:58) - Languages matter less than the user experience (36:08) - Higher-level programming and formal verification (38:12) - Ambition, inhibition, and larger agent tasks (40:41) - Feedback systems for checking agent work (45:04) - Context and feedback beat raw model intelligence (49:17) - AGENTS.md, documentation, and learning with local models (57:48) - Build your own things ⠀ Links from the show -------------------- Dask Coiled Frisky Qwen 3 Vite py-spy formal verification ⠀ Guests ------- Matthew Rocklin, Founder & CEO, Coiled Computing Website LinkedIn ⠀ Follow the podcast ------------------- LinkedIn Threads Instagram TikTok ⠀ Follow Dan Gerlanc ------------------- X LinkedIn Threads Bluesky

  7. Jul 7

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

    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, not just engineers, now writes system prompts and builds their own copilot-style agents. His own day to day has moved from core development toward AI enablement, meaning security review, best practices, and helping non-technical staff adopt evaluation-driven habits for the prompts and agents they build themselves. Jonathan's path to WGU ran through Pentara, a biostatistics consultancy, and Zions Bancorporation, where he did quant finance work before a stint simulating financial products for WGU students. He became a founding member of WGU's MLOps team in 2023, when the university's machine learning was still traditional work like random forests and ensembles for predicting student outcomes, well before Databricks had built out MLOps tooling. Dan connected this to Hamel Husain's essay "The Revenge of the Data Scientist", and Jonathan agreed that evaluation-driven development brings the work full circle: checking evals and correctness is the generative AI analogue of checking a confusion matrix. The pre-enrollment agent's rollout became the clearest illustration of the method. The first release, a bare foundation model with no WGU context, drew heavy negative feedback from the employees testing it, some of whom wanted to cancel the initiative. Jonathan's team treated that feedback as fuel, folding the failed questions into an evaluation dataset and iterating until they reached roughly 82 percent correctness and near-total relevance, at which point the same employees became enthusiastic supporters. He credited MLflow's architecture for building subject matter experts directly into the agent ops workflow rather than treating evaluation as a purely technical exercise. Jonathan was candid about where his trust runs out. He does not trust a tool's first output even after a full planning session, citing a Kiro planning cycle from the day before that failed on the first try despite extensive back and forth. He is cautious about MLflow's fast release cadence outpacing its own skill files, and notably guarded about tools like OpenClaw and Claude Cowork that can reach into email or personal documents. Given how much effort WGU puts into protecting student data, he extends the same caution to his own personal information and limits what such agents can access. On his team, Jonathan resists banning AI-generated code or stigmatizing it in review, and instead pushes everyone toward reviewing code outside their usual specialty, using AI review tools like Amazon Q or GitHub Copilot as a starting point rather than a final answer. He pushed back on the idea that tool usage equals productivity, warning about AI slop and noting that some of the heaviest users he knows are not the most productive. The thread ties back to evaluation-driven development's real thesis: start from value, not from the tool, a point he illustrated with WGU's Academic Virtual Assistant pilot, where a surprising result showed that students chatting with the assistant were more likely, not less, to still reach out to a human mentor afterward. Full episode notes Click here to view the episode transcript. Chapters (00:00) - Introducing Jonathan Bown (00:56) - ODSC talk: escaping POC prison with MLflow 3.0 (05:11) - The forgotten Excel file: rebuilding around evals (09:36) - MLflow skills and the Databricks AI Dev Kit (15:00) - When AI becomes the user of your software (18:16) - How the day-to-day has changed in six months (22:16) - Centralizing prompts, evals, and best practices (25:38) - From quant finance to founding WGU's MLOps team (31:02) - The Revenge of the Data Scientist (35:01) - Has the job gotten easier or harder? (37:33) - Thinking ten steps ahead with agentic coding tools (42:15) - Leveling up junior engineers instead of gatekeeping review (51:17) - Where trust breaks down: OpenClaw and personal data (56:48) - The mental toll of managing agents versus writing code (59:27) - How much detail agentic tools actually need in a prompt (01:07:14) - Value over software: the Academic Virtual Assistant's surprise result ⠀ Links from the show -------------------- MLflow 3.0 Databricks AI Dev Kit Genie Code ODSC (Open Data Science Conference) OpenClaw AWS Kiro Google Antigravity The Revenge of the Data Scientist Amazon Q ⠀ Guests ------- Jonathan Bown, Principal ML Engineer, WGU Website LinkedIn ⠀ Follow the podcast ------------------- LinkedIn Threads Instagram TikTok ⠀ Follow Dan Gerlanc ------------------- X

  8. Jul 2

    When Software Gets Cheap, Focus Gets Expensive

    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 local agents over cloud agents that containerize the repo and open PRs later, because steering an agent while it runs keeps his mental model intact. Long unattended runs still make sense to him, but only when they start from a clear goal and a more detailed rider, with phased commits and verification points he can inspect after a walk or a night away. Dan and Greg also dig into coordination at larger scale. Greg is skeptical that issue trackers were ever clean or current enough to describe day-to-day engineering, but he sees issues becoming useful as specs with provenance and evidence that can be handed to agents. Personally, he runs several projects at once, usually three to five, with local agents in permissive modes, and rotates attention while long runs execute. That power is not free. He describes the dopamine loop of watching ideas come to life, the temptation to keep agents busy overnight, and the scarcity mindset created by subsidized access to frontier models. The episode closes with where Greg still does not trust the tools. Copywriting and visual design still require heavy human intervention because the models can blur rather than sharpen the message. He frames taste less as a mystical trait and more a selection amongst trade-offs and the ability to connect ideas in understandable ways. Coding has benefited from benchmarks and verifiable answers; much of the rest of the world is less tractable because there is no single ground truth for what "good" means. Full episode notes Click here to view the episode transcript. Chapters (00:00) - Introduction and guest background (00:55) - What agentic teams are running into (06:56) - Startup leverage, MVP traps, and maintaining SpecStory (09:26) - When software gets cheaper, distribution matters more (12:31) - Hand-written code, craft, and code as liability (16:21) - Mining 1,300 sessions into 25 patterns (19:01) - Verification and as-built architecture docs (23:55) - Co-writing docs with LLMs (25:15) - Keeping docs fresh through skills, Git, and verbose commits (27:50) - Trunk-based development for agentic teams (30:26) - Local steering versus cloud-agent pull requests (32:14) - Goal and rider plans, long runs, and Gas Town (35:52) - Replacing issue trackers with weekly docs (38:19) - Larger teams and issues as agent-ready specs (42:45) - Parallel projects and concentration limits (44:47) - Local agents, permissions, and risk judgment (46:57) - The cognitive pull of managing agents (51:58) - Scarcity, token costs, and model choice (58:57) - Copy, design, naming, and taste (01:05:04) - Why creative output resists verification (01:07:12) - Closing ⠀ Links from the show -------------------- Hardcore Agentic Engineering for builders who ship SpecStory Stoa 25 Patterns in Agentic Engineering AI Essentials for Tech Executives Meditations on Tech Beyond Code-Centric Goal Engineering WebRTC CRDT Trunk-based development Steve Yegge's Gas Town Dead Reckon Devin DORA Bear DeepSeek Qwen Yann LeCun ⠀ Guests ------- Greg Ceccarelli, Co-Founder & CPO, SpecStory Website Blog LinkedIn X ⠀ Follow the podcast ------------------- LinkedIn Threads Instagram TikTok ⠀ Follow Dan Gerlanc ------------------- X LinkedIn Threads Bluesky

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