On November 5, 2026 the Economics team at the Anthropic Institute published a technical report titled “AI for scientific discovery: How researchers use Claude”, with Johannes Hermle, Ben Jones and Lukas Althoff as lead authors among nine. The report uses LLM classifiers to label 207,049 consumer-plan sessions between August 2 and September 30, 2026 by field and task, adds a survey of 528 scientists and a “theoretical AI capability” score, and ends with three acceleration scenarios. As of our check on November 8, 2026, it is Anthropic’s most complete public dataset on scientific use of its products.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

A word on position first: this is research a vendor ran on its own product’s usage data, and its conclusions stop at the boundary of sessions on Anthropic consumer plans that a classifier recognized as science. The first half of this article checks the numbers and marks where over-reading is easy. The second half takes the gap the report exposes, between what researchers use Claude for most and what they rate as most important, and turns it into a workflow a researcher can copy: which surface for which task, what evidence every session must leave behind, and how to accept results with scripts rather than memory. Every script runs offline; we made no API calls.

1. What this is: a technical report on the vendor’s own usage data

The main sample is 207,049 sessions on consumer plans from 2026-08-02 to 2026-09-30: 128,914 on Claude (the report groups Chat and Cowork under that name) and 78,135 on Claude Code. A supplemental Claude Science sample is also studied, but the text gives neither its size nor its date range. Each session first passes a classifier that decides whether it involves scientific work; a second classifier then assigns field, subfield and task from the SciNet taxonomy, which has 7,262 tasks, 34 fields and 318 subfields.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

The privacy design determines what the data can support. The report states that labels such as “chemistry” or “data cleaning” are the only information retained from conversations, that no classifier extracts or stores open-ended research content, and that results are reported only in aggregate and only for cells meeting a minimum number of distinct accounts. The authors therefore cannot inspect the scientific quality of any individual session. Every figure for “doctoral-level content”, “high AI autonomy” or “hours a human would need” is a model estimate, not a human review.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

The survey covers 528 scientists, mostly in life and health sciences, recruited from applicants to Anthropic’s AI for Science and related grant programs and affiliated with US or Canadian institutions. The authors acknowledge that people who applied for AI research credits are likely more intensive AI users than the typical scientist. Researcher time shares come from a separate SciNet LLM classifier, validated against wet-lab protocols and paper frequencies.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

Taken together, the report can answer: on Anthropic’s consumer products, what do sessions recognized as research do, which fields do they come from, and how does that relate to a capability score? It cannot answer how scientists worldwide use AI, and it says nothing about other vendors’ products. Because the text says consumer plans only, we infer that Team, Enterprise and direct API use are outside the sample; that is our inference, since the report does not itemize exclusions. For every percentage below, keep the denominator in mind: research sessions on Anthropic consumer products.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

2. Task shares versus time shares: many sessions is not many researcher hours

The most informative table in the report sets each task category’s share of sessions on Claude and Claude Code beside the share of researcher time spent on it. The figures below are copied from the text. Researcher time shares are printed for only four categories; the other four have no itemized figure in the text and are shown as “—” rather than estimated by us.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

Session shares by task category against researcher time shares (source: Anthropic report of 2026-11-05, checked 2026-11-08).
Task categoryClaude sessionsClaude Code sessionsResearcher time
Data analysis33.7%48.1%27.6%
Writing and communication32.0%17.6%16.0%
Data gathering11.5%11.9%28.6%
Reading and knowledge acquisition7.6%3.7%—
Theoretical analysis5.0%4.7%—
Design and development4.7%7.7%—
Ideation and hypothesis generation4.2%2.1%7.1%
Other1.3%4.2%—

At the level of individual tasks, drafting manuscripts is the most common on both products: 18.6% on Claude and 11.1% on Claude Code. On Claude it is followed by reviewing and synthesizing literature (6.8%) and responding to peer reviewer comments (6.7%); on Claude Code by designing, building and refining research artifacts (4.8%) and visualizing data and results (4.6%). As for outputs, 52% of Claude sessions produce written artifacts and 21% technical ones; technical artifacts are about twice as common on Claude Code; biology is the only field where technical artifacts outnumber written ones.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

