State of Agentic Coding #11 with Geoff, Armin, and Ben

Summary

The episode examines how agentic coding is changing software development—not just by generating code, but by challenging the assumptions behind coding tools, programming languages, engineering jobs, and the business models funding AI.

Careers, curiosity, and industry cycles

• The speakers urge developers to stay curious and keep experimenting as expectations change. They also acknowledge that adapting is harder for people with family, financial, and other responsibilities; optimism alone does not remove those constraints.
• They expect software engineering to remain important, but argue that the profession’s unusual scarcity and compensation may not last in its current form. Developers may need to understand products and business needs, not just their preferred language or framework.
• The discussion compares AI-driven change with earlier technology and economic cycles. The lesson is not that software will disappear, but that industries and the value of particular skills can change substantially.
• Geoff describes sharing career advice aimed at junior developers, including investing in skills and understanding boom-and-bust cycles. He says readers have told him that applying this advice helped their careers.

DHH’s changing view of software development

• The speakers discuss David Heinemeier Hansson’s Rails World keynote and its analogy between portrait painting, photography, and today’s mass production of images. As technology makes a formerly specialized craft widely accessible, the work’s economic value can shift.
• They take the analogy as a warning that typing code by hand may become less valuable as a job skill, even if developers still enjoy doing it personally.
• Agent-written code may change what programming languages and frameworks should optimize for. Many were designed to make code comfortable for human authors; the panel asks whether future tools should instead make languages easier for agents to use and integrate with.
• The speakers stress that this does not mean existing languages will simply vanish. Communities and tools may need to adapt to the new workflow.

Pi Durable and the limits of the basic agent loop

• The panel describes Pi Durable as an effort to make an agent’s work persist across shutdowns and restarts, so it can resume where it left off. The design is intended to support more complex workflows, including subagents, asynchronous work, and multiple people interacting with an agent.
• The speakers contrast this with a common, simpler agent pattern: a transcript, a model response, a tool call, a tool result, and another model response. They argue that this familiar loop becomes awkward when the system must handle concurrent tasks, background context compression, branching work, or collaboration.
• A broader engineering lesson is to re-examine established agent designs rather than repeatedly building on them by habit. The panel suggests that agent architecture and underlying tools may need significant redesign, not just incremental additions.

Live Lisp demonstration: Modifying a running program

A live demonstration connects an LLM to a running Lisp environment. The model can inspect available functions, define new ones, and execute them directly—for example, creating a function to reverse a line and then extending the program.

This differs from the common workflow of editing files, compiling, and deploying. The demo presents a “live” environment in which code can be changed and tested during execution, with the possibility of rolling back a change.

The discussion uses Lisp to illustrate “code as data” and the idea of software that can modify itself. The point is less that Lisp should become the standard agent language, and more that older language ideas may offer useful models for agent-native development.

The speakers also note the tradeoffs: Lisp can be unfamiliar and unpleasant for many programmers, and other environments—particularly JavaScript-based ones—may require deliberate architecture to support reliable hot changes.

Agent tools, generated code, and visibility

• The panel observes that some models increasingly write short scripts to perform tasks such as file editing instead of using explicit editing tools supplied by the agent harness. This can be efficient, but may produce terse, difficult-to-read code.
• They distinguish code executed in a harness’s “code mode” from commands run through a shell such as Bash: the tools operate in different contexts and may have different access to the project and filesystem.
• The speakers worry that when agents hide their work behind opaque scripts or generic tool calls, developers lose visibility into what the agent is doing. That is especially concerning for consequential tasks, where users may need to review actions and verify intermediate results.
• Possible responses discussed include better interfaces for showing tool activity, classifiers that interpret tool calls, or a separate model that explains an agent’s actions. These approaches could improve oversight but may add complexity and token costs.

Models, open weights, and token economics

• The speakers say model behavior changes quickly, making it risky to treat current agent practices as permanent best practices. New model releases may call tools differently or perform more work through generated code.
• They discuss KV-cache reuse as an important efficiency mechanism, while noting that cache dependence can make it harder to switch models during a session.
• Open-weight models are presented as useful for experimentation, though the speakers say access to suitable computing hardware remains a major constraint and that these models can lag leading commercial models.
• A recurring theme is that current AI use is heavily subsidized. The panel gives examples of token use that would be hard to justify at full price and questions whether current subscription and API economics can last.
• They expect providers to seek returns on substantial investment, but do not claim that the business outcome is certain. Low prices may be intended to encourage adoption and habitual use, while future profitability remains unresolved.

Creative and physical-world applications

• The speakers discuss models producing games, music, video, and 3D designs, as well as helping with 3D printing. These examples suggest that general-purpose models may overlap with tools previously dedicated to specific creative tasks.
• They caution that impressive demonstrations do not necessarily mean there is sustained demand: users’ attention is limited, and many generated projects may be novelties rather than products people want.
• At the same time, they note that a creative result can sometimes matter even when its audience does not care how it was made. A generated song that provokes a strong reaction is offered as an example of AI output reaching people beyond the developer community.

Adoption and public reaction

The panel questions whether most people want a general-purpose assistant or want to spend time modifying their software. They distinguish between technologists who enjoy experimenting and the broader public, which may value convenient, reliable products more than customization.

They also discuss negative reactions to AI-generated content and data centers. Their view is that widespread acceptance may depend on visible benefits, rather than technical demonstrations alone.

Guides, reviews, and tutorials

• Live demo: An LLM interacts with a running Lisp environment to inspect, define, execute, and undo functions.
• Architecture walkthrough: The speakers explain the goals of Pi Durable and why persistent state, subagents, and concurrent activity challenge the basic transcript-and-tool-call agent loop.

The episode does not present a conventional product review or a step-by-step tutorial.

Main speakers and sources

• Geoff Huntley — Discusses agentic coding, career adaptation, and demonstrates the Lisp-based live programming concept.
• Armin Ronacher — Discusses agent design, Pi Durable, and coding tools.
• Ben Vinegar — Co-founder of Modem; contributes to the discussion of agents, software development, and adoption.