Skip to main content
skill CX Codex

human-gate-designer — Claude Code skill for human review points in DAG workflows

human-gate-designer designs human-in-the-loop review points for DAG workflows: what to show a person, how to collect feedback, and how to route it back. Fits when you add approval gates to agent pipelines.

MIT 141 installs ★ 274 updated 2026-10-30

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add curiositech/some_claude_skills --skill human-gate-designer -a claude-code
Open on GitHub

What human-gate-designer does

The skill decides where a DAG needs a human gate. Its decision tree covers four triggers: irreversible actions like deploy or email send, user-facing deliverables such as reports and pull requests, remaining budget over $0.50, and confidence below 0.7. Gates go before irreversible steps or after generation but before delivery.

Presentation design is a separate section. The human sees one or two sentences of context, highlighted agent decisions, a confidence score, money spent against budget, and remaining nodes. Three buttons: Approve, Modify, Reject. Modify opens a text field, and that text gets injected into the retry prompt for the node.

Feedback routing branches heavily. Approve continues the DAG. Modify re-runs the node with the human's text and brings the result back for review. Reject can target a single node, an entire phase, or stop the DAG and return partial results.

The README lists anti-patterns worth remembering. Don't gate after every node, and don't settle for binary approve/reject — without a Modify option the human can't give a specific correction. Raw JSON with no context makes a gate useless. The skill is limited to Read, Write and Edit tools.

What it helps with

  • pick which DAG nodes need a human gate
  • design the review screen a person sees
  • inject Modify feedback into the node retry prompt
  • route approve, reject and modify into different DAG branches
  • avoid gating every single node in a workflow

Example prompts for the agent

  • Design an approval gate before the email send step in my DAG
  • Where should I put a human review point in this workflow?
  • How do I present a review screen for a node with confidence 0.65?

How to install human-gate-designer

1Skills CLI (Vercel)

npx skills add curiositech/some_claude_skills --skill human-gate-designer -a claude-code

2Manually: put the files in place

~/.claude/skills/human-gate-designer/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/human-gate-designer/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about human-gate-designer

How do I install human-gate-designer in Claude Code?

Run npx skills add curiositech/some_claude_skills --skill human-gate-designer -a claude-code. The skill lands in ~/.claude/skills/human-gate-designer/SKILL.md.

What does human-gate-designer do?

It designs human-in-the-loop review points for DAG workflows: where to place them, what to show the person, and how to route approve/reject/modify decisions back into the graph.

Does it run gates at runtime?

No. Runtime execution is a separate concern — the README points to dag-runtime with Temporal signals for that.

Source text

SKILL.md · MIT
---
name: human-gate-designer
description: Designs human-in-the-loop review points for DAG workflows. Determines what to present to the human, how to collect feedback, and how to route approve/reject/modify decisions back into the DAG.
  Use when adding approval gates, designing review UX, or handling human feedback in agent workflows. Activate on "human review", "approval gate", "human-in-the-loop", "human gate", "approval workflow",
  "user review step". NOT for executing human gates at runtime (use dag-runtime with Temporal signals), general UX design, or chatbot conversation design.
allowed-tools: Read,Write,Edit
metadata:
  category: Design & Creative
  tags:
  - human
  - gate
  - designer
  - human-review
  - approval-gate
  pairs-with:
  - skill: task-decomposer
    reason: Task decomposition identifies which DAG nodes require human approval gates
  - skill: output-contract-enforcer
    reason: Human gate inputs and outputs need schema validation before routing decisions
  - skill: reactflow-expert
    reason: Human gates are visualized as interactive approval nodes in DAG dashboards
---

# Human Gate Designer

Designs human-in-the-loop review points in DAG workflows: what to present, how to collect feedback, how to route decisions back into the DAG.

---

## When to Use

✅ **Use for**:
- Deciding WHERE in a DAG to place human gates
- Designing WHAT the human sees at each gate
- Defining HOW feedback routes back (approve/reject/modify)
- Balancing automation speed with human oversight

❌ **NOT for**:
- Runtime execution of human gates (use `dag-runtime` + Temporal signals)
- General UI/UX design (use design skills)
- Chatbot conversation flow (different pattern)

---

## Gate Placement Decision Tree

```mermaid
flowchart TD
  A{Is the action irreversible?} -->|Yes| G1[Gate BEFORE the action]
  A -->|No| B{Is output user-facing?}
  B -->|Yes| G2[Gate AFTER generation, BEFORE delivery]
  B -->|No| C{Cost > $0.50 for remaining nodes?}
  C -->|Yes| G3[Gate at the cost threshold]
  C -->|No| D{Confidence score < 0.7?}
  D -->|Yes| G4[Gate on low-confidence outputs]
  D -->|No| N[No gate needed]
```

### Where to Place Gates