Two traps in reading this table. First, session shares sum to 100%, so a category that is “high” forces another to be “low”: the table describes a relative distribution, not absolute workload. Second, data gathering takes 28.6% of researcher time but only 11.5% to 11.9% of sessions. That may mean the model is little help there, or it may mean that data gathering happens at the bench, the instrument and in the field, where no chat window is open. The report itself warns that ideation tends to be woven into other tasks and may be undercounted.

3. Recompute the use ratio in thirty lines of Python

The report measures relative intensity with a “use ratio”: a task’s share of use divided by its share of researcher time, where 1 means proportional. By capability quintile, the lowest quintile sits at about 0.2 on both products, the middle at about 1, and the top quintile at about 2.1 on Claude and 3.9 on Claude Code. The report does not print the ratio per task category, so we compute it from the published shares. The script below needs only the Python 3 standard library; save it as use_ratio.py and run python3 use_ratio.py.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

use_ratio.py: recompute the use ratio for the four categories with a published time share; the rest are marked n/a on purpose.
# Recompute the use ratio (share of sessions / share of researcher time)
# from the task shares printed in Anthropic's 2026-11-05 report (Figure 2 / text).
SHARES = {
    # task: (Claude sessions %, Claude Code sessions %, researcher time % or None)
    "data analysis": (33.7, 48.1, 27.6),
    "writing & communication": (32.0, 17.6, 16.0),
    "data gathering": (11.5, 11.9, 28.6),
    "reading & knowledge acquisition": (7.6, 3.7, None),
    "theoretical analysis": (5.0, 4.7, None),
    "design & development": (4.7, 7.7, None),
    "ideation & hypothesis generation": (4.2, 2.1, 7.1),
    "other": (1.3, 4.2, None),
}

def ratio(use, time):
    return None if time is None else use / time

def flag(r):
    if r is None:
        return "no time share printed"
    return "over-used (>1)" if r > 1 else "under-used (<1)"

def fmt(r):
    return "   n/a" if r is None else f"{r:6.2f}"

print(f"{'task':34} {'Claude':>8} {'Code':>8}  reading")
for task, (c, cc, t) in SHARES.items():
    rc, rcc = ratio(c, t), ratio(cc, t)
    print(f"{task:34} {fmt(rc):>8} {fmt(rcc):>8}  {flag(rc)} / {flag(rcc)}")

tot_c = sum(v[0] for v in SHARES.values())
tot_cc = sum(v[1] for v in SHARES.values())
tot_t = sum(v[2] for v in SHARES.values() if v[2] is not None)
print(f"\nsession shares sum to {tot_c:.1f}% (Claude) / {tot_cc:.1f}% (Claude Code)")
print(f"printed researcher time shares sum to {tot_t:.1f}%; the rest is not broken out in the text")

Output: writing and communication 2.00 (Claude) / 1.10 (Claude Code), data analysis 1.22 / 1.74, data gathering 0.40 / 0.42, ideation and hypothesis generation 0.59 / 0.30. The script also prints two sanity checks: session shares on each product sum to 100.0%, while the four printed time shares sum to only 79.3%. The remaining 20.7% is spread over reading, theory, design and other, which the text does not break out, so no ratio can be computed for them. Do not fill that gap with a plausible-looking number.

Interpret with restraint. A writing ratio of 2.00 on Claude reflects, first of all, that a chat interface is made for text; it is not direct evidence that the model is best at writing. Data analysis at 1.74 on Claude Code versus 1.22 on Claude matches the tooling: a surface that executes code naturally receives more analysis. What deserves attention is the category below 0.6 on both products, ideation. The next sections show that it is exactly the step researchers rate highest in the survey.

4. Fields and the capability–use link: a correlation is not a cause

By field, the largest shares of Claude sessions are computer science 11.9%, engineering 8.4% and medicine 7.7%. Computer science accounts for 4.3% of researchers worldwide but 32.7% of Claude Code sessions; AI and machine learning for 1.2% of researchers but 5.0% of Claude and 15.2% of Claude Code sessions. The log-log correlation between a field’s session share and its researcher share is 0.79 on Claude and 0.62 on Claude Code, falling to 0.61 and 0.43 at the subfield level. Formal sciences, social sciences and economics show high relative use; lab-based physical sciences, medicine, nutrition and veterinary medicine show low relative use; arts and humanities are especially low on Claude Code.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

