Skill Graph

An RFC discovery skill that red-teams its own assumptions

A proposal written in one pass reads well and hides its assumptions. This graph studies feasibility, prior art, the interface and the failure modes separately, then a verifier that only sees their notes removes claims that rest on something nobody stated.

7 steps in 4 stages · 7 subagents · a kit of 12 files

Open in the studioDownload the kit

Free. Built in your browser; nothing is uploaded. No API key, no account.

How it runs

Steps in the same stage start at the same time. Each subagent gets only what its incoming edges carry, and a step in a fresh context never sees the reasoning of the steps before it. A gate decides whether the work passes, and a failed gate re-runs the work it checks.

  1. Stage 1

    • Split · Planner

      sonnet · Read

  2. Stage 24 in parallel

    • Feasibility Study · Worker

      haiku · Read, Grep, Glob, WebSearch, WebFetch

    • Prior Art · Worker

      haiku · Read, Grep, Glob, WebSearch, WebFetch

    • Interface / DX · Worker

      haiku · Read, Grep, Glob, WebSearch, WebFetch

    • Failure Modes · Worker

      haiku · Read, Grep, Glob, WebSearch, WebFetch

  3. Stage 3

    • VERIFIER (Fresh Context) · Checker

      opus · Read, Grep, Glob · fresh context

      Gate: No kept claim rests on an unstated assumption.

  4. Stage 4

    • Final answer · Writer

      sonnet · Read

Use it when

  • You are about to write a design doc or RFC.
  • You want prior art and failure modes before anyone builds.
  • Reviews of your proposals keep finding the same gaps.

Change these first

  • Rename the sections of the final answer to your team's RFC template.
  • Add a cost or security worker if your reviews always ask about it.

Need a workflow built for your team? Fixed-price packages

What you get

An orchestrating SKILL.md, one Claude Code subagent per step with its own tools and model, and the same skill as a Cursor rule. Your agent runs it with its own subagents; nothing on this site calls a model.

rfc-discovery-graph-skill-kit.zip12 files
  • .claude/skills/rfc-discovery-graph/SKILL.mdorchestrator
  • .claude/skills/rfc-discovery-graph/graph.skill.mdgraph source
  • .claude/agents/rfc-discovery-graph-splitter.mdsubagent
  • .claude/agents/rfc-discovery-graph-feasibility.mdsubagent
  • .claude/agents/rfc-discovery-graph-prior-art.mdsubagent
  • .claude/agents/rfc-discovery-graph-interface-design.mdsubagent
  • .skill-graph/.gitignoresupport
  • .cursor/rules/rfc-discovery-graph.mdcCursor rule
  • README.mdreadme
  • + 3 more subagents
.claude/skills/rfc-discovery-graph/SKILL.md
---
name: rfc-discovery-graph
description: "Explores a proposal from four angles in parallel, red-teams unstated assumptions in a fresh context, and drafts an RFC."
---

# rfc-discovery-graph

Explores a proposal from four angles in parallel, red-teams unstated assumptions in a fresh context, and drafts an RFC.

This skill is a graph: each step has its own prompt and context, and only the payloads named below move between steps.

## Plan

Run the stages in order. Every model step runs in its own subagent; do not do a step's work yourself. Only command steps and approvals are yours to run. Steps in the same stage do not depend on each other: start them together, in one message with several subagent calls.

The input (`goal`) is the user's goal: their request, word for word, handed on under `### goal`. Ask for it if the user has not given one.

### Stage 1 · 1 step

- **SPLIT** (`splitter`) → subagent `rfc-discovery-graph-splitter`
  - Hand it: the user's goal.
  - Expect: `subtask_json` (json).
  - Contract check (`subtask_json`): save its output to `.skill-graph/rfc-discovery-graph/splitter.json`, then run `node -e "const fs=require('fs');const d=JSON.parse(fs.readFileSync(process.argv[1],'utf8'));const k=['feasibility','prior_art','interface_design','failure_modes'];const ok=d!==null&&typeof d==='object'&&Array.isArray(d)===false;const m=ok?k.filter((x)=>Object.hasOwn(d,x)===false):k;if(m.length>0){console.error('Missing keys: '+m.join(', '));process.exit(1)}" .skill-graph/rfc-discovery-graph/splitter.json` with Bash. Exit code 0 passes.
  - If a contract check fails: re-run this step once with its previous answer and the error output. If it fails again, stop and show the user the output.

### Stage 2 · 4 steps in parallel

- **Feasibility Study** (`feasibility`) → subagent `rfc-discovery-graph-feasibility`
  - Hand it: only the `feasibility` value from the JSON of SPLIT (`splitter`).
  - Expect: `research_notes` (markdown).
- **Prior Art** (`prior_art`) → subagent `rfc-discovery-graph-prior-art`
  - Hand it: only the `prior_art` value from the JSON of SPLIT (`splitter`).
  - Expect: `research_notes` (markdown).
