Claude Skill

judgment-day

Trigger: judgment day, dual review, adversarial review, juzgar. Run explicit blind dual review with at most two scoped fix/re-judgment rounds.

LLM Mart · 0 points · 10 views 0 listing impressions 0 install-command copies
Virus-scanned Reviewed automatically before listing.

Full trust report

Download gentleman-programming-gentle-ai-internal_assets_skills_judgment-day-d2e3443.zip · 3 KB
Part of gentleman-programming/gentle-ai — 36 skills

Install

skills CLI npx skills add https://github.com/Gentleman-Programming/gentle-ai/tree/main/internal/assets/skills/judgment-day
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install gentleman-programming-gentle-ai@llmmart
Git git clone https://github.com/Gentleman-Programming/gentle-ai.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole gentleman-programming/gentle-ai collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Activation Contract

Load only when the user explicitly requests Judgment Day or equivalent dual/adversarial review for a concrete target. Judgment Day is a standalone developer tool: judges run whenever asked, on any runtime, and need no review transaction, runtime identity, or delivery-receipt machinery to start. It replaces ordinary 4R as the adversarial method for that target; never run both.

Hard Rules

  • Resolve matching project skills before starting and pass the same paths to both judges (jd-judge-a, jd-judge-b) and the fix actor (jd-fix-agent).
  • Build one complete immutable target, then launch two blind read-only judges in parallel with identical scope and criteria.
  • Each judge returns one neutral findings result and terminates. Wait for both; never accept a partial judgment.
  • Never launch review-refuter; two-judge agreement is the corroboration mechanism.
  • Only the parent orchestrator merges/persists findings, launches the fix actor (jd-fix-agent), and launches scoped re-judgment.
  • Fix only severe findings confirmed by both judges. WARNING/SUGGESTION rows remain info.
  • Permit at most two fix rounds and two scoped re-judgments. Re-judgment sees only the frozen ledger plus fix delta and may record fix-caused defects.
  • The only terminal verdicts are APPROVED | ESCALATED; never reset or extend an exhausted round budget.
  • A judgment issues no receipt and carries no delivery authority: it satisfies no commit, push, PR, or release gate. When the caller explicitly wants ordinary negotiated review for the same target, run it as its own step; neither outcome authorizes delivery, which remains under ordinary repository policy.

Decision Gates

Condition Action
Target unclear Ask one scope question and stop.
Both judges confirm severe finding Ask before round-one correction; then use the bounded fix actor.
One judge reports it Record suspect; do not auto-fix.
Judges contradict Escalate for explicit human decision.
Scoped re-judgment fails before round two Parent may launch the final bounded fix round.
Any issue remains after round two Escalate and stop.

Execution Steps

  1. Build the complete immutable target and freeze the scope both judges will inspect.
  2. Launch both read-only judges in parallel (jd-judge-a, jd-judge-b) against the same immutable target.
  3. Merge findings into the frozen ledger and persist it through the selected artifact store.
  4. Ask before round-one correction; run the fix actor (jd-fix-agent) only for confirmed severe IDs.
  5. Run both judges again (jd-judge-a, jd-judge-b) only over the frozen ledger plus immutable fix delta.
  6. Repeat once at most, then run independent final verification and return the terminal verdict.

Output Contract

Return target identity, round, confirmed/suspect/contradiction/INFO counts, correction work units, scoped re-judgment result, artifact references, skill resolution, and exactly one final JUDGMENT: APPROVED ✅ or JUDGMENT: ESCALATED ⚠️.

References

