New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Outcome

by jongwony in jongwony/epistemic-protocols

This skill should be used when the user asks to "run the outcome eval", "paired bare vs protocol", "which decisions did the protocol surface", "count what the AI asked or presented", "does /inquire…

MITAuto-check: notes

Install Outcome

skills CLI
$ npx skills add jongwony/epistemic-protocols --skill outcome -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jongwony/epistemic-protocols outcome --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jongwony/epistemic-protocols.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/outcome .claude/skills/outcome && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
outcome
GitHub stars
173
Token cost
~1.3k tokens
SKILL.md length
635 words
Files
7 (incl. scripts, references)
Skills in repo
29
Repo updated
First seen
Licence
MIT

At a glance

This skill should be used when the user asks to "run the outcome eval", "paired bare vs protocol", "which decisions did the protocol surface", "count what the AI asked or presented", "does /inquire…

  • Asks to run the outcome eval
  • SKILL.md covers The one measure, What this eval measures, and…, Boundary with /realize and Design, plus 2 more sections
  • Runs JavaScript and Shell scripts from its folder; calls node
  • Paired bare vs protocol

What it does

Outcome is an agent skill from jongwony/epistemic-protocols. This skill should be used when the user asks to "run the outcome eval", "paired bare vs protocol", "which decisions did the protocol surface", "count what the AI asked or presented", "does /inquire surface what the request left out", or wants to see, from transcripts, which decisions reached the user as a question or something to recognize instead of having to be written into the opening prompt. Project-local contributor tooling.

Its SKILL.md is about 1.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 10 other files, including scripts and reference files (for example `cases/inquire-rate-limiter/case.json`, `references/runbook.md` and `scripts/turn-claude.sh`).

The repository describes itself as: Epistemic protocols for Claude Code — structure human-AI interaction quality at every decision point - https://epistemic-protocols.com. The licence is MIT.

When your agent uses it

  • Asks to run the outcome eval
  • Paired bare vs protocol
  • Which decisions did the protocol surface
  • Count what the AI asked

Example prompts

  • “run the outcome eval”
  • “paired bare vs protocol”
  • “which decisions did the protocol surface”
  • “/outcome”

Requirements

  • Node.js
  • A Bash shell
  • Pre-approved tools (allowed-tools): Read, Grep, Glob, Bash, Write

What it can do on your machine

Read from SKILL.md and the folder at commit 6649d84. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Grep
    • Glob
    • Bash
    • Write

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 4 files in scripts/ (JavaScript and Shell), which the agent can run.

    Shell commands in SKILL.md call:

    • node

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Outcome loads about 1.3k tokens when it runs, and up to ~3.5k if it reads all its reference files. Until then it costs about 110 tokens; SKILL.md has 635 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~110
When it runs · the whole SKILL.md, loaded when a task matches
~1.3k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~3.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Grep, Glob, Bash, Write

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from jongwony/epistemic-protocols at commit 6649d84, republished under its MIT licence (© jongwony). 635 words, ~1,270 tokens.

Download SKILL.mdSave it as .claude/skills/outcome/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
outcome
description
This skill should be used when the user asks to "run the outcome eval", "paired bare vs protocol", "which decisions did the protocol surface", "count what the AI asked or presented", "does /inquire surface what the request left out", or wants to see, from transcripts, which decisions reached the user as a question or something to recognize instead of having to be written into the opening prompt. Project-local contributor tooling.
allowed-tools
Read, Grep, Glob, Bash, Write

Outcome Eval

Without a protocol, a person has to recall at length and write a long opening prompt. With one, they answer when asked, by recalling, or recognize what is put in front of them — and the items that come up this way can be ones nobody would have thought of at the start. This eval shows that one thing, from the transcript: the same request runs with and without the protocol, and each cell lists the decisions that reached the user through the AI.

The one measure

Per cell: the decision items that entered the conversation through the AI and that the user's opening request did not contain. Each is recorded with the verbatim span that raised it and how it reached the user:

  • asked — put as a question; the user answered by recalling.
  • presented — shown as an option or default; the user recognized, picked or corrected it.

The number is the count of such items, per cell and per arm, shown under the opening request whose gaps they fill: each item is something the user would otherwise have had to write into that request. It is read from the transcript and the opening request alone — no hidden specification, no checklist, no grader of correctness. Identifying an item is a reading of the transcript, attributed to whoever wrote the cell's notes, not a mechanical extraction; the spans stay with it so anyone can check the reading.

What this eval measures, and what it does not

It shows how many decisions reached the user as a question or as something to recognize, rather than having to be written up front, and how many of them reached the user before any code existed — the only ones an answer could shape before the implementation. It does not show whether an answer then changed the code, whether the answers were right, whether a person felt less load, or anything about rework.