| Situation | Gate Position | Why |
|-----------|-------------|-----|
| Irreversible action (deploy, send email, submit) | Before the action | Can't undo |
| User-facing deliverable (report, website, PR) | After generation, before delivery | Quality check |
| High cost remaining (>$0.50) | Before expensive phase | Budget confirmation |
| Low confidence output (&lt;0.7) | After the uncertain node | Expert judgment needed |
| Ambiguous task decomposition | After planning, before execution | Validate the plan |
| First run of a new template DAG | After each phase | Build trust gradually |

---

## Gate Presentation Design

### What the Human Sees

```
┌──────────────────────────────────────────────────────┐
│  🔍 Human Review: [Node Name]                        │
│                                                      │
│  Context: [1-2 sentences: what happened so far]      │
│                                                      │
│  Output to Review:                                   │
│  ┌──────────────────────────────────────────────────┐│
│  │ [The node's output, formatted for readability]   ││
│  │ [Key decisions highlighted]                      ││
│  │ [Confidence: 0.82]                               ││
│  └──────────────────────────────────────────────────┘│
│                                                      │
│  Cost so far: $0.08 / $0.50 budget                  │
│  Remaining nodes: 4 (est. $0.12)                    │
│                                                      │
│  [✅ Approve]  [✏️ Modify]  [❌ Reject]              │
│                                                      │
│  If modifying, what should change?                   │
│  ┌──────────────────────────────────────────────────┐│
│  │ [text input for human feedback]                  ││
│  └──────────────────────────────────────────────────┘│
└──────────────────────────────────────────────────────┘
```

### Presentation Principles

1. **Show context, not just output**: The human needs to understand what the DAG has done so far, not just the current node's result.
2. **Highlight decisions**: Bold or annotate the choices the agent made. These are what the human is actually reviewing.
3. **Show confidence**: If the agent was uncertain, say so. Low-confidence outputs need more scrutiny.
4. **Show cost**: The human should know what they've spent and what's remaining.
5. **Make "Modify" easy**: A text input for feedback that gets injected into the retry prompt.

---

## Feedback Routing

```mermaid
flowchart TD
  H[Human decision] --> A{Decision?}
  A -->|Approve| C[Continue to next wave]
  A -->|Modify| M[Re-execute node with human feedback injected]
  M --> V[Validate modified output]
  V --> H
  A -->|Reject| R{Reject scope?}
  R -->|This node only| RN[Re-plan this node with different approach]
  RN --> H
  R -->|Entire phase| RP[Re-plan from last successful phase]
  RP --> H
  R -->|Abort DAG| AB[Stop execution, return partial results]
```

### Feedback Injection

When the human selects "Modify," their text becomes part of the re-execution prompt:

```
Original task: [same as before]
Previous output: [the output the human rejected]
Human feedback: "[the human's modification text]"

Revise your output to address the human's feedback.
Preserve the parts they didn't comment on.
```

---

## Anti-Patterns

### Gate After Every Node
**Wrong**: Requiring human approval after every single node.
**Right**: Gate only at irreversible actions, user-facing outputs, and low-confidence decisions. Most internal nodes need no gate.

### Binary Approve/Reject Only
**Wrong**: The human can only approve or reject, with no way to provide specific feedback.
**Right**: Always include a "Modify" option with a text input for targeted feedback.

### No Context in the Gate
**Wrong**: Showing the human a raw JSON output with no explanation.
**Right**: Show: what the DAG is doing, what happened so far, what this output means, what happens next if approved.

© curiositech · MIT · curiositech/some_claude_skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set180

The whole set →
git-workflow-expert git-workflow-expert — a git skill covering branching strategies, merge conflicts, rebase workflows, and recovery commands like bisect and reflog. Handy when history gets messy or a commit goes missing. CX Codex +1 143installs microservices-patterns The microservices-patterns skill helps plan service boundaries and communication patterns. Use it when assessing a monolith or designing a distributed system. CX Codex +1 142installs output-contract-enforcer output-contract-enforcer is a Claude Code skill that checks DAG node JSON against its schema and traces mismatches when a downstream node receives unexpected input. CX Codex +1 141installs anthropic-technical-deep-dive anthropic-technical-deep-dive builds deep technical preparation for Anthropic interviews: Constitutional AI, RLHF, interpretability, scaling laws, MCP, agentic systems, and AI safety. CX Codex +1 141installs error-handling-patterns The error-handling-patterns skill for Claude Code designs error handling in TypeScript and Python, supporting the choice between exceptions and Result types and the design of recovery flows. CX Codex +1 140installs dependency-management dependency-management guides agents through evaluating third-party packages, locking strict versions, and setting up security audits with Dependabot or Renovate. CX Codex +1 140installs component-template-generator component-template-generator is a Claude Code skill that creates React, Vue, and Svelte component templates using design tokens. It runs for component-library work and design-system implementation. CX Codex +1 139installs recursive-synthesis recursive-synthesis runs a document through six phases, from ten parallel agent positions to a merged final text. Built for constitutions, charters and architecture decisions. CX Codex +1 138installs

Project sponsors

Companies that keep this analytics open