Probity - AIコーディングエージェントにTDDと開発ルールを守らせるガードレールツールProbity is a guardrail tool that enforces TDD workflows and development rules…

Software teams that have started delegating real coding work to AI agents such as Claude Code and OpenAI's Codex share a recurring frustration: even when a prompt explicitly asks the agent to follow test-driven development, the agent frequently writes the implementation first and the tests afterward, or skips the tests entirely. Probity is a guardrail tool designed to address exactly that gap, enforcing TDD workflows and broader development rules on AI coding agents so that the process is respected rather than merely requested. It is positioned as the successor to an earlier tool called TDD Guard.

The core problem Probity targets is that natural-language instructions are not guarantees. Prompting an agent to "write the failing test first" nudges its behavior but does not bind it, because these agents are non-deterministic and may reorder steps, rationalize shortcuts, or ignore project conventions when they conclude a different path is faster. For teams that treat TDD as a discipline rather than a suggestion, that unpredictability undermines the whole point of the practice. A guardrail approach shifts enforcement out of the prompt and into an external mechanism that can observe what the agent is doing and intervene when it strays from the intended workflow.

TDD Guard, hosted at github.com/nizos/tdd-guard, established this pattern for Claude Code. Its mechanism and setup have been documented in detail in community write-ups, including a Zenn article referenced alongside Probity's introduction. Tools in this category generally work by hooking into the agent's execution loop, inspecting proposed file edits or commands, and blocking actions that violate the expected order of operations. In a TDD context, that typically means preventing implementation code from being written before a corresponding failing test exists, and ensuring the red-green-refactor cycle is honored step by step. Probity appears to extend this idea beyond TDD alone to encompass wider development rules and project conventions, which suggests it is meant to codify a team's standards, not just its testing order.

Probity is described specifically as a migration destination for TDD Guard users, which implies an intent to preserve the same guardrail philosophy while broadening scope or improving coverage across agents. The explicit mention of both Claude Code and Codex is notable, because it points toward tooling that is not tied to a single vendor's agent. As more coding assistants adopt similar hook and permission systems, a guardrail that can sit in front of multiple agents is likely to be more durable than one built for a single product. Readers considering a switch should still verify the exact setup steps and compatibility for their environment, since those details govern how much of an existing TDD Guard configuration carries over.

The broader context here is the rapid maturation of agentic coding. Over the past year, assistants have moved from autocompleting lines to executing multi-step tasks: reading a repository, editing several files, running test suites, and iterating on failures with limited human oversight. That autonomy raises the stakes for process control, because an agent that skips tests can produce code that looks complete but lacks the safety net a team relies on. Guardrail tools such as Probity fit into a growing ecosystem of controls around AI agents, alongside features like permission prompts, sandboxed execution, and hook systems that let developers script custom checks before an action is allowed to proceed.

For teams already invested in test-driven development, the appeal is straightforward: TDD's value comes from its ordering, where a failing test defines the expected behavior before any code is written to satisfy it. If an agent inverts that order, the resulting tests may be written to match whatever the implementation happens to do, which quietly erodes their usefulness. Enforcing the sequence mechanically restores the intended feedback loop regardless of how the underlying model behaves on a given run.

As with any tool of this kind, the practical trade-off is friction versus reliability. Stricter enforcement can interrupt an agent mid-task and require more careful configuration, but it also makes the agent's output more trustworthy for teams that cannot afford to audit every change by hand. Whether Probity becomes a common replacement for TDD Guard will likely depend on how smoothly it handles that balance and how well it integrates with the coding agents developers are already using.