The “theoretical AI capability” score is built by having an LLM make pairwise AI-versus-human comparisons for each step of a research task, then aggregating with a Bradley–Terry model. It is a model’s judgment of model capability, not a measured success rate. The report then correlates the capability percentile with several task characteristics, copied below.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

Correlation of task characteristics with the “theoretical AI capability” percentile (figures from the report).
Task characteristicCorrelation with capability percentileUse-ratio pattern the report describes
Reinforcement-learning suitability (RL index)+0.78top bin about 2.2 (Claude) / 4.2 (Claude Code)
Cognitive share of the task+0.69use ratio rises to about 1.4 / 1.5 with cognitive share
Physical component−0.57falls from about 1.2 toward zero
Regulatory restriction−0.38falls from about 1.2 toward zero
Interpersonal component−0.31falls from about 1.2 toward zero

At the subfield level, use per researcher correlates with average capability at 0.45 (Claude) and 0.57 (Claude Code), and autonomy with capability at 0.47 and 0.31; across fields, the weighted correlation between use ratio and the AI time share is +0.58. The authors note that health sciences use less than capability predicts, and suggest regulation as a reason, while formal sciences, social sciences and the humanities use more, plausibly because their material is already text and code. The direction of causation cannot be settled from this data: capability may drive use, or the degree to which a field’s material is digitized may drive both the capability score and the usage.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

5. Three acceleration scenarios: read the assumptions before the multipliers

The part of the report most likely to be distorted in retelling is the acceleration multiplier. In the authors’ own words, these are illustrative scenarios, not forecasts. All three share one set of cost assumptions and one bottleneck calibration; they differ only in how much of the non-physical work AI is assumed to automate.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

Assumptions and results of the three scenarios (figures from the report; multipliers refer to research-team time, not to output or discoveries).
ScenarioCore assumptionResult stated in the reportHow to read it
Scenario 1: current capabilitiesCapability scores decide which steps AI takes overAI takes 27%–52% of research time (median 38%); acceleration from 1.35x (arts) to 2.02x (statistics); computer science 1.96x, chemistry 1.41xUpper-bound estimate for today; adoption lag still applies
Scenario 2: 75% of non-physical steps automatedHypothetical future; physical steps unchangedComputer science about 8x; statistics and library science about 7x; economics about 6x; most social sciences, mathematics, physics and astronomy 4–5x; bench and medical sciences 2–3xSensitivity analysis; automated share of non-physical time from 82% (computer science) to 28% (arts)
Scenario 3: all non-physical steps automatedHypothetical future; only physical steps and coordination remainStatistics, computer science, economics, mathematics, psychology, most social sciences, arts and humanities about 15–16x; biology, chemistry, materials, agriculture, biomedical sciences only 3–4xPhysical steps are about 40% of time in those fields: the hard bottleneck

Cost assumptions: an AI agent hour at 30 dollars against a researcher hour at 95 dollars, with AI running 0.2 hours for every researcher hour saved. From this the authors derive that a fully automated task costs about one-sixteenth of the human cost, and that halving AI cost would double that ceiling. The bottleneck structure is calibrated to Ahmadpoor and Jones (2019). The report states explicitly that it does not count machinery or experimental inputs, constraints at the level of a field rather than a team, substitution of simulation for experiment, or the quality of ideas.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

So before “computer science 8x” goes on a slide, confirm three things: it is arithmetic on team time, not papers or discoveries; scenarios 2 and 3 assume automation has already happened, not that models can do it today; and in biology, chemistry and materials, physical steps take roughly 38% to 41% of time, so the report’s own ceiling there is 3x to 4x however strong the model becomes.

6. The Claude Science sample and the 528-person survey: reading self-selected data

The supplemental Claude Science sample is concentrated in the life sciences: biomedical sciences 31.1%, biology 24.1%, medicine and clinical sciences 8.7%, every other field below 5%, life sciences more than half in total. Relative to Claude, protein structure and function hypotheses are 6.0 times as likely, mechanistic models of protein–protein and protein–ligand interactions 5.6 times, drug–target hypotheses 5.6 times; conversely, coordinating with collaborators is at 0.15 times, presenting at conferences 0.2 times, species abundance and diversity analysis 0.23 times. Ideation makes up 8% of Claude Science sessions.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

