SKILL 20 / RESEARCH · DEEP-DIVE

Writing Your Research Process as a Workflow Skill

Anyone can copy the six-line checklist — but citation verification is the only step a machine can run for you

2026-09-21 · BigCat

Last issue was about picking a ready-made research skill. This one is about writing the process yourself. The leads: two validation scripts that actually run, and a six-line checklist buried in the official best-practices page that almost nobody notices.

Prerequisite → Skill 19 Research Skills Roundup (where all three implementations here come from)

// WHY THIS MATTERS

One of last issue's six tests was "is there a check a machine can run?" This issue follows that thread. Citation verification is the only step in a research process whose correctness can be settled automatically — whether a link opens, whether a DOI exists, whether an in-text number has a matching bibliography entry. None of that requires reading the content. Pin it to the end of a checklist, make failure jump back, and you have a workflow skill. The official best-practices page splits these two ideas across "Use workflows for complex tasks" and "Implement feedback loops"; 199-biotechnologies/claude-deep-research-skill turned them into two Python scripts that actually run. This issue bolts the two together.

// 01

What it kills for you: skipped steps you cannot see afterwards

Claim: the most expensive error in a research report is not a wrong sentence. It is "it skipped the verification step and you could not tell." A checklist makes skipping visible; a validation script makes skipping throw an error.

The official six lines can be copied wholesale

In Skill authoring best practices, under "Use workflows for complex tasks," the first example happens to be research — and it is from the "skills without code" family:

# Verbatim from the docs: Research synthesis workflow
Research Progress:
- [ ] Step 1: Read all source documents
- [ ] Step 2: Identify key themes
- [ ] Step 3: Cross-reference claims
- [ ] Step 4: Create structured summary
- [ ] Step 5: Verify citations

The five lines are not the point. The sentence after them is: If citations are incomplete, return to Step 3. — the last step has to jump back on failure, or the checklist is typography, not a loop. The docs' own verdict on this pattern: Clear steps prevent Claude from skipping critical validation.

Then install the two scripts

# The lead: the one implementation here that makes "validate -> fix -> rerun" a real script
git clone https://github.com/199-biotechnologies/claude-deep-research-skill.git ~/.claude/skills/deep-research
pip install -r ~/.claude/skills/deep-research/requirements.txt

# First thing that runs: you don't need it to write a report — point it at any markdown you already have
python ~/.claude/skills/deep-research/scripts/verify_citations.py --report report.md --strict
python ~/.claude/skills/deep-research/scripts/validate_report.py --report report.md

This is the one command to run first. verify_citations.py needs no API key (it uses the free doi.org resolver); exit code 0 passes, 1 fails. Feed it that AI-written market scan you produced last week and you will most likely see a few dead links immediately.

