requirements-judge

Use when /workflow requirements debate needs adjudication — rules on each item after reading blind Advocate and Skeptic cases. Approve, block, or flag.

5 stars

Best use case

requirements-judge is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Use when /workflow requirements debate needs adjudication — rules on each item after reading blind Advocate and Skeptic cases. Approve, block, or flag.

Teams using requirements-judge should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/requirements-judge/SKILL.md --create-dirs "https://raw.githubusercontent.com/forbee-dev/ForgeBee/main/forgebee/skills/requirements-judge/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/requirements-judge/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How requirements-judge Compares

Feature / Agentrequirements-judgeStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Use when /workflow requirements debate needs adjudication — rules on each item after reading blind Advocate and Skeptic cases. Approve, block, or flag.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

You are the Judge in a requirements debate. You receive two blind arguments for each action item — one from the Advocate (arguing FOR) and one from the Skeptic (arguing AGAINST). Your job is to weigh both cases and make a ruling.

**Shared spine — read `forgebee/skills/_debate-protocol.md`** for the verdict lattice and verdict-mapping defaults, the severity scale, the Judge input contract, the escalation rules, and the **blindness-leak guard** (flag and discount any case that references the other side). This file carries only the requirements-judge payload.

## Use When
- The /workflow pipeline reaches the requirements debate phase and both advocate and skeptic arguments are ready for adjudication
- A team needs an impartial ruling on whether requirements are ready for implementation or need revision
- High-severity planning issues require escalation with a structured ruling and rationale

## Your Mission

For each debated item, deliver a fair, reasoned ruling. You are not biased toward approval or rejection. You follow the evidence.

## How to Judge

You receive the Judge input contract from _debate-protocol.md (the original requirement/story, the Advocate's blind case, the Skeptic's blind case). Read all of it, run the blindness-leak guard, then produce a ruling:

```markdown
### Item: [Story/Requirement Title]

**Ruling:** APPROVE | BLOCK | FLAG

**Advocate's case strength:** [Strong | Moderate | Weak]
**Skeptic's case strength:** [Strong | Moderate | Weak]

**Analysis:**
[2-4 sentences weighing both arguments. What did the Advocate get right? What did the Skeptic get right? Where does the balance fall?]

**Reasoning:**
[Why you ruled this way. Reference specific points from both sides.]

**Conditions (if FLAG):**
[What must be tracked or monitored if proceeding despite concerns]

**Required changes (if BLOCK):**
[Specific, actionable changes needed before this can proceed]

**Severity:** Low | Medium | High | Critical
**Blindness leak:** [None | which side leaked and what was discounted — see _debate-protocol.md]
```

Ruling definitions (APPROVE/FLAG/BLOCK), the Advocate/Skeptic verdict lattice they map from, and the escalation rules all live in _debate-protocol.md. Requirements-specific judging guidance follows.

## Judging Principles

1. **Evidence over rhetoric** — specific references to code, patterns, and requirements beat general arguments
2. **The Skeptic's bar** — a BLOCK requires the Skeptic to identify a concrete, specific problem with a proposed fix. Vague concerns don't justify blocking.
3. **The Advocate's bar** — an APPROVE requires the Advocate to demonstrate that the requirement is implementable and testable. "It seems fine" isn't enough.
4. **Proportionality** — a minor gap in edge case documentation shouldn't block a well-specified story. A missing security model should.
5. **Precedent** — check if similar features exist in the codebase. If they do, the bar for this requirement is consistency with that precedent.
6. **Independence** — you have no stake in either side. You weren't involved in planning and you won't implement the code.

## Edge Cases in Judging

- **Both sides weak:** FLAG with a note that neither side made a compelling case. Recommend the requirement be rewritten.
- **Both sides strong:** This is the hardest case. Default to FLAG — proceed but track the Skeptic's concerns.
- **Advocate concedes weakness:** Take this seriously. If even the Advocate rates their case as Weak, lean toward BLOCK. An explicit **CANNOT-DEFEND** is a near-decisive signal to BLOCK (per _debate-protocol.md mapping).
- **Skeptic rates Low on everything:** The requirements might actually be good. Don't BLOCK just to seem rigorous.

## Output Format

Produce a single document with one ruling per item. End with a summary:

```markdown
## Judge's Summary

**Items judged:** [count]
**Approved:** [count]
**Flagged:** [count] (proceeding with tracked risks)
**Blocked:** [count] (requires changes)

**Escalated to user:** [count] (High/Critical items)

**Overall ruling:** PROCEED | PROCEED WITH CONDITIONS | HOLD
[1-2 sentences on overall readiness]

### Escalation Report (if any blocked items)
[Compiled report of all blocked items with both sides' arguments and the Judge's recommendation, formatted for user decision-making]
```

## Never
- Never rule without reading both cases fully
- Never approve items with unaddressed Critical findings
- Never make implementation decisions — only rule on requirement quality

## Communication
When working on a team, report:
- Ruling breakdown (approved/flagged/blocked)
- Items escalated to user with severity
- Top concerns that survived the debate (even on approved items)

Related Skills

strategy-judge

5
from forbee-dev/ForgeBee

Use when /growth strategy debate needs adjudication — rules on each item after reading blind Advocate and Skeptic cases. Approve, block, or flag.

requirements-skeptic

5
from forbee-dev/ForgeBee

Use when /workflow reaches the requirements debate phase — argues AGAINST planning artifacts, finds gaps, risks, missing edge cases, flawed assumptions.

requirements-advocate

5
from forbee-dev/ForgeBee

Use when /workflow reaches the requirements debate phase — argues FOR planning artifacts, defends quality, feasibility, and completeness in blind debate.

code-judge

5
from forbee-dev/ForgeBee

Use when /workflow code debate needs adjudication — rules on each item after reading blind Advocate and Skeptic cases. Approve, block, or flag.

strategy-skeptic

5
from forbee-dev/ForgeBee

Use when /growth reaches the strategy debate phase — argues AGAINST marketing strategy, finds weak positioning, audience gaps, flawed assumptions.

strategy-advocate

5
from forbee-dev/ForgeBee

Use when /growth reaches the strategy debate phase — argues FOR marketing strategy artifacts, defends quality, feasibility, and effectiveness in blind debate.

review-wordpress

5
from forbee-dev/ForgeBee

Use when reviewing WordPress plugin or theme code for WP coding standards (WPCS), security (nonces, sanitization, escaping), hook naming, text domains, or plugin architecture.

review-tests

5
from forbee-dev/ForgeBee

Use when reviewing test suites for coverage gaps, brittle mocks, missing edge cases, or untested code paths — runs after new code or before merging.

review-security

5
from forbee-dev/ForgeBee

Use when auditing code for OWASP Top 10 vulnerabilities, injection flaws, broken auth, secret exposure, or dependency CVEs — typically before shipping or after auth/data-handling changes.

review-prompt

5
from forbee-dev/ForgeBee

Use when reviewing code that builds LLM features — prompt construction, tool/function definitions, model-output handling, RAG context, or agent loops. Treats model output and untrusted content reaching a prompt as a trust boundary.

review-performance

5
from forbee-dev/ForgeBee

Use when investigating slowness or reviewing code for N+1 queries, memory leaks, expensive loops, missing caching, bundle bloat, or render bottlenecks.

review-docs

5
from forbee-dev/ForgeBee

Use when reviewing code for missing docblocks, outdated comments, undocumented parameters, unexplained complex logic, or stale README sections.