For biology and biomedical sessions, the report estimates three measures from its own “economic primitives” framework (citing Appel et al. 2026), ordered Claude / Claude Code / Claude Science: human time without AI 4.9 / 5.9 / 10.3 hours, doctoral-level content 48.0% / 67.7% / 82.7%, high AI autonomy 23.7% / 64.1% / 73.3%. Reweighting Claude and Claude Code to the Claude Science task mix gives 5.1 hours, 55.1%, 25.2% and 5.5 hours, 71.8%, 61.4%: the gap narrows but does not close. The authors write that the differences may partly reflect who uses the product, a self-selection effect; the measurement method for the three indicators is not spelled out in the report.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

  • Self-reported use. Ideation: 17% none, 53% assistive, 24% shared. Data gathering: 20% none, 31% assistive, 30% shared, 14% delegated. Data analysis: 20% assistive, 44% shared, 28% delegated. Writing: 40% assistive, 41% shared, 13% delegated.
  • Importance for an important result, 100 points: ideation 35.6, data gathering 23.6, data analysis 23.3, writing 17.5.
  • Expectation that AI alone matches top researchers: data analysis 38% say already, 94% by 2030; writing 89% by 2030; ideation and data gathering 72% each by 2030.
  • Full research projects with no human involvement: about 40% expect them by 2030, about 64% by 2035, 16% never.

Put the survey next to the usage data and the report’s most engineerable finding appears: researchers rate ideation as the most important step (35.6 points), yet ideation has one of the lowest use ratios (0.59 / 0.30) and is the hardest step to verify. High value, low use, low verifiability: the six sections that follow are designed for that combination, not for producing one more draft.

7. From question to traceable evidence: six links in a research session

The report’s discussion names two pressures. First, as output volume rises, the capacity to verify and absorb that output becomes the bottleneck. Second, citing Schneider et al. (2020), principal investigators on US federally funded projects spend about 44% of their research time on administrative requirements. The right place for AI in a research process is therefore not “generate more pages” but “leave a trace at every step that someone else can check”, so that verification cost does not grow in step with output.

The chain below is our engineering recommendation, not report content. It demands file-level evidence for every arrow: a written spec or preregistration at the question stage; source records and hashes for data; one re-runnable entry point and a locked environment for analysis; a review record independent of the author for verification; a command output behind every number in the writing; and for every figure a path back to script, commit and random seed. Claude Code’s best-practices page says the same thing in its own domain: give Claude a check it can run, and ask for the command and its output, or a screenshot, instead of accepting “all tests pass”.

  • Question: write the research question, inclusion and exclusion criteria and planned analyses into SPEC.md; everything the model does later is checked against it.
  • Data: record each raw file’s source URL or collection date, generate data/SHA256SUMS, keep the raw directory read-only.
  • Analysis: one run.sh regenerates every result; environment.lock pins dependencies; random seeds are printed explicitly.
  • Verification: tests cover the analysis code; a reviewer who did not write it (a person or a read-only subagent) re-runs and signs off.
  • Writing: every number in the manuscript maps to a command output; the same for replies to reviewers.
  • Provenance: figures/PROVENANCE.tsv records script, commit and seed for each figure; REVIEW.md records who re-ran what and when.
  1. Question: SPEC.md with inclusion and exclusion criteria
  2. Data: source records + SHA256SUMS
  3. Analysis: run.sh + environment.lock + seeds
  4. Verification: tests + independent reviewer re-run
  5. Writing: every number points to a command output
  6. Provenance: PROVENANCE.tsv + REVIEW.md
The research-session chain this article recommends: every arrow must have matching evidence in the folder; final prose cannot stand in for the intermediate steps.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05) · Claude Code docs: Best practices

8. Dividing the work between Claude, Claude Code and Claude Science

The report’s data already shows each surface’s natural tendency: Claude takes writing, literature and reviewer replies; Claude Code takes data analysis and technical artifacts; Claude Science concentrates in the life sciences with the highest autonomy. The official claude.com/science page, read on 2026-11-08, describes Claude Science as a desktop app in public beta for macOS, Windows and Linux. The page says explicitly that it is an app, not a model, and that it runs on the Claude models your plan includes. It is available on Pro, Max, Ultra, Team and Enterprise plans; Team and Enterprise admins must enable it first, except on the Claude Team plan for Scientists, where it is on by default and which is aimed at active scientists at academic and nonprofit institutions, with eligibility verified through the group’s principal investigator.

Claude Science official page

