Research Scientist — AI Cheat Sheet

1 Getting started in claude.ai

The web chat is your research workbench — no install required.

Projects keep a body of context (papers, notes, goals) reusable across chats.
Upload PDFs, CSVs, images, and code directly into a conversation.
Ask for an Artifact (a live HTML/SVG/document panel) when output is long or visual.
State your role and goal up front: "I am a climate scientist; be precise and cite uncertainty."

Tip Give the model your standards, not just your question: audience, level of rigor, preferred units, and what a good answer looks like.

2 Literature & reading

Use Claude to digest and structure — verify the facts yourself.

Summarize a paper into claims, methods, assumptions, and limitations.
Compare several PDFs into a structured table.
Draft a related-work paragraph from sources you supply.

Here are 4 PDFs. Build a comparison table:
columns = [method, dataset, key assumption,
reported skill metric, stated limitation].
Quote the exact sentence for each metric and
give the page number. If a cell is not stated
in the paper, write "not reported" — do not infer.

Caution Do not ask for citations from memory. Models invent plausible-looking references and DOIs. Only summarize sources you have actually attached.

3 Analysis & data

Treat the model as a fast, fallible analyst pair.

Explain an unfamiliar method or derive an equation step by step.
Write/debug Python, R, or NCL/Fortran for your workflow.
Sanity-check a result: "What would make this wrong?"

Attached: station_temps.csv (daily, 1990-2020).
Write Python (pandas + numpy) to compute the
annual mean, a linear trend with 95% CI, and a
Mann-Kendall test. Print assumptions you make
about missing data, and flag any column you are
unsure how to interpret before computing.

Tip Ask it to run the numbers a second way (different library or method) and reconcile — disagreement surfaces bugs fast.

4 Figures, diagrams & artifacts

For dense or visual output, request an artifact.

SVG diagrams for schematics, model architectures, workflow figures.
HTML artifacts for interactive tables, draft posters, or a quick dashboard.
Plotting code (matplotlib/ggplot) you run on your own data.

Create an SVG schematic of a coupled
atmosphere-ocean model: 4 labeled boxes with
flux arrows between them, a legend, and aria
labels for accessibility. Make it a single
self-contained file I can drop into a slide.

Caution The model cannot see your real data values when it draws a figure — it renders what you describe or the code you run. Always plot from your own dataset before trusting a chart.

5 When to trust the output

Match your verification effort to the stakes. The model is a confident draft generator, not a source of truth.

Generally reliable

Restructuring / summarizing text you provided.
Explaining standard methods and well-known math.
Boilerplate code, refactors, regex, unit conversions you can test.
Brainstorming hypotheses and counter-arguments.

Verify before you trust

Specific citations, DOIs, author/year, exact quotes.
Numerical results, statistics, p-values — re-run them.
Recent events or anything past the training cutoff.
Domain edge cases and "it depends" claims stated as fact.

Tip — make it show its work Ask: "List the claims above and rate your confidence in each; mark which depend on the attached files vs. your prior knowledge." This separates grounded answers from guesses.

6 Model & effort selection

Bigger isn't always better — match the model to the task.

Pick	Best for
Opus	Hard reasoning: derivations, study design, multi-paper synthesis, subtle code bugs.
Sonnet	The everyday default: summaries, drafting, most coding, fast iteration.
Haiku	Quick, cheap, high-volume: reformatting, extraction, simple Q&A.

Effort / reasoning level (where offered):

low — quick lookups medium — default high — analysis & design xhigh — hardest reasoning

Tip Start on Sonnet/medium. Escalate to Opus/high only when the answer is wrong or the problem is genuinely hard — it costs more time and tokens.

7 Cost & token awareness

Usage is metered by session and by week.

Per-session & weekly limits: long chats with big attachments burn budget fast.
Opus costs a premium over Sonnet/Haiku per token — reserve it for hard problems.
Long conversations re-send their whole history each turn — start a fresh chat for a new topic.
Attach only the pages/files you need; trim giant CSVs to a sample first.
Other tools (OpenAI Codex, Google Antigravity) meter differently — check each plan's terms.

Tip Use a Project for stable background context so you don't re-paste it into every new chat.

8 Privacy & responsible use

Know what you may share before you paste.

Don't upload embargoed, proprietary, or personally identifying data without clearance.
Check your institution's policy and the product Terms of Use on data handling.
The model can be wrong with confidence — you remain the author and are accountable for results.
Disclose AI assistance per your journal / funder requirements.

Caution Treat anything pasted into a cloud chat as potentially leaving your machine. When unsure, de-identify or summarize first.

9 Provenance & disclosure

Make the result reproducible from what's in the repo — not from a chat you can't share.

Reproduce the checked-in artifact + environment, not the conversation — commit the generated code and figures.
Record the model name and version (pin a specific version — never "latest"), the effort level, your prompts, and which tools / MCP servers were enabled — plus the diff.
Add a methods-section line naming the tool + model + version and what it did (e.g. "drafted the analysis script; author reviewed and edited").

Tip "Latest" is a moving target. Pinning the exact model version lets a reviewer reproduce — or at least interpret — what you actually ran.

10 A light on-ramp to Claude Code

When your work outgrows copy/paste, Claude Code is the same intelligence working directly in your files and terminal — it can read your whole project, run scripts, and edit code in place.

Signs you're ready

You keep pasting the same files back and forth into chat.
Your analysis spans many scripts / a real repository.
You want changes applied and tested, not just suggested.

First steps (in a terminal, inside your project folder)

# install once, then just run it in your project:
npm install -g @anthropic-ai/claude-code
cd ~/my-analysis
claude

# then talk to it like a colleague:
> Read analyze.py and tell me what it does.
> Add a --start-year flag and update the README.
> Run the tests and fix anything that breaks.

Tip — modalities, cheapest to richest (a) copy/paste chat → (b) inline editor autocomplete → (c) CLI single agent → (d) CLI agent orchestrating sub-agents. Richer modes use more tokens but do more per prompt. Most of these prompting habits are model-agnostic and transfer to other AI coding tools.

Caution Claude Code can run commands and change files. Work in a git repo, review diffs before accepting, and never let it run destructive commands you don't understand.

11 Do / Avoid

Do

Give role, goal, audience, and rigor level up front.
Attach your sources; ask for quotes + page numbers.
Re-run every number and verify every citation.
Ask for confidence ratings and "what would make this wrong?"
Use artifacts for figures, tables, and dense output.
Start fresh chats per topic; reserve Opus for hard reasoning.

Avoid

Asking for references "from memory" — they get fabricated.
Trusting stats, p-values, or charts without re-deriving them.
Pasting sensitive or embargoed data into the cloud.
Treating confident prose as peer-reviewed fact.
Running Opus/xhigh on trivial reformatting tasks.
Letting Claude Code edit outside version control.