Evidence Selfloop

Community

WILLOSCAR

evidence-selfloop

Evidence self-loop for surveys: read evidence bindings + evidence packs, then write an actionable upstream TODO plan (which stage/skill to fix) before writing more prose.

Overview

Publisher	WILLOSCAR
Repository	`research-units-pipeline-skills`
Skill name	`evidence-selfloop`
Stars	513
Forks	39
Bundled files	1
Links	Skill source Repository

Markdown instructions
A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.
Works with any LLM
AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.
1 bundled files
Scripts, templates, and references the model can read while it works. Files are read-only and never executed.
Open source
Published by WILLOSCAR on GitHub. Read the source before you install it.

Installation

Install the Evidence Selfloop AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

Open the app and go to Plugins → Skills.
Choose "Install from GitHub".
Paste the skill folder URL below and confirm.
https://github.com/WILLOSCAR/research-units-pipeline-skills/tree/main/.codex/skills/evidence-selfloop
Enable the skill in any chat where you want it available.

Store

Installed

Skills

Add skills

Import one or more skills from a public GitHub folder or a local .skill or .zip archive, or SKILL.md file.

From GitHub URLFrom .skill, .zip, or SKILL.md

GitHub repo or folder

https://github.com/WILLOSCAR/research-units-pipeline-skills/tree/main/.codex/skills/evidence-selfloop

Points to a single skill folder, or any folder that contains multiple skills. Public repos only.

CancelContinue

Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills

git clone --depth 1 https://github.com/WILLOSCAR/research-units-pipeline-skills.git /tmp/research-units-pipeline-skills
mkdir -p .claude/skills
cp -r /tmp/research-units-pipeline-skills/.codex/skills/evidence-selfloop .claude/skills/evidence-selfloop

Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Evidence Selfloop in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Evidence Selfloop on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Evidence Selfloop is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

Loaded only when it is needed
The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.
Switch models mid-chat
Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Evidence Self-loop (C3/C4 fix → rebind → redraft)

Triggers & routing

Trigger: evidence self-loop, evidence loop, evidence gaps, binding gaps, blocking_missing, 证据自循环, 证据缺口回路.

Purpose: make the evidence-first pipeline converge without writing filler prose.

This skill reads the intermediate evidence artifacts (briefs/bindings/packs) and produces an actionable TODO list that answers:

Which subsections are under-supported?
Is the problem mapping/coverage (C2) or evidence extraction (C3) or binding/planning (C4)?
Which skill(s) should be rerun, in what order, to unblock high-quality writing?

Inputs

outline/subsection_briefs.jsonl
outline/evidence_bindings.jsonl (expects binding_gaps / binding_rationale if available)
outline/evidence_drafts.jsonl (expects blocking_missing, comparisons, eval protocol, limitations)
Optional (improves routing):
- outline/evidence_binding_report.md
- outline/anchor_sheet.jsonl
- papers/paper_notes.jsonl
- papers/fulltext_index.jsonl
- queries.md

Outputs

output/EVIDENCE_SELFLOOP_TODO.md (report-class; always written)

Self-loop contract (what “fixing evidence” means)

Prefer fixing upstream evidence, not writing around gaps.
If an evidence pack has blocking_missing, treat it as a STOP signal: strengthen notes/fulltext/mapping, then regenerate packs.
If bindings show binding_gaps, treat it as a ROUTING signal: either enrich the evidence bank for the mapped papers, expand mapping coverage, or adjust required_evidence_fields if unrealistic.

Recommended rerun chain (minimal):

If C3 evidence is thin: pdf-text-extractor → paper-notes → evidence-binder → evidence-draft → anchor-sheet → writer-context-pack
If C2 coverage is weak: section-mapper → outline-refiner → (then rerun C3/C4 evidence skills)

Workflow (analysis-only)

Read queries.md (if present)

Use it only as a soft config hint (evidence_mode / draft_profile); do not override the artifact contract.

Read outline/subsection_briefs.jsonl

For each sub_id, capture axes + required_evidence_fields (what evidence types this subsection expects).

Read outline/evidence_bindings.jsonl

For each sub_id, surface binding_rationale and binding_gaps (what the binder could/could not cover from the evidence bank).

(Optional) Read outline/evidence_binding_report.md

Use it as a human-readable summary; treat it as a view of outline/evidence_bindings.jsonl, not a separate truth source.

Read outline/evidence_drafts.jsonl

Surface blocking_missing (STOP signals), and check for missing comparisons / eval protocol / limitations that would force hollow writing.

(Optional) Read outline/anchor_sheet.jsonl

Check whether each subsection has at least a few citation-backed anchors (numbers / evaluation / limitations).

(Optional) Read papers/paper_notes.jsonl and papers/fulltext_index.jsonl

Use these to route fixes: if evidence is abstract-only and missing eval tokens, prefer enriching notes/fulltext before drafting prose.

What the report contains

Summary counts: subsections with blocking_missing, with binding_gaps, and common failure reasons.
Per-subsection TODO: the smallest upstream fix path (skills + artifacts) to make the subsection writeable.

Status semantics (unblock rules)

This skill is the prewrite router for evidence quality. Treat its Status: line as the unblock contract:

PASS: no blocking_missing and no binding_gaps -> proceed to C5 writing (but still scan non-blocking writability smells: low comparisons/eval/anchors often predict hollow prose).
OK: no blocking_missing, but some binding_gaps -> you may draft, but expect weaker specificity; prefer fixing gaps first.
FAIL: missing inputs OR any blocking_missing -> do not write filler prose; fix upstream and rerun C3/C4.

Routing matrix (symptom -> root cause -> upstream fix)

Use this as a semantic routing table (not a script checklist). The goal is to fix the earliest broken intermediate artifact.

