The Missing Piece of Agentic Development

Agentic development makes software engineering feel like an optimization problem. Define your goal, let AI suggest solutions, and refine until it works. In demos, agents add features, refactor code, and close tickets while you sit back and relax. But in large-scale projects, the challenges become clear. The difficult part isn’t generating code. It’s getting the right results quickly and safely as things change and security matters, without overloading people with reviews and debugging.

Most programming tools were built for a world where people write code and computers run it. With agentic workflows, computers suggest code and people check direction. This shift exposes limits in our languages, compilers, and tools.¹

In reality, tools like Claude Code and OpenCode are bringing agentic workflows into daily development, not just demos.²³ As adoption grows, teams converge on agentic orchestration patterns such as planner/executor loops, tool routing, reflection, and multi-agent decomposition.⁴ One popular “overnight iteration” pattern is the Ralph Wiggum self-referential development loop, where you keep the agent running with persistent iteration, then review the changes in the morning.⁵⁶⁷

The Bottleneck

#

With agents, producing another implementation is almost free. While AI supports software engineering activities, it also influences scarce resources like reviewer attention, architectural coherence, integration stability, security assurance, and evidence of correctness.⁸

When output is abundant, you don’t need more creativity in code generation. You need high-bandwidth, low-latency signals showing whether the agent is moving in the right direction.

Today’s workflows still rely on delayed signals: integration tests that run later, runtime crashes discovered in staging, flaky CI that confuses cause and effect, and security issues found after the fact. In an agentic loop, delayed signals are poison. Feedback must be immediate, localized, and deterministic, or the loop becomes an expensive random walk.

A Role Shift

#

Developers are becoming reviewers and directors rather than manual constructors. Informal “vibe coding” is acceptable, but “vibe reviewing” is catastrophic. But most orgs aren’t prepared for that. If an agent writes 80% of the diff, a human reviewer must answer critical questions. Does this align with product requirements? Is the design sound? Are the security boundaries correct? Is the behavior actually what we intended? Are there hidden side effects or policy violations?⁹

Traditional reviewing assumes implementation is the primary artifact. Agentic reviewing requires the opposite. Interface and intent must be the artifact, and implementation treated as refinement.

This demands a deeper understanding of fundamentals like type systems, logic, semantics, threat modeling, and protocol reasoning. Not because we’re becoming academics, but because verification literacy is the job. Education should reflect this paradigm shift, relying less on pragmatic details and more on a big-picture understanding of good systems design.¹⁰¹¹

The misunderstanding of new technology requirements on human resources has famously led to scandalous layoffs at Salesforce, where the CEO thought he needed fewer engineers “because I need less heads with AI.” ¹²

Compiler as a Tool

#

Most compilers still “speak human.” They produce free-form text errors, cascading diagnostics, inconsistent error ordering, little or no structured causality, and weak, non-actionable suggestions. For agents, that’s a low-quality signal. For reviewers, it creates cognitive overload.¹³

What agentic loops/workflows need are compilers and interpreters that behave like verification oracles. These include structured diagnostics (machine-readable), stable error IDs and deterministic ordering, precise provenance (“this constraint came from this rule and this span”), reduced/minimal unsatisfiable cores (the smallest inconsistency witness), and actionable “fix-its” (edits with rationale).¹⁴¹⁵

Why unsat cores matter is simple. An LLM is essentially a fuzzy translator of intent into code. To help it converge, you must provide sharp counterexamples, not a thousand symptoms. A minimal unsat core is the densest possible feedback: “You got this specific promise wrong.”¹⁶

Clarifying Intent

#

Most languages don’t separate intent from implementation. We bury intent across comments, ticket descriptions, Slack threads, unit tests written after the fact, and implicit conventions. Humans must infer intent from implementation while agents infer it from loosely specified prompts. That’s why agentic coding feels unstable. The agent optimizes for “passes CI” or “looks plausible” rather than “provably satisfies the requirement.” Without formal intent encoding, reviewers must reconstruct semantics. Every PR becomes a detective story.

Ecosystem Entropy

#

Agentic coding is hypersensitive to entropy. Our ecosystems offer countless ways to accomplish the same task. When there are several ways to represent errors, serialization, data modeling, async I/O, input validation, or authorization, agents may generate a wide range of styles and patterns. Review, maintenance, and security become harder as consistency breaks down.¹⁷¹⁸

Worse, the default behavior in many ecosystems is to import another package. This is manageable when humans choose dependencies carefully. With agents, it becomes a supply-chain hazard generator, introducing risks such as abandonware, typosquatting, malware packages, vulnerable transitive dependencies, and subtle behavioral differences across libraries. Agentic coding amplifies productivity and creativity, but also expands the attack surface.¹⁹²⁰²¹

Typing for Convergence

#

There’s a misconception that types are about developer preference. In agentic workflows, strong static typing becomes something else entirely. It serves as a dense reward signal for iterative synthesis, a persistent executable specification in the codebase, a refactoring safety net under extreme churn, a boundary enforcer for architecture and effects, and a way to push correctness earlier than tests can.²²²³²⁴

Many teams gravitate toward stronger types as AI writes more code. Without them, you’re “navigating fog” with runtime errors as your compass. But mainstream static types often stop short of what agentic workflows demand. They don’t encode behavioral promises, constrain effects precisely, prove protocol adherence, expose minimal counterexamples, or turn intent into a first-class review artifact.²⁵²⁶²⁷

Readability as Throughput

#

When humans mostly review, source code targets future reviewers, security auditors, incident responders, and the agent itself, all of which benefit from consistent structure.

If syntax encourages cleverness, deeply nested abstractions, or implicit control flow, agentic iteration produces diffs humans can’t confidently approve. Adversaries can compromise AI agents by embedding hard-to-detect backdoors during data collection, leading agents to perform unsafe or malicious actions when triggered. Once humans lose confidence, the agent becomes a liability rather than a productivity tool.²⁸²⁹³⁰

Making Intent Checkable

#

Agentic development works best when intent is expressed formally and readably, verified at compile time, constraining agent behavior while humans review intent first, then skim implementation for hazards, with the compiler emitting machine-actionable counterexamples when encoding fails. Related work includes runtime verification for agents, improved LLM-assisted specification generation for complex loop functions, and hybrid generative + verification workflows.^31323334

This isn’t about more tests. Tests are still essential. This is about moving from post-hoc validation to specification-driven construction. We need languages where what the program must do becomes an explicit, checkable artifact, not just a vibe. Adjacent directions include agentic graph compilation and context-oriented toolchain integration.³⁵³⁶³⁷

A Proposed Direction

#

These requirements point toward a language designed for the agentic era from first principles.

• Separation of intent and implementation means developers encode behavioral promises (contracts, invariants) and admissible side effects (capabilities/effects) directly in the source.
• Static verification as the inner loop means type checking doesn’t just catch mismatches. It validates intent constraints, refinement obligations, and protocol/session compliance.
• Diagnostics built for agents and reviewers include structured errors, deterministic output, provenance, reduced/minimal unsat cores, and repair-oriented suggestions.
• A large, opinionated standard library provides “one right way” patterns that reduce entropy, improve readability, and minimize supply-chain risk through reduced dependency sprawl.
• Optimization informed by specification means richer intent enables more aggressive, safe compilation, such as bounds-check elimination, specialization, and effect-aware reordering.

Agentic development demands more than better models. It requires a verification-native foundation. Without that, the loop won’t scale beyond toy demos, and humans remain the bottleneck. This is the missing piece. The path forward lies in toolchains and languages that prioritize verification, clear formal intent, and immediate feedback for scalable agent-human collaboration systems.