What it actually checks (per scripts/verify_citations.py on the repo's main branch, 2026-09): whether each DOI resolves at doi.org and returns metadata; whether the title/year in your report matches that metadata above 50% similarity, flagging mismatches; whether URLs return HTTP 200 to a HEAD request; plus a set of hallucination heuristics — generic academic title templates like "A Study of…", tbd/todo placeholders, pre-2000 papers that mention AI or GPT, future-dated years, and recent works carrying neither a DOI nor a URL. Under --strict, any suspicious or unverified entry fails the run.

The other half is structure. validate_report.py runs 9 checks: executive summary present and between 50 and 400 words, 8 required sections present, in-text citations matched to bibliography entries, entry numbering consecutive with no gaps, no TBD/TODO, no signs of truncated generation, total length above 500 words, at least 10 unique sources, and internal markdown links resolving.

Source · 199-biotechnologies/claude-deep-research-skill (per the GitHub repo page, 2026-09: 1.1k stars, MIT, v2.3.1)
// 02

Mechanism: the checklist prevents skipping, the script makes it fail loudly

Claim: this works because it replaces the vaguest sentence in research — "I checked" — with a fact that carries an exit code.
question -> method -> sources -> evidence -> synthesis -> caveats | ^ +--- citation registry --+ <- machine-checkable intermediate | verify_citations.py -> exit 1 jumps back; nothing proceeds

Three parts, each named in the docs

  1. Workflow / checklist. Break a complex task into ordered steps and have the model copy the checklist into its response, ticking items off. This treats skipping.
  2. Feedback loop. The docs phrase it as Run validator → fix errors → repeat, with the instruction Only proceed when validation passes. This treats "ran the check, ignored the result."
  3. Plan-validate-execute. Produce a machine-checkable intermediate artifact, validate it, then execute. The docs frame this for batch and destructive operations — research is the same family: once a report is drafted, the error gets copied dozens of times.

In research, that intermediate artifact is the citation registry

The deep-research skill in daymade/claude-code-skills puts it at P3: merge sources by evidence family, number them [n] by first appearance, tag each with a type (official / academic / secondary-industry / journalism / community) and an accessibility label, and record dropped sources with the reason they were dropped — those sources may not reappear when drafting at P5. Two more rules in the same SKILL.md are worth lifting on their own: set AS_OF explicitly at P0, attach a publication date to every time-sensitive claim and downgrade confidence as it ages; and one hard prohibition, written verbatim — Lead agent never invents URLs; every locator must come from an actual retrieval.

Why verification should be a different role

Anthropic's Research system exits the research loop and hands all gathered material plus the report to a separate CitationAgent, which identifies where each citation belongs (per Anthropic's engineering post "How we built our multi-agent research system," 2025-06). The logic is plain: an agent that both writes and verifies is verifying its own recollection; a separate role holds nothing but the sources and the draft.

The most common half-built version: a checklist with no jump-back at the end. The model will dutifully tick all five boxes, including "Step 5: Verify citations" — ticking a box is not checking. A validation step with no exit code is the same as no validation step.
// 03

Real usage and limits: three ways in, one hard line

Claim: you do not have to build this from scratch. Three existing implementations each solve one stretch, and assembling beats authoring — but not one of them can tell you whether a sentence is actually what that source said.

By increasing effort

Wiring verification to something real

54yyyu/zotero-mcp (per the GitHub repo page, 2026-09: 5.1k stars, MIT): uv tool install zotero-mcp-server, then zotero-mcp setup. It upgrades verification from "the link opens" to "this one is in my library and I have read it": add papers by DOI, URL, ISBN or BibTeX, read full text and specific PDF page ranges, pull BibTeX directly, and optionally install the scite extra for citation tallies and retraction alerts — retraction is the cell that pure web checking cannot fill. When not to install it: you do not use Zotero, or your sources are web pages rather than literature, in which case it is just tool-slot cost.

Where the originals come from: openags/paper-search-mcp (twenty-odd academic sources, most needing no key) and blazickjp/arxiv-mcp-server (papers land on disk, read the original section by section, emit BibTeX) were covered last issue. One line to add here: a validation script can only tell you the DOI exists. To judge whether a sentence is what that paper said, you have to fetch the paper.

How to accept what you assembled

skill-creator in anthropics/skills (/plugin marketplace add anthropics/skills) supplies a ready procedure: test cases live in evals/evals.json; every case spawns two subagents in the same turn — one with the skill, one without as baseline; results are graded per assertion by agents/grader.md, aggregated by python -m scripts.aggregate_benchmark into pass_rate, time and token figures with mean and standard deviation, and finally served by eval-viewer/generate_review.py as a page you review by hand. It also carries a line worth taping to a wall: do not force assertions onto subjective outputs. Research sits exactly half and half — write citation verification as assertions, and leave the quality of the conclusions to a human.

The hard line of this section: citation verification is not fact verification. verify_citations.py can confirm that a DOI exists and a URL returns 200. It does not check whether the sentence is what that source said. A real link attached to a claim it does not support is the highest-frequency false positive in this category, and it passes every automated check. Which is why Step 3 in the checklist — cross-reference claims — can be neither skipped nor automated.
// 04

