Humility in the Age of Agentic Coding

Summary of Humility in the Age of Agentic Coding

by Practical AI LLC

55m•March 17, 2026
Listen to Episode

Overview of Practical AI Podcast — "Humility in the Age of Agentic Coding"

This episode interviews Steve Klabnik (software engineer, long-time Rust contributor and co‑author of The Rust Programming Language) about his shift from AI skeptic to active experimenter with agentic programming, his side project Roo (a new systems-ish language), and the broader implications of LLMs/agents on software development practices. The conversation emphasizes epistemic humility, rethinking long‑held engineering beliefs, and practical techniques for making human–AI teaming productive and safe.

Guest background

  • Steve Klabnik: software engineer, docs author, long history in web/dev ecosystems (Ruby/Rails, Go, Rust).
  • Worked extensively on Rust’s documentation and community; wanted to learn more about compilers and language implementation.
  • Transitioned in 2024–25 from criticizing AI to experimenting with agentic tools (VS Code + Klein, Claude) and building Roo with AI assistance.

Core topics covered

  • Steve’s personal arc: from “AI hater” to active user/experimenter after agentic tools proved practically useful.
  • Human perspectives matter: conversations outside the developer echo chamber (e.g., a non‑programmer who uses AI to draft reports then fact‑checks) changed Steve’s view of value.
  • Agentic programming as a learned skill (analogy: Vim — a tool with a learning curve that can be worth investing in).
  • Roo — a toy/experimental language project intended to explore:
    • How agents perform when asked to write code in a language not present in their training data.
    • Whether agentic workflows can produce nontrivial systems (compilers).
    • Design goals: between Rust and Go (strong types, good DX, faster compile cycle); exploring “mutable value semantics” (minimize/reference usage to avoid GC and borrow-checker complexity).
  • Engineering practices to revisit: DRY, strict shift‑left emphasis, pull request/code‑review workflows — some norms may need reexamination in an agentic context.
  • Validation is critical: give agents the ability to run tests and validate outputs automatically; spec-driven development worked well for Roo.

Main takeaways

  • Practical value exists now: agentic tools (when combined with validation) are already productive for non‑trivial engineering work.
  • Humility is essential: software engineers should avoid dismissing non‑programmer use cases, be ready to change opinions when evidence changes, and reexamine long-held practices.
  • Treat agentic programming as a skill worth learning — success depends on tooling, prompts, and process, not just raw model capability.
  • Provide agents with automated validation and test harnesses so they can iterate toward correct behavior (test->fixed point).
  • Many entrenched software engineering “truths” (e.g., compile-time beliefs, DRY dogma, Brooks’ law) need empirical revalidation in the era of agentic coding.
  • Biggest open problem: balancing enormous velocity gains (e.g., agent‑merged PRs) with quality, trust and safety—how to scale speed without degradation.

Notable quotes / insights

  • “We could all deal with a little more humility.” — a central theme: be willing to update beliefs.
  • Agents iterate toward a fixed point; giving them tests/specs lets that fixed point be “test pass.”
  • “Agentic programming is a skill” (analogy to Vim): tools with a learning curve can be worth adopting.
  • On non‑programmer users: they accept occasional inaccuracies and fact‑check; they nevertheless get large productivity benefits because it solves authoring-block problems.
  • On code style: small conveniences like indentation debates matter less; many practices are historical/heuristic rather than empirically proven.

Practical recommendations / action items

For engineers and teams experimenting with agentic coding:

  • Start small, treat agentic workflows as a skill to develop (practice and standardize prompts/workflows).
  • Invest in automated validation:
    • Create specs and automated tests that agents can run.
    • Connect tests to the agent workflow so it can self‑evaluate and iterate.
  • Reevaluate process artifacts:
    • Reconsider strict rules that exist primarily to help humans (DRY thresholds, PR gate patterns) and experiment with different guardrails for agent‑generated vs human‑generated code.
    • Consider labeling PRs by origin (agent vs. human) and experimenting with different review standards.
  • Accept some duplication or “messy” intermediate outputs if they enable speed, provided you have processes to clean/validate later.
  • Measure outcomes: velocity, defect rates, post‑release issues to decide which practices to keep/change.
  • Maintain human oversight where it matters: blind trust in agents is risky—focus human review and testing on higher‑risk areas.

Roo (project) specifics — quick summary

  • Purpose: experiment with agentic creation of a new language and compiler (language not in model training), and explore the middle ground between Rust and Go.
  • Design direction:
    • Strong types, good developer experience, faster compile cycles than Rust.
    • Exploring “mutable value semantics” (minimize references to avoid GC and borrow checker).
    • No GC currently; trade‑offs to remove borrow/lifetimes in exchange for restricted expressiveness.
  • Development approach:
    • Rebuilt Roo after an initial attempt; success improved by spec-driven development and a custom test harness connecting the language spec to executable test cases.
    • Not yet production ready; there are known gaps in runtime/collections/strings that need work.
  • Intent: primarily a learning/play project for Steve; he’d welcome ideas or forks that pursue the concept further.

Future outlook (Steve’s perspective)

  • Uncertain but important: Steve feels the profession is in an experimental phase; many practices will be tested and rethought.
  • Key near‑term research/engineering challenge: how to safely capture the velocity gains from agentic workflows (e.g., agent-merged PRs) without sacrificing quality or trust.
  • Steve expects more experimentation; frontier labs are still hiring, so wholesale job displacement by AI isn’t yet obvious—although the social/economic impacts remain a real concern.
  • Roo may remain a personal “69 Chevy in the garage” project; its ideas could nonetheless inspire future languages or tooling.

Resources & links mentioned / implied

  • Roo (project by Steve Klabnik) — experimental language/compiler (search Steve Klabnik Roo).
  • The Rust Programming Language (the book) — Steve is a co‑author.
  • Tools referenced: VS Code + Klein extension; Claude and other agentic systems.
  • Practical AI Podcast: practicalai.fm (host site)

Summary prepared to give you the episode’s essentials: guest background, why his perspective changed, what he learned building a compiler with agents, and practical guidance for teams experimenting with agentic coding.