On features, the page lists connections to more than 60 scientific databases, analysis specialists for genomics, single-cell, proteomics, structural biology and cheminformatics, and a background reviewer that flags incorrect citations, untraceable numbers and figures that do not match their underlying code. Each artifact keeps the code that generated it, the environment it ran in, a plain-language description and the conversation that led to it. Compute can run on local kernels, a Slurm cluster over SSH or a Modal account. Raw datasets and compute stay on the machines, clusters or cloud accounts you choose, but prompt and response content is processed by Anthropic under standard retention, and some sensitive life-science requests may be handled by a different Claude model. All of this is the vendor’s description; we did not install or test the app.

Claude Science official page

Suggested division of work across the three surfaces (the “report characteristics” column uses report data; the rest is our recommendation).
SurfaceResearch tasks it suitsWhat a session leaves behind by defaultWhere the data livesReport characteristics
Claude (Chat / Cowork)Drafting manuscripts, literature synthesis, reviewer replies, organizing ideasConversation text and written artifacts; code and data are not part of itWhatever you paste enters the conversationWriting and communication 32.0%; written artifacts 52%; high autonomy only 23.7% (biology)
Claude CodeData analysis, visualization, building analysis pipelines, executable verificationCommands, outputs, file changes; Stop hooks and deny rules give deterministic limitsLocal repository; whatever the model reads enters the conversationData analysis 48.1%; technical artifacts about twice Claude’s; high autonomy 64.1%
Claude Science (beta)Life-science analysis, database search, multi-step analysis with a reviewerPer the vendor, each artifact carries code, environment, description and conversationRaw data and compute stay where you choose; prompts and responses are processed by AnthropicLife sciences more than half; high autonomy 73.3%; doctoral-level content 82.7%

Choose by data boundary first and evidence need second. For projects under data agreements or ethics review, confirm that “prompt and response content processed by Anthropic” is permitted before anything else, and do not read “raw data stays local” as “nothing is uploaded”. Use Claude Code where executable evidence is needed: Stop hooks, deny rules and --max-turns are classed as deterministic controls in its documentation and do not depend on the model remembering a rule. Writing can stay in the chat surface, but every number must still trace back to a command output in the analysis folder. At the plan level you only need to know which plans the vendor lists; check your own account for specifics. This article does not discuss prices.

Claude Science official page · Claude Code docs: Best practices

9. What a research session must leave behind: an offline acceptance gate

Compress the six links of section 7 into five files that must exist, then check with a script that they are present and consistent. The gate does not judge whether the science is right; it judges whether someone else can re-run and trace it. It can be run by hand or as a Claude Code Stop hook, where exit code 2 sends Claude back to work instead of letting it declare completion.

Claude Code docs: Best practices

Evidence an analysis folder must contain and how it is checked (our recommendation).
EvidenceFileCheck
Re-runnable coderun.shexists; on a clean checkout regenerates every result
Pinned environmentenvironment.lockexists; exact versions exported by pip, conda or renv
Data hashesdata/SHA256SUMSshasum -a 256 --check passes for every file
Figure provenancefigures/PROVENANCE.tsvevery row’s figure, script, commit and seed exist and are non-empty
Independent reviewREVIEW.mdcontains a re-ran: line naming what the reviewer executed
check_analysis.sh: offline check that the five kinds of evidence exist and agree; prints ACCEPT, otherwise exits with code 2.
#!/usr/bin/env bash
# check_analysis.sh <folder> — offline acceptance gate for one analysis folder.
# ACCEPT only when code, pinned environment, data hashes, figure provenance
# and an independent reviewer note are all present and consistent.
set -u
dir="${1:?usage: check_analysis.sh <analysis-folder>}"
fail=0
need() { if [ -e "$dir/$1" ]; then echo "ok      $1"; else echo "MISSING $1 — $2"; fail=1; fi; }

need run.sh                 "one entry point that regenerates every result"
need environment.lock       "pinned environment (requirements.txt, renv.lock, conda export ...)"
need data/SHA256SUMS        "hashes of the raw inputs the analysis read"
need figures/PROVENANCE.tsv "one row per figure: figure, script, commit, seed"
need REVIEW.md              "independent reviewer pass: who, when, what was re-run"

if [ -f "$dir/data/SHA256SUMS" ]; then
  if (cd "$dir/data" && shasum -a 256 --check --quiet SHA256SUMS); then
    echo "ok      data hashes match"
  else
    echo "FAIL    raw data does not match SHA256SUMS"; fail=1
  fi