Costs and alternatives: three bills, and three cheaper roads

Claim: this costs you false positives, latency, and money. The first two have fixes; the third you can only decline to pay.

One: false positives

Hallucination detection is heuristic. It treats title templates like "A Study of…" and "Recent Advances in…" as suspicious signals — and real papers are named exactly that. Under --strict those fail the run outright, so you spend time "fixing" a citation that was fine. Run it once without --strict, read the list, judge it yourself, and only then decide whether it belongs in the pipeline.

Two: latency

Every citation means a network request: DOI content negotiation against doi.org, a HEAD request per URL, a 10-second timeout, and a 0.5-second rate limit between entries. Fifty citations is minutes. Keep it out of every conversation turn; run it once before you ship.

Three: cost

Process-layer skills are usually orchestrator-plus-subagents. Per Anthropic's engineering post "How we built our multi-agent research system," 2025-06: an Opus 4 lead with Sonnet 4 subagents outperformed a single Opus 4 by 90.2% on their internal research eval, at the cost of roughly 15x the tokens of an ordinary chat, and the post states plainly that the structure does not suit tightly coupled tasks. Price a deep research report like a compile, not like a question.

If you do not write this skill, what else

  1. Paste the six lines into the prompt. Enough for a one-off investigation; do not create a directory for a single task.
  2. Keep the validation script as a standalone CLI tool. It depends on no skill. Run it by hand before shipping and you have collected eighty percent of the benefit.
  3. Write one minimal rule into CLAUDE.md: any number you will act on must carry a source and that source page's own date. It needs no tooling and stops most accidents.

// ONE-PAGE PICK LIST

Do these three first: (1) Copy the five-line Research synthesis workflow checklist from "Use workflows for complex tasks" in the official best-practices page, together with the return to Step 3 jump-back. (2) git clone https://github.com/199-biotechnologies/claude-deep-research-skill.git ~/.claude/skills/deep-research, use only scripts/verify_citations.py at first, and point it at a report you have already finished. (3) Lift the P3 citation registry section from deep-research in daymade/claude-code-skills, including "record dropped sources with reasons" and the AS_OF date rule.

Add as needed: Weizhena/Deep-Research-skills (you want a human gate at the outline) · 54yyyu/zotero-mcp (verification should hit your own library; you want retraction alerts) · openags/paper-search-mcp and blazickjp/arxiv-mcp-server (you need the originals back to check against) · skill-creator in anthropics/skills (you want a baseline comparison before accepting the workflow).

Explicitly do not: wire --strict straight into a pipeline without a human pass · put verify_citations.py in every conversation turn · create a skill directory for a one-off investigation · assume that passing citation verification means the facts were checked.

// GLOSSARY

workflow / checklist pattern
The official best-practices approach: write a multi-step task as a tickable checklist the model copies into its response. The docs say plainly that it prevents skipping critical validation.
feedback loop
Run validator, fix, rerun, and proceed only once it passes. In a research process, that validator is citation verification.
plan-validate-execute
Produce a machine-checkable intermediate plan, validate it, then execute. Here the intermediate artifact is the citation registry.
citation registry
A source ledger kept separately from the prose: deduplicated and numbered, tagged by type, recording dropped sources and why. Once frozen, the prose may cite only from it.
AS_OF
An "as of" date fixed explicitly at the start of the process. Every time-sensitive claim carries a source date, and anything past its freshness window gets a confidence downgrade.
CitationAgent
The separate agent in Anthropic's Research system responsible for placing citations: after the research loop ends, it reads the raw material and the draft and identifies where each citation belongs.
baseline eval
Running the same prompt once with the skill and once without, then comparing. Skip this and you cannot tell whether the skill helped or the model could already do it.

// FURTHER READING