jibuff: A Specification-Driven Workflow Framework for AI Programming Agents

jibuff is an open-source specification-driven workflow framework designed to address the problem of ambiguous requirements faced by AI programming agents. Through multi-round clarification interviews, specification locking, and a validation loop, jibuff helps developers eliminate requirement ambiguities before AI agents execute tasks, reducing computational costs and improving code quality.

With the rapid development of AI programming agents like Claude Code and Codex, developers are increasingly relying on these tools to automate code generation tasks. However, the powerful capabilities of AI agents also bring a core problem: ambiguous or conflicting requirement specifications lead to costly rework.

When developers input an unclear requirement to an AI agent, the agent may generate code that does not meet expectations, which not only wastes computational resources but also shifts the debugging burden back to the developer. This "requirement jitter" problem is particularly prominent in fields with high stability requirements, such as real-time communication and media processing.

jibuff (named after the "jitter buffer" in real-time communication) draws on technical concepts from the real-time communication field. In audio and video transmission, a jitter buffer is used to absorb timing inconsistencies and ensure the decoder receives a stable data stream. jibuff applies this concept to AI programming workflows: before requirements reach the AI agent, sufficient clarification and solidification are performed to eliminate ambiguities.

The core workflow of the framework follows five phases:

1. Interview: Clarify requirements through multi-round dialogues, using a hybrid ambiguity scoring mechanism (keyword coverage + conflict detection + dimension clarity) to quantify the clarity of requirements

2. Spec Lock: Generate and freeze the tasks.md specification document; scope changes are not allowed during agent execution

3. Agent Loop: The LoopController feeds tasks one by one to a new Claude subprocess to avoid session state contamination

4. Validation: Run a configurable stack of validators after each task is completed, including code checks, type checks, testing, security scans, etc.

5. Artifact: Passed or failed artifacts are written to the storage directory; each task can only see its own historical context

jibuff provides two operation modes to adapt to different scenarios:

• Ambiguity threshold: ≤ 0.25
• Risk gate: None
• Maximum interview rounds: 5
• Validator stack: Code check, type check, testing, security scan
• Applicable scenarios: General functions, scripts, API development

• Ambiguity threshold: ≤ 0.15 (stricter)
• Risk gate: < 0.4
• Maximum interview rounds: 8
• Validator stack: Adds device, network, fallback mechanism, and firewall checks to the Quick mode stack
• Applicable scenarios: WebRTC, media processing, real-time protocol development

This layered strategy allows developers to choose the appropriate level of strictness based on project criticality, ensuring the reliability of key systems without affecting the efficiency of daily development.

jibuff adopts a strict context isolation design; each task runs in a new subprocess and can only access the context of the current task. This design avoids the context contamination problem common in long sessions, ensuring each decision is based on clear and relevant information.

jibuff can be registered as an MCP (Model Context Protocol) server in Claude Code, exposing four core tools:

• jibuff_interview: Start or continue an interview session
• jibuff_run: Execute the specification loop
• jibuff_status: Query the current loop status
• jibuff_cancel: Terminate the running loop

This integration allows developers to directly call jibuff's capabilities in the familiar Claude Code environment without switching tools.