fi

if [ -f "$dir/figures/PROVENANCE.tsv" ]; then
  while IFS=$'\t' read -r fig script commit seed; do
    [ "$fig" = "figure" ] && continue            # header row
    [ -f "$dir/$fig" ]    || { echo "FAIL    listed figure missing: $fig"; fail=1; }
    [ -f "$dir/$script" ] || { echo "FAIL    script for $fig missing: $script"; fail=1; }
    [ -n "$commit" ]      || { echo "FAIL    no commit recorded for $fig"; fail=1; }
    [ -n "$seed" ]        || { echo "FAIL    no seed recorded for $fig"; fail=1; }
  done < "$dir/figures/PROVENANCE.tsv"
fi

if ! grep -qiE '^re-ran:' "$dir/REVIEW.md" 2>/dev/null; then
  echo "FAIL    REVIEW.md has no 're-ran:' line naming what the reviewer executed"; fail=1
fi

if [ "$fail" -eq 0 ]; then echo "ACCEPT"; else echo "HOLD — fix the lines above"; exit 2; fi

Usage: bash check_analysis.sh <analysis-folder>. We tested it on a minimal synthetic folder: with all five files present, hashes matching and every PROVENANCE row complete it prints ACCEPT; on an empty folder it lists each missing item and exits with code 2. It deliberately does not parse notebooks or read data content; that is the job of tests and the reviewer. It depends only on bash, shasum and grep, which ship with macOS and most Linux distributions.

10. Put the evidence rules in CLAUDE.md, then back them with a Stop hook

Claude Code’s best-practices page, read on 2026-11-08, divides instructions into two kinds. Non-deterministic ones are read by the model, which decides whether to follow them: the prompt, CLAUDE.md, skills. Deterministic ones are executed by Claude Code itself: hooks, deny rules, managed settings. The page’s rule of thumb is that a line with zero exceptions belongs in a hook, not in CLAUDE.md, and that repeatedly adding emphasis to a CLAUDE.md line Claude keeps ignoring is itself the signal. CLAUDE.md should hold only what the model cannot see in the code; the memory guide recommends staying under 200 lines.

Claude Code docs: Best practices

CLAUDE.md: session conventions for a data-analysis project; only commands, evidence rules and gotchas the model cannot read from the code.
# Analysis conventions (loaded into every Claude Code session in this repo)

## Commands
- Reproduce everything: bash run.sh
- Tests on the analysis code: python3 -m pytest tests -q
- Acceptance gate: bash check_analysis.sh .

## Evidence rules
- Every number you report must come from a command you ran in this session.
  Quote the command and the relevant output lines; never type a number from memory.
- Fix the random seed, print it, and record it in figures/PROVENANCE.tsv.
- When you change a figure, update its PROVENANCE row (figure, script, commit, seed).
- Raw data under data/raw/ is read-only. Derived data goes to derived/ and is
  regenerated by run.sh, never edited by hand.
- If a check fails, say so. Never describe a result as confirmed without the output.

## Gotchas
- The environment is pinned in environment.lock; do not install packages ad hoc.
- A citation needs a DOI or URL that was actually opened; mark everything else "to verify".

The .claude/settings.json below turns three rules into deterministic controls. Deny rules hold in every permission mode, including auto and bypassPermissions; the documentation notes that a Read deny rule also catches common file-reading commands such as cat, but not a script that opens the file itself. A Stop hook runs when Claude tries to end its turn; exit code 2 blocks the stop and whatever the command wrote to stderr goes back to the model as the reason it cannot finish. The hooks documentation adds a cap: after eight consecutive blocks with no tool call in between, Claude Code overrides the next block and ends the turn, adjustable with the CLAUDE_CODE_STOP_HOOK_BLOCK_CAP environment variable; the hook input carries a stop_hook_active field to avoid looping on a condition that will never resolve.

Claude Code docs: Best practices · Claude Code docs: Hooks

