Tools
Every module in this course comes back to one decision: which rung of the tool ladder a task actually needs. Module 1 introduces that ladder with one comparison — a plain chat window failing to open a Compustat extract, the same request succeeding once an agent can read, script, and run. This page is the reference version of that lecture: four tools, what each one is good for, what it costs, and a decision table for matching a research task to the right one. It gets updated on its own schedule, because tool capabilities and pricing change faster than a syllabus does.
The four tools
Claude Desktop
What it is. A chat application with Projects (persistent context you upload once and reuse across conversations) and MCP support, so it can be wired to external tools and data sources through the same protocol Module 4 uses for WRDS. It does not have direct filesystem access to your machine and cannot execute code or run a script against a local file the way a terminal agent can.
When to reach for it. Anything that’s a conversation, not a pipeline: a quick methods question, drafting an email, thinking through a referee comment before you touch the manuscript, summarizing a PDF you’ve uploaded to a Project. It sits at the first or second rung of the ladder — useful for thinking work, no help at all once a task requires touching a file on disk.
Cost / plan. A Claude Pro or Max subscription (Claude Max is a higher-usage tier for people running many long sessions), or pay-as-you-go API access if you’d rather not subscribe. Pricing tiers change; check current rates before budgeting for a cohort.
Install pointer. Download from Anthropic’s official site; no terminal setup required, which makes it the easiest starting point for someone who has never touched an agentic tool before.
Cursor
What it is. An agentic code editor — a fork of VS Code with inline AI edits, a chat panel that can propose and apply multi-file changes, and its own agent mode that will plan and execute a short chain of edits inside the editor’s sandbox. It sits a rung above Claude Desktop and a rung below Claude Code: real autonomy, but bounded by the editor’s own project view rather than a full terminal session.
When to reach for it. Mixed Stata/Python users who want a GUI rather than a terminal prompt, and who are mostly editing code rather than running open-ended multi-step pipelines: cleaning up a do-file, refactoring a script, working through inline suggestions while you read the diff in the same window you’re already working in.
Cost / plan. A paid Cursor subscription (Pro tier, roughly comparable in price to Claude Pro) is required for meaningful agentic usage beyond a free trial; Cursor can also be configured to call Anthropic’s models directly, which is worth knowing if your institution already has an Anthropic API budget.
Install pointer. Download from Cursor’s official site; sign in, connect a model provider if you want a choice other than the bundled default, and open a project folder to get started.
Claude Code
What it is. A terminal-resident agent: it reads and writes files in your project directory, executes your existing R, Python, or Stata installation, and iterates — write, run, read the error, fix, rerun — without you retyping anything. This is the fourth rung, and the one this course is built on. Wired to an external service through the Model Context Protocol (the WRDS MCP server Module 4 builds is the course’s example), it reaches the fifth rung: authenticated access to a licensed data source without your credentials ever entering the conversation.
When to reach for it. Anything that is a real pipeline rather than a single edit: an empirical loop that goes from an empty folder to a verified figure (Module 2), an EDGAR scrape with a fallback chain of extraction patterns (Module 3), a WRDS pull with iron-law filters and a Parquet/DuckDB handoff to Stata (Module 4), or a capstone that has to survive a credential audit and a commit-history cross-check (Module 5).
Cost / plan. Same subscription as Claude Desktop (Pro or Max) or an API key; Claude Code is a separate install but draws on the same account. Heavy agentic use — long sessions, large context, frequent tool calls — is the use case Max exists for.
Install pointer. Installed from the terminal per Anthropic’s official Claude Code documentation; requires a working local development environment (Node, and whatever R/Python/Stata installation your research already depends on) since Claude Code runs your code, it doesn’t ship its own.
Codex
What it is. OpenAI’s coding agent, available as a CLI, an IDE extension, and a cloud-hosted execution environment. Functionally, it occupies the same rung as Claude Code — terminal or IDE-resident, file and execution access, iterative agentic loops — built by a different lab on a different model family.
When to reach for it. If your institution’s AI budget or existing subscriptions run through OpenAI rather than Anthropic, or if you want a second agent’s judgment on the same codebase (some researchers run two agents against the same repo as a cheap adversarial check). The concepts this course teaches — context management, verification discipline, skills-as-SOPs, MCP-style tool access — transfer directly; the syntax and a handful of defaults differ.
Cost / plan. A ChatGPT Plus/Pro/Team subscription (Codex is bundled into the higher tiers) or OpenAI API usage.
Install pointer. Installed via OpenAI’s official Codex documentation, either as a CLI package or an IDE extension, depending on which surface you want.
“I want to… → use…”
| I want to… | Use… | Why |
|---|---|---|
| Ask a quick lit question | Claude Desktop | It’s a conversation with no file to touch — the lightest tool that answers it is the right one. |
| Draft a referee response | Claude Code, editor-not-rewriter mode | The Module 5 editor-not-rewriter prompt needs the actual manuscript files and a skill like barrios-voice or econ-humanizer running against them, not a pasted excerpt in a chat window. |
| Build a data pipeline (idea → figure) | Claude Code | This is the Module 2 empirical loop end to end — named scripts, a join, a paper trail — which requires real filesystem and execution access. |
| Scrape EDGAR filings | Claude Code | Rate limits, caching to disk, and a multi-pattern extraction fallback (Module 3) are the multi-step, file-heavy jobs a terminal agent handles and a chat tool cannot. |
| Pull WRDS data | Claude Code + wrds-mcp |
The fifth rung exists for exactly this: your WRDS credentials live in an environment file the MCP server reads, never in the conversation (Module 4). |
| Revise a paper draft (writing + git) | Claude Code | Skills, strategic-revision, git commits as the unit of verification, and the no-hand-typed-numbers rule (Module 5) all assume the agent can see and version the actual repository. |
Where they overlap
Claude Code vs. Cursor’s agent mode. Both will plan and execute a multi-step change without you approving every line. The practical difference is surface and scope: Cursor’s agent operates inside the editor’s project view, which is comfortable if your work is mostly code files you’re already looking at, while Claude Code operates from the terminal against your whole project directory and whatever local runtime you have installed, which matters once a task spans data files, non-code artifacts, and long-running scripts rather than source files alone. A Stata-heavy researcher who wants to watch inline diffs in a familiar editor window may genuinely prefer Cursor for day-to-day edits and still reach for Claude Code for the heavier pipeline work.
Claude Code vs. Codex. These are close functional peers — terminal-resident, file- and execution-capable, iterative — built by different labs. Neither is categorically more capable at the kind of task this course teaches; the differences show up in model behavior on specific tasks, in the maturity of each ecosystem’s MCP servers and skills equivalents, and in which subscription you already have. This course teaches Claude Code because its skills ecosystem and the wrds-mcp server this course depends on are built for it, not because the underlying concepts — context management, verification discipline, permission modes — are Anthropic-specific. They aren’t; they transfer to Codex directly.
Running multiple sessions in parallel
Once one agent feels routine, the natural next question is two. The naive version fails: two Claude Code sessions in the same directory stomp on each other — conflicting edits, dirty git state, a build one agent breaks while the other is mid-test. The clean primitive is the git worktree: each session gets its own directory tree while every tree shares the same .git database, so branches stay in lockstep with no cloning and no syncing. That is Module 5’s git-as-operating-system idea, extended one step — commits are the unit of verification, and worktrees are the unit of isolation.
cmux (“tmux for Claude Code,” MIT, pure bash) wraps that whole lifecycle into single commands: cmux new robustness-alt-winsor creates a worktree and branch and launches a fresh Claude session in it; cmux new fix-figure-labels spins up a second, fully isolated session without touching the first; cmux merge and cmux rm fold finished work back into your main checkout and clean up. For a researcher, the pattern fits any task that forks: two variable-construction variants explored simultaneously and compared before you commit to one; a referee-response robustness battery running in one worktree while you and another session revise prose in a second; a risky refactor of the pipeline tried on a branch an agent can’t leak into your working copy.
Two caveats. Parallel sessions multiply usage the same way parallel RAs multiply salaries — the subscription headroom that comfortably feeds one session may throttle three. And parallelism multiplies verification debt at exactly the same rate it multiplies output: every worktree still owes the Module 5 discipline (paper trail, inspection, one number checked by hand) before its branch merges, not after. cmux merge is a git operation, not a sign-off.
Adjacent options, briefly: manaflow-ai/cmux (same name, different tool) is a Ghostty-based macOS terminal with vertical tabs and notifications built for watching several coding agents at once — it solves the UI problem where craigsc/cmux solves the workflow problem; and dashboard tools such as amux monitor many sessions from one place. Start with worktrees — they teach the concept; the fancier tooling is convenience on top.
Last reviewed: July 2026. Tool capabilities, pricing, and install steps change often — treat the profiles above as a starting point, and check each vendor’s current documentation before you commit a cohort to one.