Specification First: Agentic Development Plugin Prove Debuts on Hacker News

When AI Agents Start Writing Code, Who Ensures They Get It Right?

A Show HN project called "Prove" has appeared on Hacker News, positioned as a specification-first agentic development plugin. Although the post hasn't gained much traction (4 points, 0 comments), the problem it addresses is quite substantive: as AI agents increasingly participate in code generation, what developers need is not more generation capability, but engineering constraints that put "specification" before "generation."

The project's name itself carries an attitude—Prove. It suggests not letting AI "try writing something and see," but rather constraining AI with specifications before it writes code, and verifying the results afterward.

What Exactly Is Specification-First Prioritizing?

The traditional AI coding assistant workflow roughly goes: give a prompt → model generates code → human review. The problem is that model-generated code often "looks right," but deviates from what the developer actually intended, and the review cost is not insignificant.

The specification-first approach reverses the order: first describe "what to do" in some formal specification, have the AI agent generate an implementation under this constraint, then verify the implementation against the specification. Prove's appearance as a plugin means it wants to embed this workflow into developers' existing processes rather than building a separate standalone platform.

Judging from the project's positioning, it covers both the "development" and "proof" ends—constraining the generation process while also providing verifiable evidence for the results.

Specification First is not an entirely new concept in software engineering; it derives from the traditions of formal methods and Design by Contract. Its core idea is: before implementation, precisely describe what the system "should do" in precise language, including preconditions, postconditions, and invariants, then let the implementation satisfy these constraints. Compared to natural language prompts, the advantage of formal specifications is machine-checkability—a verifier can automatically compare whether implementation behavior matches specification claims. In AI coding scenarios, specification-first decouples "intent expression" from "code generation": specifications are the human's responsibility, generation is done by AI agents, and verification is automatically executed by the toolchain. This is similar to test-driven development (TDD), but specifications emphasize a complete characterization of behavior rather than merely covering a few examples.

The Trade-offs of the Plugin Form

Choosing a plugin rather than a standalone tool is a pragmatic decision. Agentic development involves editors, version control, test environments, and multiple other components; a plugin can follow the existing toolchain, reducing migration costs. The price is that the plugin's capability boundaries are limited by the host environment, and the design space for specification languages and verification mechanisms is also compressed.

Another point worth noting is the expectation implicit in the name "Prove": it doesn't just generate code, it also provides some kind of checkable conclusion. This is a more engineering-oriented direction among AI coding tools, contrasting with the route of pursuing "generate an entire application from one sentence."

Agentic development refers to letting AI agents autonomously complete multi-step tasks with fewer step-by-step instructions, such as reading codebases, modifying multiple files, running tests, and iterating based on results. Unlike single-round code completion, agentic agents need access to editor context, version control state, and test environments, thus requiring higher levels of toolchain integration. The plugin form allows agents to directly read the host editor's buffers, call its diagnostic interfaces, and present generation results as patches for easy human review. However, plugins run within the host's sandbox and typically cannot freely install system-level dependencies or customize a complete verification runtime, which limits the expressiveness of specification languages and the depth of verifier implementations.

Why Projects Like This Are Worth Watching

Discussions about AI coding have long focused on model capabilities, but what really determines practical outcomes is often engineering constraints. The specification-first approach puts human intent upfront and verification at the end, leaving the middle for AI agents to fill in—this makes responsibility division clearer: when problems arise, you can pinpoint whether the specification was unclear or the implementation deviated from it.

Information about this project is currently limited, and its popularity is low, but it represents a category of emerging tools: not pursuing stronger generation, but pursuing more controllable generation. For teams introducing AI agents into real projects, this direction may have more long-term value than yet another code completion plugin.

(Note: This article is based on Hacker News project release information. Specific implementation details of the project have not yet been made public, and its future performance remains to be seen.)

Verifiable generation is a direction that is differentiating within AI coding tools. The mainstream route aims to improve model generation quality, reducing manual modifications through larger models, more context, and stronger completion; another route focuses on "whether generation results can be independently verified," with typical approaches including: having AI simultaneously produce implementations and formal specifications, then using SMT solvers or property testing tools for consistency checks; or requiring agents to pass a set of tests automatically derived from specifications before submitting code. The value of the latter lies in transforming AI's uncertainty into an auditable evidence chain—even if generation cannot be guaranteed to be completely correct, it can define the meaning of "correct" at the specification level and automatically alert when implementations deviate.

One-line Summary

Prove plugin advocates writing specifications first before letting AI generate code, pursuing controllable and verifiable generation.

Paragraph Summary

The Prove project on Hacker News is a specification-first agentic development plugin that advocates using formal specifications to constrain "what to do" before AI generates code, and then verifying implementations against specifications after generation. The article analyzes how this approach inverts the traditional "prompt→generation→human review" process, noting that responsibility division becomes clearer: when problems arise, you can pinpoint whether specifications were unclear or implementations deviated. The plugin form reduces migration costs but limits capabilities to the host environment. The article argues that such tools—pursuing controllable generation rather than stronger generation capability—may have more long-term value for teams introducing AI agents into real projects, though project implementation details have not yet been made public.