.claude/settings.json: pre-approve three analysis commands, deny reading secrets and editing raw data, and a Stop hook that runs the tests and then the acceptance gate.
{
  "permissions": {
    "allow": [
      "Bash(bash run.sh)",
      "Bash(python3 -m pytest *)",
      "Bash(bash check_analysis.sh *)"
    ],
    "ask": ["Bash(git push *)"],
    "deny": [
      "Read(./.env)",
      "Read(./secrets/**)",
      "Edit(./data/raw/**)",
      "Write(./data/raw/**)"
    ]
  },
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 -m pytest tests -q 1>&2 && bash check_analysis.sh . 1>&2 || exit 2"
          }
        ]
      }
    ]
  }
}

Independent review can go to a read-only subagent. The sub-agents documentation places definitions under .claude/agents/, with only name and description required in the YAML front matter and tools accepting a comma-separated list; leaving out Write and Edit yields a reviewer that cannot change files. It also warns that when the main conversation runs in bypassPermissions, acceptEdits or auto mode, a subagent’s permissionMode is ignored, so restricting tools is the more reliable control. The best-practices page’s related suggestion is /code-review, which reviews the diff in a fresh subagent that never saw your conversation and is not swayed by the reasoning that produced the code.

Claude Code docs: Sub-agents · Claude Code docs: Best practices

.claude/agents/analysis-reviewer.md: a read-only review subagent that re-runs the gate and traces every number in the report.
---
name: analysis-reviewer
description: Independent read-only reviewer for an analysis folder. Use after the main session says a result is done.
tools: Read, Glob, Grep, Bash
model: inherit
---

You review an analysis folder you did not produce. Do not edit files.
1. Run bash check_analysis.sh . and report the full output.
2. For every number in REPORT.md, find the command or script that produced it;
   list numbers you cannot trace.
3. For every figure listed in figures/PROVENANCE.tsv, confirm the script, commit and seed
   exist and that the figure is newer than the script.
4. Report "ACCEPT" only if every item passes; otherwise list each gap with the file name.

11. Literature screening and references: fix the output schema, then check formats offline

The report shows literature review as the second most common task on Claude (6.8%). An auditable screen needs two things: the model’s output follows a fixed structure, and every decision quotes the sentence in the abstract that settled it. Claude Code’s programmatic-use page, read on 2026-11-08, provides the mechanism: claude -p runs non-interactively, --output-format json with --json-schema returns structured output in a structured_output field, and if the model declines or produces nothing valid that field is absent, so a script must check for it. --bare skips hooks, skills, plugins, MCP servers and CLAUDE.md so the same command behaves identically on every machine, but it does not use a subscription login and requires ANTHROPIC_API_KEY; --permission-mode dontAsk denies anything that would otherwise prompt; --max-turns caps the run; piped stdin is capped at 10 MB.

Claude Code docs: Run Claude Code programmatically (claude -p)

Screen one abstract against a fixed schema; one record per run, so runs can be parallel and repeated. We did not execute this command (it requires billed API access).
# Screen one abstract against written criteria; the answer must match a fixed schema.
# --bare skips hooks, plugins and CLAUDE.md so the run is identical on every machine;
# it does not use a subscription login, so ANTHROPIC_API_KEY must be set (billed API use).
cat abstract-0001.txt | claude --bare -p \
  "Decide whether this abstract meets every criterion in CRITERIA.md. For each criterion quote the sentence that decided it. Do not guess missing information: mark it unknown." \
  --allowedTools "Read" \
  --permission-mode dontAsk \
  --max-turns 3 \
  --output-format json \
  --json-schema '{"type":"object","properties":{"include":{"type":"string","enum":["yes","no","unknown"]},"criteria":{"type":"array","items":{"type":"object","properties":{"name":{"type":"string"},"met":{"type":"string","enum":["yes","no","unknown"]},"quote":{"type":"string"}},"required":["name","met","quote"]}}},"required":["include","criteria"]}' \
  | jq '.structured_output // {"error": "no structured_output: do not count this record"}'

The design rationale: the quote field lets a reviewer check each decision against the abstract instead of trusting a yes; unknown is an explicit value, which stops the model guessing when information is missing; one call per record allows parallel runs and re-running only the failures. We did not run this command, since it needs an API key and incurs cost; we checked each flag’s existence and meaning against the documentation. Flag names may change between versions; confirm against the current programmatic-use and CLI reference pages before running.

Claude Code docs: Run Claude Code programmatically (claude -p)