Symptom (where you see it)	Likely root cause	Inspect first	Smallest upstream fix chain
`evidence_drafts.blocking_missing: no usable citation keys`	mapped papers lack `bibkey` / bibkeys not in `citations/ref.bib`	`papers/paper_notes.jsonl` (bibkey fields), `citations/ref.bib`	C3 `paper-notes` (ensure bibkeys) -> C4 `citation-verifier` -> rerun `evidence-binder` -> rerun `evidence-draft`
`blocking_missing: title-only evidence`	retrieval/metadata lacks abstracts (or aggressive filtering)	`papers/papers_raw.jsonl` abstracts, `papers/paper_notes.jsonl` evidence_level	C1 `literature-engineer` (enrich metadata) OR C3 `pdf-text-extractor` (fulltext) -> rerun `paper-notes`
`blocking_missing: no evidence snippets extractable`	notes are too thin / evidence bank empty for mapped papers	`papers/evidence_bank.jsonl` (counts), `papers/paper_notes.jsonl`	C3 `paper-notes` (richer extraction; prefer fulltext when possible) -> rerun C4 packs
`blocking_missing: no concrete evaluation tokens`	notes/bank did not extract benchmarks/metrics/budgets	`papers/paper_notes.jsonl` (metrics/benchmarks fields), `outline/anchor_sheet.jsonl`	C3 `paper-notes` (extract eval anchors) -> rerun `anchor-sheet` + `evidence-draft`
`evidence pack comparisons` are sparse (signals: comparisons low)	clusters are not contrastable OR mapping coverage too weak	`outline/subsection_briefs.jsonl` (clusters), `outline/mapping.tsv`	C2 `section-mapper` (coverage) OR C3 `subsection-briefs` (better clusters) -> rerun `evidence-draft`
`bindings.binding_gaps` mentions benchmarks/metrics/protocol	binder cannot find evaluation-tagged evidence for this subsection	`outline/evidence_binding_report.md` (tag mix), `papers/evidence_bank.jsonl` tags	C3 `paper-notes` (tag/evidence extraction) OR C2 expand mapping for that subsection -> rerun `evidence-binder`
`binding_gaps` mentions security/threat model/attacks	mapped set lacks security-focused works or notes lack threat-model detail	`outline/mapping.tsv`, `papers/paper_notes.jsonl`	C2 expand mapping (+ C1 queries if needed) OR C3 enrich notes -> rerun binder/packs
`binding report` looks mechanically uniform across H3 (same mix, low tag variance)	binder selection too recipe-like OR evidence bank tags too coarse	`outline/evidence_binding_report.md` (tag mix), evidence bank tags	tighten `required_evidence_fields` + improve evidence bank tags, then rerun binder; avoid writing around non-specific bindings

Interface with the writer self-loop (avoid writing around evidence)

If writer-selfloop is FAIL due to missing anchors/comparisons and the corresponding writer pack has pack_warnings, stop and run this evidence self-loop: the section is telling you the pack is not writeable.
Prefer fixing evidence gaps once, upstream, rather than patching every H3 with generic filler.

What this skill does NOT do

It does not edit papers/*, outline/*, or sections/*.
It does not invent new facts/citations.
It does not "relax" quality by changing thresholds; it routes you to the earliest artifact to fix.

Script

Quick Start

uv run python .codex/skills/evidence-selfloop/scripts/run.py --workspace <workspace>

All Options

--workspace <dir>
--unit-id <U###> (optional)
--inputs <semicolon-separated> (optional override)
--outputs <semicolon-separated> (optional override; default writes output/EVIDENCE_SELFLOOP_TODO.md)
--checkpoint <C#> (optional)

Examples

Generate an evidence TODO list after C4 packs are generated:
- uv run python .codex/skills/evidence-selfloop/scripts/run.py --workspace <workspace>

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

scripts/run.py14 KB

Frequently asked questions

What does the Evidence Selfloop AI skill do?

Evidence self-loop for surveys: read evidence bindings + evidence packs, then write an actionable upstream TODO plan (which stage/skill to fix) before writing more prose.

Why use Evidence Selfloop on TypingMind?

Because you install it once and use it with any model. Evidence Selfloop is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Evidence Selfloop in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/WILLOSCAR/research-units-pipeline-skills/tree/main/.codex/skills/evidence-selfloop. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Evidence Selfloop?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Evidence Selfloop?

As many as you like. As long as a model supports skills, you can use Evidence Selfloop with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Evidence Selfloop AI skill free?

It is published on GitHub by WILLOSCAR. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Brainstorming

obra

CommunityPopular

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Executing Plans

Use when you have a written implementation plan to execute in a separate session with review checkpoints

Using Superpowers

Use when starting any conversation - establishes how to find and use skills, requiring skill invocation before ANY response including clarifying questions

Context And Decisions

affaan-m

CommunityPopular

Govern stable domain context with a narrowly scoped CONTEXT.md when needed, and route hard-to-reverse decisions to ECC's existing architecture-decision-records skill. Use when domain terms require…

Overview

Installation

Install in TypingMind

Install in another agent

Use it in TypingMind

Works with any AI model

Skill instructions

Evidence Self-loop (C3/C4 fix → rebind → redraft)

Triggers & routing

Inputs

Outputs

Self-loop contract (what “fixing evidence” means)

Workflow (analysis-only)

What the report contains

Status semantics (unblock rules)

Routing matrix (symptom -> root cause -> upstream fix)

Interface with the writer self-loop (avoid writing around evidence)

What this skill does NOT do

Script

Quick Start

All Options

Examples

Bundled files

Frequently asked questions

Related AI Skills

Set up your own AI workspace now