Files (gentle-ai)
  • references
    • prompts-and-formats.md 3 KB
      # Judgment Day Prompts and Formats
      
      ## Judge Prompt
      
      ```markdown
      You are blind Judge {A|B} in explicit Judgment Day mode.
      
      Target: {immutable target identity and exact paths}
      Skills to load: {resolved SKILL.md paths}
      Criteria: correctness, edge cases, error handling, performance, security, and project conventions.
      
      Run one exhaustive read-only sweep. Do not edit, delegate, refute, or inspect unrelated scope. If scoped re-judging, read ONLY the frozen ledger and immutable fix delta; record any fix-caused defect with proof.
      
      Return one JSON object and no prose, using exactly this native result shape:
      
      {"findings":[{"location":"path:line or path:start-end","severity":"CRITICAL","claim":"observable incorrect behavior","evidence_class":"deterministic","causal_disposition":"introduced","proof_refs":["concrete proof"]}],"evidence":["what was inspected"]}
      
      This is a judgment-day judge result, not a `gentle-ai review capture-result` lens artifact. Judgment day selects no lenses and records your work as a judge proof, so your result carries no bound artifact subject and no inspection envelope. The only allowed top-level fields are `findings` and `evidence`, and the only allowed finding fields are `location`, `severity`, `claim`, `evidence_class`, `causal_disposition`, and `proof_refs`. Never emit `summary`, `skill_resolution`, or any other unknown field. Keep orchestration metadata outside the native result JSON; `evidence` contains only genuine inspection evidence. Return `{"findings":[],"evidence":["what was inspected"]}` when clean, then terminate.
      ```
      
      > This shape governs judgment-day judges only. An ordinary bounded review lens is a different artifact: it is captured with `gentle-ai review capture-result`, and its result must additionally echo the binding's top-level `subject_hash` and a completed `inspection` envelope, or admission refuses it. `gentle-ai review schema reviewer` emits that schema with a working example. The two shapes are not interchangeable, and neither one is a relaxation of the other.
      
      ## Fix Actor Prompt
      
      ```markdown
      You are the bounded Judgment Day fix actor.
      
      Confirmed severe ledger IDs: {table}
      Skills to load: {resolved SKILL.md paths}
      
      Apply only confirmed fixes as atomic work units. For each unit, record focused test result, runtime evidence or justified N/A, and rollback boundary. Never review, add findings, refactor unrelated code, or launch another actor. Mark addressed IDs fixed and return control to the parent orchestrator for scoped re-judgment.
      
      End with: Skill Resolution: {paths-injected|fallback-registry|fallback-path|none} — {details}
      ```
      
      ## Verdict Shape
      
      ```yaml
      target_identity: <sha256>
      round: 1 | 2
      confirmed: []
      suspect: []
      contradictions: []
      info: []
      fix_work_units: []
      scoped_rejudgment: approved | escalated | not_run
      terminal_state: approved | escalated
      skill_resolution: <value>
      ```
      
      Warnings and suggestions are informational. After the second scoped re-judgment, remaining severe findings require `escalated`; no third round exists.
      
  • SKILL.md 3.6 KB
    ---
    name: judgment-day
    description: "Trigger: judgment day, dual review, adversarial review, juzgar. Run explicit blind dual review with at most two scoped fix/re-judgment rounds."
    license: Apache-2.0
    metadata:
      author: gentleman-programming
      version: "1.7"
    ---
    
    ## Activation Contract
    
    Load only when the user explicitly requests Judgment Day or equivalent dual/adversarial review for a concrete target. Judgment Day is a standalone developer tool: judges run whenever asked, on any runtime, and need no review transaction, runtime identity, or delivery-receipt machinery to start. It replaces ordinary 4R as the adversarial method for that target; never run both.
    
    ## Hard Rules
    
    - Resolve matching project skills before starting and pass the same paths to both judges (`jd-judge-a`, `jd-judge-b`) and the fix actor (`jd-fix-agent`).
    - Build one complete immutable target, then launch two blind read-only judges in parallel with identical scope and criteria.
    - Each judge returns one neutral findings result and terminates. Wait for both; never accept a partial judgment.
    - Never launch `review-refuter`; two-judge agreement is the corroboration mechanism.
    - Only the parent orchestrator merges/persists findings, launches the fix actor (`jd-fix-agent`), and launches scoped re-judgment.
    - Fix only severe findings confirmed by both judges. WARNING/SUGGESTION rows remain `info`.
    - Permit at most two fix rounds and two scoped re-judgments. Re-judgment sees only the frozen ledger plus fix delta and may record fix-caused defects.
    - The only terminal verdicts are `APPROVED | ESCALATED`; never reset or extend an exhausted round budget.
    - A judgment issues no receipt and carries no delivery authority: it satisfies no commit, push, PR, or release gate. When the caller explicitly wants ordinary negotiated review for the same target, run it as its own step; neither outcome authorizes delivery, which remains under ordinary repository policy.
    
    ## Decision Gates
    
    | Condition | Action |
    |---|---|
    | Target unclear | Ask one scope question and stop. |
    | Both judges confirm severe finding | Ask before round-one correction; then use the bounded fix actor. |
    | One judge reports it | Record suspect; do not auto-fix. |
    | Judges contradict | Escalate for explicit human decision. |
    | Scoped re-judgment fails before round two | Parent may launch the final bounded fix round. |
    | Any issue remains after round two | Escalate and stop. |
    
    ## Execution Steps
    
    1. Build the complete immutable target and freeze the scope both judges will inspect.
    2. Launch both read-only judges in parallel (`jd-judge-a`, `jd-judge-b`) against the same immutable target.
    3. Merge findings into the frozen ledger and persist it through the selected artifact store.
    4. Ask before round-one correction; run the fix actor (`jd-fix-agent`) only for confirmed severe IDs.
    5. Run both judges again (`jd-judge-a`, `jd-judge-b`) only over the frozen ledger plus immutable fix delta.
    6. Repeat once at most, then run independent final verification and return the terminal verdict.
    
    ## Output Contract
    
    Return target identity, round, confirmed/suspect/contradiction/INFO counts, correction work units, scoped re-judgment result, artifact references, skill resolution, and exactly one final `JUDGMENT: APPROVED ✅` or `JUDGMENT: ESCALATED ⚠️`.
    
    ## References
    
    - [references/prompts-and-formats.md](references/prompts-and-formats.md) — compact judge/fix prompts and verdict shape.
    - [../_shared/review-ledger-contract.md](../_shared/review-ledger-contract.md) — optional ordinary negotiated-review context: consult it only when the caller explicitly requests that lifecycle; never required to run judges and never delivery authorization.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.

Related