verify_refs.py: offline check of DOI syntax, duplicates and years in a bibliography CSV; it never resolves DOIs online.
# verify_refs.py — offline format check of a bibliography CSV (columns: key,doi,year,title).
# It checks DOI syntax, duplicates and years only. It does NOT resolve DOIs or fetch
# anything; do that later as a separate, logged step and keep the HTTP status per DOI.
import csv, re, sys
from pathlib import Path

DOI = re.compile(r"^10\.\d{4,9}/\S+$")
path = Path(sys.argv[1] if len(sys.argv) > 1 else "references.csv")
seen, problems = {}, 0

def report(line, key, msg):
    global problems
    problems += 1
    print(f"line {line}: {key}: {msg}")

with path.open(newline="", encoding="utf-8") as f:
    for n, row in enumerate(csv.DictReader(f), start=2):
        key = row.get("key") or f"row{n}"
        doi = (row.get("doi") or "").strip().lower()
        doi = doi.removeprefix("https://doi.org/").removeprefix("doi:")
        if not doi:
            report(n, key, "no DOI — mark 'to verify'; do not cite yet")
        elif not DOI.match(doi):
            report(n, key, f"malformed DOI {doi!r}")
        elif doi in seen:
            report(n, key, f"duplicate of {seen[doi]}")
        else:
            seen[doi] = key
        year = (row.get("year") or "").strip()
        if not re.fullmatch(r"(19|20)\d{2}", year):
            report(n, key, f"year {year!r} is not a four-digit year")

print(f"{len(seen)} unique well-formed DOIs, {problems} problem(s)")
sys.exit(1 if problems else 0)

verify_refs.py works at the format level only: a DOI starts with 10. and a registrant prefix, is unique after stripping https://doi.org/ and doi: and lowercasing, and the year has four digits. It stays offline on purpose: resolving DOIs should be a separate, logged step that records the HTTP status and date for each one. We tested it on a synthetic CSV with four rows: one valid, one duplicate of the first differing only in case and prefix, one with no DOI, one with a malformed DOI and a two-digit year. It reported 1 unique well-formed DOI and 4 problems and exited with code 1.

12. Four decisions for a researcher after reading the report

First, pilot AI on ideation and data gathering rather than on one more draft. The report shows these are the steps researchers rate most important (35.6 and 23.6 points) and the ones with the lowest use ratios; experiments there pay most and need the evidence chain of section 7 most, because errors are hardest to spot. Second, choose the surface by data boundary: confirm that your institution’s data agreements allow prompt and response content to be processed by the vendor before discussing features.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05) · Claude Science official page

Third, give every project an acceptance gate and a reviewer who did not write the code, whether a colleague or a read-only subagent; the scripts in sections 9 and 10 run without any account. Fourth, treat the report’s multipliers as arithmetic on team time: scenario 1’s 1.35x to 2.02x is an upper-bound estimate for current capability, scenarios 2 and 3 are sensitivity analyses, and the 3x to 4x ceiling in wet-lab fields follows from physical steps taking about 40% of the time.

Anthropic: AI for scientific discovery — How researchers use Claude (2026-11-05)

For readers at academic or nonprofit institutions, Anthropic has two public entry points related to the report. The AI for Science program, announced on May 5, 2025, offers API credits to researchers attached to research institutions who work on high-impact projects, with a focus on biology and the life sciences; applications go through an online form and are reviewed by Anthropic’s team with subject-matter experts, and the page gives no credit amounts or deadlines. The anthropic.com/science page collects Anthropic’s science blog, for example the vault-particle structure of 2026-11-04 and the formalized proof of Fermat’s Last Theorem of 2026-09-04. These are cases the vendor chose to show, and the reading rule is the same as for the report.

Anthropic: AI for Science program announcement (2025-05-05) · Anthropic Science page and science blog index

What we did not verify: we did not reproduce the report’s classifiers and have no access to the underlying session data, so every figure is a transcription or recomputation from the published text; we did not install or trial Claude Science, and every feature description comes from the vendor’s page; the claude -p example was not executed, only checked flag by flag against the documentation; the three scripts ran only on local synthetic fixtures, never on real research data; the Claude Code documentation was read on 2026-11-08 and flag names or defaults may change between versions.

This article analyzes an Anthropic research report and public documentation. Claude subscriptions, Claude Science plan requirements and this site’s products are separate ledgers. Do not infer any relationship between this site and Anthropic, and do not read the report’s multipliers as a promise about any product.