The software development world has spent the past two years in a frenzy over agentic coding — AI systems that can autonomously write, debug, and deploy code with minimal human intervention. But a provocative new essay from one of the functional programming community’s most respected voices argues that the industry is already looking past agentic coding toward something far more transformative, and far less understood.
Gabriel Gonzalez, the engineer and writer behind the influential blog Haskell for All, published a detailed treatise in February 2026 titled “Beyond Agentic Coding” that has sparked intense discussion among developers, AI researchers, and technology strategists. The piece doesn’t merely iterate on the current discourse around AI-assisted programming — it fundamentally reframes the trajectory of how humans and machines will collaborate to build software, arguing that the agentic paradigm is a transitional phase rather than an endpoint.
From Autocomplete to Autonomy — and What Comes After
To understand where Gonzalez believes the industry is headed, it helps to trace the arc of AI-assisted development as he lays it out. The first generation of tools — exemplified by GitHub Copilot and early large language model integrations — functioned essentially as sophisticated autocomplete engines. They predicted the next line or block of code a developer was likely to write, offering suggestions that could be accepted, modified, or rejected. This was useful but fundamentally passive; the human remained the architect, the decision-maker, and the executor at every step.
The second generation — the agentic era that dominates current tooling — shifted the balance considerably. Tools like Devin, Cursor’s agent mode, and various autonomous coding frameworks from startups and major labs gave AI systems the ability to plan multi-step tasks, execute them across files and repositories, run tests, interpret errors, and iterate toward solutions. As Gonzalez describes in his essay on Haskell for All, this represented a genuine leap: the AI moved from suggesting code to doing coding work, operating with a degree of autonomy that would have seemed implausible just three years ago.
The Limits of Letting AI Drive
But Gonzalez’s central argument is that agentic coding, for all its impressive capabilities, carries fundamental limitations that the industry has been slow to acknowledge. The most critical of these is what he characterizes as a mismatch between the AI’s operational model and the actual cognitive work of software engineering. Agentic systems, he contends, are optimized for tasks that can be decomposed into discrete, well-specified steps — fix this bug, implement this API endpoint, write tests for this module. They excel when the problem space is bounded and the success criteria are clear.
What they struggle with, Gonzalez argues, is the higher-order reasoning that defines the most consequential work in software development: architectural decisions, trade-off analysis, system design under uncertainty, and the kind of holistic judgment that comes from understanding not just what a system does but why it was built that way. These are the decisions that determine whether a codebase remains maintainable over years, whether a system scales gracefully, and whether technical debt accumulates or is held in check. No amount of autonomous code generation addresses these concerns if the underlying design is flawed.
A New Paradigm: Declarative Intent and Formal Verification
The “beyond” in Gonzalez’s title refers to a paradigm he sees emerging at the intersection of several technical threads: formal methods, dependent type systems, declarative specification languages, and AI. Rather than asking an AI agent to write code that implements a feature, the post-agentic model would have developers express their intent in a rigorous, machine-verifiable format — something closer to a mathematical specification than a natural language prompt or even traditional code. The AI’s role would then shift from autonomous coder to proof-search engine: finding implementations that provably satisfy the specification.
This vision draws heavily on ideas from the functional programming and formal verification communities — worlds that Gonzalez has inhabited for over a decade. Languages like Haskell, Agda, Idris, and Lean have long explored the idea that types can serve as specifications and that programs can be constructed as proofs of correctness. What has changed, Gonzalez suggests, is that modern AI systems are becoming powerful enough to make this approach practical at scale. Where proof assistants once required extraordinary expertise and patience, AI-augmented formal methods could democratize the technique, making it accessible to working engineers rather than just researchers and mathematicians.
Why the Functional Programming Community Saw This Coming
Gonzalez’s perspective is not emerging in a vacuum. The functional programming community has long been skeptical of approaches to software correctness that rely primarily on testing and human review — the very mechanisms that agentic coding systems use to validate their output. The argument, refined over decades by researchers like Philip Wadler, Conor McBride, and Edwin Brady, is that tests can only demonstrate the presence of correct behavior for specific inputs, while types and formal proofs can guarantee correctness across all possible inputs. If AI can bridge the gap between specification and implementation with mathematical rigor, the result would be software that is correct by construction rather than merely tested into approximate reliability.
The timing of Gonzalez’s essay is notable. It arrives as the broader AI industry is grappling with the reliability problem in agentic systems. Reports from engineering teams at major technology companies have documented cases where autonomous coding agents introduce subtle bugs, make architecturally unsound decisions, or generate code that passes tests but fails under real-world conditions. These are not merely growing pains; they reflect a structural limitation of systems that generate code probabilistically and validate it empirically. As Gonzalez writes on Haskell for All, the question is not whether agentic coding works — it clearly does, for many tasks — but whether it represents the ceiling of what AI can contribute to software engineering.
The Industry’s Billion-Dollar Bet on Agents May Need Revision
The implications for the technology industry are significant. Venture capital has poured billions of dollars into agentic coding startups over the past 18 months, with valuations predicated on the assumption that autonomous code generation is the future of software development. If Gonzalez’s thesis gains traction — and early indicators suggest it is resonating with a technically sophisticated audience — it could redirect investment toward companies working on formal methods tooling, specification languages, and AI-assisted verification.
Some movement in this direction is already visible. Research labs at Google DeepMind and Meta’s FAIR division have published work on using large language models for theorem proving and formal verification, with promising results on mathematical benchmarks. The Lean theorem prover community has seen a surge of interest, partly driven by AI researchers who see it as a potential foundation for the kind of specification-driven development Gonzalez describes. Meanwhile, startups like Harmonic and Morph Labs have begun exploring the commercial potential of AI-augmented formal methods, though these efforts remain in early stages compared to the mature agentic coding ecosystem.
The Human Role Evolves, But Doesn’t Disappear
One of the most striking aspects of Gonzalez’s argument is its implications for the role of the human developer. In the agentic paradigm, the developer’s job is increasingly to supervise, review, and direct AI agents — a role that some have compared to managing a team of junior engineers. In the post-agentic paradigm Gonzalez envisions, the developer’s role would shift again, toward something more like a systems architect or formal specifier: someone who defines precisely what the software should do, in a language rigorous enough for machine verification, and then lets AI find an implementation that provably meets those requirements.
This is, in some ways, a more intellectually demanding role than either traditional coding or agent supervision. It requires the ability to think precisely about system behavior, to anticipate edge cases and failure modes, and to express requirements in a formal framework. But Gonzalez argues that this is exactly the kind of work that humans are uniquely suited for — and that AI, at least in its current form, is not. The creative and analytical work of deciding what to build and specifying it correctly is fundamentally different from the mechanical work of translating that specification into executable code.
A Provocation the Industry Cannot Afford to Ignore
Not everyone is convinced. Critics of the formal methods approach have long argued that the overhead of writing formal specifications exceeds the benefit for most practical software projects, and that the technique is best suited for safety-critical domains like aerospace, medical devices, and cryptography rather than the broad spectrum of commercial software development. Gonzalez acknowledges this objection but counters that AI dramatically changes the cost-benefit calculus: if an AI system can automatically derive a correct implementation from a specification, the marginal cost of formalization drops precipitously while the benefit — provable correctness — remains enormous.
The debate is far from settled, and it would be premature to declare the agentic era over before it has fully matured. But Gonzalez’s essay represents a serious intellectual challenge to the prevailing assumptions of the AI-assisted development movement. It suggests that the industry’s current fixation on autonomous code generation may be optimizing for the wrong objective — producing more code faster — when the real bottleneck in software engineering has always been producing correct code that solves the right problem. If the post-agentic future Gonzalez describes comes to pass, the most valuable skill in software development may not be prompting an AI agent or reviewing its output, but rather the ancient and demanding art of saying precisely what you mean.
WebProNews is an iEntry Publication