Code is clay now
Agentic coding is transforming software from rigid 'code-stone' into malleable 'code-clay,' fundamentally altering development workflows. The piece explores this shift, distinguishing between 'artisan' (human-in-the-loop) and 'factory' (automated pipeline) approaches to building. HN readers are buzzing about the implications for developer roles, the true nature of code malleability, and whether AI genuinely resolves longstanding software development bottlenecks.
The Lowdown
Alberto Denia posits that the advent of agentic coding has revolutionized software development, changing the very nature of code from a rigid, expensive-to-change 'code-stone' to a flexible, easily reshaped 'code-clay.' This newfound malleability collapses the cost of change, enabling a more fluid, iterative, and exploratory approach to building software.
- The Shift to Malleability: Before November 2025 (the "Middle Ages of coding"), code was like stone – difficult to change. Agentic coding makes it like clay, where modifications are cheap and rapid.
- Modeling with Clay: This allows for "modeling," where developers can quickly sculpt large blocks of code, iterate on structure, and refine details fractally, from high-level exploration to fine-grained features.
- Human Judgment Remains Key: Despite the ease of change, human product and engineering judgment is still vital for knowing what changes to make and providing the architectural armature and guardrails.
- Two Workflows: Artisan vs. Factory:
- Artisan: The developer stays "in the loop," leveraging fast feedback for exploration, refining features that need to "feel" right, and compressing development cycles. This is not mere "vibe coding" if the developer judges the code's shape, not just the surface.
- Factory: The developer is removed "from the loop," building automated pipelines (specs, generators, verifiers) for repeatable tasks like CRUD endpoints or bug fixes. Judgment moves upstream to pipeline design.
- Complementary Approaches: Both artisan and factory models are valuable and often complementary. Large products benefit from artisanship for novel problems, while solo developers can use factories for boring tasks, achieving unprecedented scale.
The article concludes by prompting readers to consider what possibilities open up now that code has become such a pliable material, inviting a re-evaluation of software engineering practices.
The Gossip
The Malleability Metaphor: Is Code Truly Clay Now?
Commenters extensively debate the author's core analogy. Many argue that code was always intended to be malleable ('software' implies 'soft,' not rigid) and that the concept of iterative development or prototyping isn't new. Some point to Lisp, which has historically been described as 'mud' or 'clay,' suggesting the idea predates modern AI. However, others clarify that while code might have always been *theoretically* malleable, AI agents drastically reduce the *speed* and *cost* of change, which fundamentally alters the experience and makes the 'clay' analogy apt for the current paradigm. Alternative metaphors like 'Legos,' 'garden,' or 'sandpit' are also proposed.
AI's Impact on Developer Workflows and Judgment
The discussion delves into the practical implications of the 'artisan' and 'factory' models for developers. While acknowledging the potential for rapid prototyping and iteration, many express concern about 'vibe coding' – producing half-baked or abandoned projects without a strong foundation. There's a consensus that human judgment, taste, and the ability to define robust 'molds' (specs, tests, architecture) remain crucial. The challenge lies in determining *when* and *where* human expertise should be applied, particularly in distinguishing meaningful, architectural work from automated code generation.
Business Value, Legacy Code, and the 'Bottleneck' Question
A significant thread questions whether the increased code malleability directly translates to increased business value. Some argue that code has rarely been the primary bottleneck; rather, market understanding, product-market fit, and the value of data are more critical. The conversation also explores AI's potential to address the perennial problem of legacy code. While some optimistically believe AI agents can dramatically reduce the cost and risk of refactoring old systems, others express skepticism, citing negative experiences with AI-generated code from contractors that, despite looking 'shiny,' delivers reduced capability and increased complexity.