Agile V: Claude skills for verifiable software engineering

Two points on Hacker News and zero comments. That's how discretely Agile V arrived on the public radar last Tuesday. Yet the repository raises a question that has been circulating for months among any team that has tried to put AI agents into production: how do you make an agent do what it promised, consistently and auditably?

The proposal is neither a new framework nor a SaaS platform. It's a set of skills for Claude—reusable packages of instructions and context—organized around what its authors call "verifiable engineering": the idea that every step an agent executes must be traceable, validatable, and repeatable.

What the repository contains

The project structures its skills around recognizable phases of the software development lifecycle: requirements analysis, design, implementation, code review, and testing. Each skill acts as a capsule of behavior that Claude invokes on demand from Claude Code, without needing to repeat instructions in each session.

The logic is straightforward: instead of writing a long prompt at the start of each task, the developer calls the corresponding skill and Claude knows exactly which criteria to apply, what output format to produce, and what checks to run before marking the task complete. It's essentially an attempt to bring something resembling quality control from industrial processes into work with agents.

The repository also includes references to hooks—shell commands that fire on Claude Code lifecycle events like `PreToolUse` or `PostToolUse`—to log what the agent did at each step. That's what the authors mean by "verifiable": not only that the result is correct, but that the process is documented.

Why this approach matters

The problem that Agile V tries to solve is real and everyday for any team using Claude Code on non-trivial projects. AI agents make errors non-deterministically: sometimes they follow instructions to the letter, sometimes they interpret them creatively. That variability is tolerable for low-risk tasks; in a CI/CD pipeline or in code generation that goes straight to production, it isn't.

The usual response has been to write longer instructions or add layers of human review. Agile V bets on a third way: encode expected behavior in auditable skills that can be versioned, shared across teams, and updated centrally. If the skill changes, all agents using it change with it.

It's not a new idea—structured workflows for LLMs have been discussed in the community for some time—but the fact that it's implemented directly on Claude Code's skills system gives it a practical advantage: it requires no additional infrastructure or custom wrappers.

Who this makes sense for

This tool isn't designed for occasional Claude users. Its natural audience is engineering teams who already have Claude Code integrated into their workflow and have run into the consistency problem: the agent works well in the demo, poorly in production.

It may also interest consultancies or studios like ours that build custom agents: having a catalog of verified skills is a way to guarantee predictable behavior without rewriting instructions project to project.

What it doesn't offer—at least in its current state—is integration with external MCP servers or an orchestration layer between sub-agents. It's a deliberately modest proposal: well-defined skills, hooks for traceability, nothing more.

Context and caveats

The repository just appeared and has minimal community activity. There's no extensive documentation, no documented use cases with metrics, and nothing is known about the team behind it. Discussion on Hacker News hasn't started yet, which makes it hard to assess real reception.

That doesn't invalidate it, but it does require taking it for what it is: an early-stage technical proposal, not a mature product.

From our perspective, it seems a reasonable direction. Agent verifiability is one of the most concrete unsolved problems in the Claude ecosystem, and attacking it from the skills layer—rather than building parallel infrastructure—is a pragmatic bet. If the project gains traction and documents real results, it will deserve attention.