- **Interface / DX** (`interface_design`) → subagent `rfc-discovery-graph-interface-design`
  - Hand it: only the `interface_design` value from the JSON of SPLIT (`splitter`).
  - Expect: `research_notes` (markdown).
- **Failure Modes** (`failure_modes`) → subagent `rfc-discovery-graph-failure-modes`
  - Hand it: only the `failure_modes` value from the JSON of SPLIT (`splitter`).
  - Expect: `research_notes` (markdown).


… 37 more lines in the kit

Or let Claude adapt it

Add Skill Graph to Claude Code as a connector, then ask. Claude loads this starter, changes it for your project, checks it and hands you the kit.

Set up the connector

Ask Claude

Use Skill Graph: get the rfc-discovery-graph template, adapt it to this project, validate it until it has no errors, and compile it for Claude Code.

The graph file

The whole workflow is one Markdown file, graph.skill.md: the steps and edges in the frontmatter, one prompt per step below it. The guide explains every field.

graph.skill.md · 158 lines
---
name: rfc-discovery-graph
description: Explores a proposal from four angles in parallel, red-teams unstated assumptions in a fresh context, and drafts an RFC.
spec: skill-graph/1
topology:
  nodes:
    - id: goal
      type: input
      label: PROPOSAL
    - id: splitter
      type: orchestrator
      label: SPLIT
      model: sonnet
      tools:
        - Read
    - id: feasibility
      type: worker
      label: Feasibility Study
      model: haiku
      tools:
        - Read
        - Grep
        - Glob
        - WebSearch
        - WebFetch
    - id: prior_art
      type: worker
      label: Prior Art
      model: haiku
      tools:
        - Read
        - Grep
        - Glob
        - WebSearch
        - WebFetch
    - id: interface_design
      type: worker
      label: Interface / DX
      model: haiku
      tools:
        - Read
        - Grep
        - Glob
        - WebSearch
        - WebFetch
    - id: failure_modes
      type: worker
      label: Failure Modes
      model: haiku
      tools:
        - Read
        - Grep
        - Glob
        - WebSearch
        - WebFetch
    - id: verifier
      type: verifier
      label: VERIFIER (Fresh Context)
      isolated_context: true
      model: opus
      tools:
        - Read
        - Grep
        - Glob
      gate: No kept claim rests on an unstated assumption.
      on_fail: retry
      max_retries: 1
    - id: merger
      type: synthesizer
      label: FINAL ANSWER
      model: sonnet
      tools:
        - Read
  edges:
    - from: goal
      to: splitter
    - from: splitter
      to:
        - feasibility
        - prior_art
        - interface_design
        - failure_modes
      contract: subtask_json
    - from:
        - feasibility
        - prior_art
        - interface_design
        - failure_modes
      to: verifier
      contract: research_notes
    - from: verifier
      to: merger
      contract: verified_notes
contracts:
  subtask_json:
    format: json
    description: One key per worker id; each value is that worker's task.
  research_notes:
    format: markdown
    description: A numbered list; every item has its evidence and a confidence of high, medium or low.
  verified_notes:
    format: markdown
    description: Only the items that passed verification, then the rejected ones with the reason.
---

# Node Prompts & Edge Contracts

## @node: splitter
You are the RFC editor. Turn the proposal into four focused research questions.

Input:
{{goal}}

Output strictly as JSON with one key per worker: `feasibility`, `prior_art`, `interface_design`, `failure_modes`. Each value is the exact task for that worker.

## @node: feasibility
Assess ONLY feasibility: effort, dependencies, migration path and the hardest technical risk.

Your task: {{splitter.feasibility}}

Return findings as a numbered list. For each one give the evidence (file, line, quote or source) and a confidence of high, medium or low.

## @node: prior_art
Survey ONLY prior art: existing tools, competitors and published approaches, with what each gets right and wrong.

Your task: {{splitter.prior_art}}

Return findings as a numbered list. For each one give the evidence (file, line, quote or source) and a confidence of high, medium or low.

## @node: interface_design
Design ONLY the interface: API or CLI shape, configuration, error messages and the first five minutes of use.

Your task: {{splitter.interface_design}}

Return findings as a numbered list. For each one give the evidence (file, line, quote or source) and a confidence of high, medium or low.

## @node: failure_modes
Find ONLY failure modes: what breaks at scale, under bad input, during partial rollout or rollback.

Your task: {{splitter.failure_modes}}

Return findings as a numbered list. For each one give the evidence (file, line, quote or source) and a confidence of high, medium or low.

## @node: verifier
You are a red-team reviewer. List the unstated assumptions behind each claim and reject claims that rest on them.

You only see the raw worker outputs below, not their reasoning. Drop any claim without concrete evidence, merge duplicates, and mark what you rejected and why.

Original input: {{goal}}

Worker outputs:
{{workers.output}}

## @node: merger
Write a production RFC in Markdown: Summary, Motivation, Proposal, Alternatives considered, Risks, Open questions.

{{verifier.output}}

More starter graphs

All blueprints