A result is an observation of one model on one day, and it changes as models change. A write-up quotes every reportable cell of the runs it draws on, including cells where the arms did not differ and cells where the bare arm raised more; picking cells turns an observation into a showcase. It goes into the pull request body or the commit message it informs, never onto a state surface — a README, an AGENTS.md, this file — where nothing re-runs it. A surface may say that this eval exists and what it counts; it does not say what it found. Records (results/) are gitignored for the same reason.

Show full SKILL.md (209 more words)Show less

Boundary with /realize

/realize judges whether a run follows a protocol's declared transitions. This skill reuses its cases — scaffold, prompts, oracles, invocation lines and isolation — by path, and changes none of them; a question about whether a gate fired belongs there.

Design

  • Arms. bare and protocol. The protocol arm gets the plugin and /realize's invocation line, nothing else. A rule added to that arm alone would credit the protocol with what the harness added.
  • Dialogue. The user side is played mechanically by the variant's oracle.md, up to the first turn that writes an implementation; a turn that neither implements nor hands anything back gets the case's go line once. The notes then close the cell.
  • Frozen case. case.json holds the sha256 of every reused /realize file and invocation line; every command that spends refuses when one has changed, since items read against a different request or oracle are a different case.

Runbook

bash
S=.claude/skills/outcome/scripts/outcome.mjs
node $S plan --runner claude --model <model> --reps 2 --dry-run   # argument check only
node $S plan --runner claude --model <model> --reps 2
node $S plan --runner codex --model gpt-6-luna --effort xhigh --codex-auth login   # or api-key (default)
node $S setup <run>                            # codex: bare and protocol homes
node $S turn <run> <cell> --open               # then --reply <file> | --go, as the oracle says
node $S note <run> <cell>                      # closes the cell; fill the items, then run again
node $S report <run> [<run> ...] [--out <dir>]
node $S teardown <run>                         # work trees and homes; records stay

Read references/runbook.md before the first run: the turn procedure, how to write the notes' items, authentication and isolation per runner, and why a Codex protocol cell writes code before any answer can arrive.

Prerequisites and tests

Node 22+ and the runner's CLI (claude or codex) on PATH. The pure parts have a test that calls no model:

bash
node --test .claude/skills/outcome/scripts/lib.test.mjs

© jongwony, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files (scripts, references) in .claude/skills/outcome of jongwony/epistemic-protocols.

  • SKILL.md
  • cases/inquire-rate-limiter/case.json
  • references/runbook.md
  • scripts/lib.mjs
  • scripts/lib.test.mjs
  • scripts/outcome.mjs
  • scripts/turn-claude.sh

Open the folder on GitHubat commit 6649d84

Compare with similar skills

Outcome next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Outcome compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Outcome this skilljongwony/epistemic-protocols173—~1.3kAutomated safety check: NotesMIT
Outcome Roadmapphuryn/pm-skills27k—~900Automated safety check: PassMIT
Outcome Trackermohitagw15856/pm-claude-skills1.4k—~1.6kAutomated safety check: PassMIT
Outcome Roadmapborghei/Claude-Skills886—~1.4kAutomated safety check: PassMIT
Principle Outcome Oriented Executioncursor/plugins10k8 repos~270Automated safety check: PassNone
Outcome Extraction For Clinical Trialsaipoch/medical-research-skills2k—~1.4kAutomated safety check: PassMIT

Similar skills

  • Outcome Roadmap

    phuryn/pm-skills

    Transform an output-focused roadmap into an outcome-focused one that communicates strategic intent.

    27k GitHub stars~900 tokensUpdated 24 days ago
    Auto-check passed

  • Outcome Tracker

    mohitagw15856/pm-claude-skills

    Record the testable predictions inside a decision, then score them against reality later — so frameworks earn trust from outcomes, not vibes.

    1.4k GitHub stars~1.6k tokensUpdated yesterday
    Product & Project ManagementAuto-check passed

  • Outcome Roadmap

    borghei/Claude-Skills

    Transform output-based feature lists into outcome-driven Now/Next/Later roadmaps using the "so what?" technique.

    886 GitHub stars~1.4k tokensUpdated 2 days ago
    Product & Project ManagementAuto-check passed

  • Principle Outcome Oriented Execution

    cursor/plugins

    Official

    Apply during planned rewrites and migrations with explicit phase boundaries.

    10k GitHub starsUsed in 8 repos~270 tokens
    Auto-check passed

  • Outcome Extraction For Clinical Trials

    aipoch/medical-research-skills

    Clinical research outcome extraction for meta-analysis. An agent skill from aipoch/medical-research-skills.

    2k GitHub stars~1.4k tokensUpdated 22 days ago
    Research & ScienceAuto-check passed

  • Ln 72 Product Outcome Evaluator

    levnikolaevich/claude-code-skills

    Evaluates observed product outcomes against a prior hypothesis; does not run experiments or change user treatment.

    572 GitHub stars~1.9k tokensUpdated 4 days ago
    Auto-check passed

More from jongwony/epistemic-protocols

All 29 skills in this repo

  • Realize

    jongwony/epistemic-protocols

    This skill should be used when the user asks to "run the eval", "test whether the protocol actually works at runtime", "check type realization", "measure protocol fulfillment", "run the…

    173 GitHub stars~3.3k tokensUpdated today
    Auto-check: notes

  • Verify

    jongwony/epistemic-protocols

    This skill should be used when the user asks to "verify protocols", "check consistency before commit", "validate definitions", "run pre-commit checks", "verify soundness", or wants to ensure…

    173 GitHub stars~1.4k tokensUpdated today
    Auto-check passed

  • Encapsulation

    jongwony/epistemic-protocols

    This skill should be used when the user asks to "audit plugin encapsulation", "check self-containment semantics", "find contributor-knowledge assumptions", or invokes /encapsulation.

    173 GitHub stars~2k tokensUpdated today
    Auto-check passed

  • Formal Review

    jongwony/epistemic-protocols

    This skill should be used when the user asks to "formal review", "formal lens review", or invokes /formal-review.

    173 GitHub stars~3.5k tokensUpdated today
    Auto-check: notes

  • Recollect

    jongwony/epistemic-protocols

    The user vaguely recalls something discussed before but cannot name it — one session, or a line of work, topic, or settled concept across several: find it in past records to recognize.

    173 GitHub stars~8.7k tokensUpdated today
    Auto-check passed

  • White Bear

    jongwony/epistemic-protocols

    A skill your agent uses when the user asks to "check white bear", "audit prohibitions", "find negative framing", or invokes /white-bear.

    173 GitHub stars~2.5k tokensUpdated today
    Auto-check passed

Questions about Outcome

What does Outcome do?

This skill should be used when the user asks to "run the outcome eval", "paired bare vs protocol", "which decisions did the protocol surface", "count what the AI asked or presented", "does /inquire…. Outcome is an agent skill from jongwony/epistemic-protocols. This skill should be used when the user asks to "run the outcome eval", "paired bare vs protocol", "which decisions did the protocol surface", "count what the AI asked or presented", "does /inquire surface what the request left out", or wants to see, from transcripts, which decisions reached the user as a question or something to recognize instead of having to be written into the opening prompt.

When should I use Outcome?

Outcome fits situations like: asks to run the outcome eval; paired bare vs protocol; which decisions did the protocol surface; count what the AI asked.

How do I install Outcome in Claude Code?

Run `npx skills add jongwony/epistemic-protocols --skill outcome -a claude-code`. Or copy the skill folder (.claude/skills/outcome in jongwony/epistemic-protocols) into .claude/skills/outcome in your project. Claude Code loads it when a task matches its description.

How do I install Outcome in Codex?

Run `npx skills add jongwony/epistemic-protocols --skill outcome -a codex`. Or copy the skill folder (.claude/skills/outcome in jongwony/epistemic-protocols) into .agents/skills/outcome in your project. Codex loads it when a task matches its description.

Can I use Outcome in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jongwony/epistemic-protocols --skill outcome -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/outcome, .gemini/skills/outcome, .github/skills/outcome and .opencode/skills/outcome in your project.

What does Outcome need to run?

Going by SKILL.md and its folder, Outcome needs JavaScript and a shell for the scripts in its folder and the command-line tools its instructions call (node). Our summary lists: Node.js; A Bash shell. Its frontmatter pre-approves these tools: Read, Grep, Glob, Bash, Write.

Does Outcome access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Outcome safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Outcome use?

Outcome is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Outcome use?

About 1.3k tokens (SKILL.md is roughly 5.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.2k tokens, read only when the agent opens those files.

What are the alternatives to Outcome?

Skills that share tags, products or a category with Outcome: Outcome Roadmap (phuryn/pm-skills, 27k stars), Outcome Tracker (mohitagw15856/pm-claude-skills, 1.4k stars), Outcome Roadmap (borghei/Claude-Skills, 886 stars) and Principle Outcome Oriented Execution (cursor/plugins, 10k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Outcome?

jongwony (a GitHub user) maintains it in jongwony/epistemic-protocols, which has 173 GitHub stars. The repository holds 29 skills in this directory. The repository was last updated on October 9, 2026.

Source: jongwony/epistemic-protocols on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.