Claude Code & Cowork for Academic Research

01 The Premise

Academic research in economics and data science involves two fundamentally different kinds of work. There is building — writing code, compiling documents, running estimations, rendering visualizations — and there is managing — organizing literature, preparing data files, formatting deliverables, coordinating with collaborators. These tasks demand different interfaces even when they benefit from the same underlying intelligence.

Anthropic now offers two agentic tools that map cleanly onto this division: Claude Code for the terminal and Cowork for the desktop. Both are powered by the same model (Claude Opus 4.6) and operate on your local filesystem. This guide explains how to use each effectively and, more importantly, how to use them together.

02 Two Tools, One Model

Before going further, it helps to be precise about what each tool is and is not.

The critical insight is that these are not competing products. They share the same agent architecture (the Claude Agent SDK) and the same model. Cowork was built on top of Claude Code's foundations, abstracted for a broader audience. For a technically fluent researcher, the question is not which to use, but when to use which.

03 The Division of Labor

Claude Code owns anything that compiles, renders, or versions

When your workflow involves a toolchain — Quarto calling knitr calling R calling ggplot2, then pandoc converting to LaTeX, then XeLaTeX compiling with custom themes and TikZ packages — Claude Code is the right environment. It has direct access to your installed tools, can read error logs, inspect intermediate files, adjust source, and rerun. The tight feedback loop of edit → compile → inspect → fix is where the terminal excels.

The same applies to git operations (branching, rebasing, resolving conflicts), to running R or Python estimation scripts that depend on specific package versions, and to any iterative development cycle.

Cowork owns the surrounding knowledge work

Before and after the build pipeline, there is substantial work that is not code: gathering and sorting source materials, processing PDFs, preparing data files from spreadsheets, consolidating notes, reformatting collaborator drafts, producing handout versions of finished presentations. These tasks are tedious in the terminal but exactly what Cowork is designed for.

04 Claude Code Workflows

The following are core Claude Code use cases for an academic researcher. Each assumes you have your toolchain installed locally and a working CLAUDE.md in your project root.

Beamer Presentations via Quarto

Claude Code handles the full Quarto → knitr → LaTeX → XeLaTeX pipeline. It can create slides from an outline, apply custom Beamer themes, insert TikZ diagrams, generate ggplot2 figures in embedded R chunks, and iteratively fix compilation errors. The key advantage is diagnostic depth: when XeLaTeX throws a cryptic error about a missing font or a TikZ library conflict, Claude Code can grep through log files, check your texmf tree, and test fixes in real time.

Create a Beamer presentation on difference-in-differences estimation.
Use my UGA theme from templates/uga-beamer.sty.
Include a TikZ diagram showing the parallel trends assumption
and an R chunk that generates a simulated DID plot with ggplot2.
Compile with XeLaTeX and fix any errors.

R Scripts & Estimation

For empirical work — cleaning data, running regressions, producing publication-quality tables — Claude Code can write, execute, and debug R scripts directly. It has access to your installed packages, can install missing ones, and can iterate on output formatting (e.g., stargazer, modelsummary, kableExtra) until the table meets your specifications.

TikZ Diagrams

Complex standalone TikZ figures — game trees, DAGs, mechanism diagrams, timeline graphics — require iterative compilation. Claude Code compiles the standalone .tex file, inspects the PDF output, adjusts node positions or styling, and recompiles until the diagram is correct.

Git & Version Control

Managing branches for paper revisions, resolving merge conflicts between coauthor edits, tagging submission versions, maintaining clean commit histories. These operations are inherently terminal-native.

05 Cowork Workflows

Cowork operates through the Claude Desktop app. You point it at a folder, describe what you need, and it executes autonomously while keeping you informed.

Literature & Source Management

Point Cowork at a folder of downloaded PDFs. Ask it to sort them by topic, extract key findings, rename files using a consistent convention (e.g., AuthorYear_ShortTitle.pdf), and produce a summary document with annotations. This is hours of manual work reduced to a single prompt.

Data Preparation

Cowork can take messy input files — spreadsheets from collaborators, CSVs with inconsistent formatting, data dictionaries in Word documents — and standardize them into clean inputs for your R pipeline. It handles the reformatting, the column renaming, and the documentation, producing files that Claude Code can then ingest without friction.

Document Conversion & Formatting

After Claude Code compiles your Beamer PDF, Cowork can produce derivative outputs: a Word-format handout for students, a summary slide deck in PPTX for a seminar organizer who needs PowerPoint, a formatted syllabus update incorporating new readings.

Administrative Tasks

Processing course evaluations, organizing student submissions, creating grade spreadsheets from scattered files, drafting routine correspondence based on templates. Cowork handles these with its built-in document skills (docx, xlsx, pptx, pdf).

Research Inbox Triage

With MCP connectors and browser integration (via Claude in Chrome), Cowork can pull information from external services and organize it locally: downloading datasets from linked sources, extracting tables from web pages into spreadsheets, consolidating reference materials from multiple locations into your project folder.

06 The Pairing Protocol

The real productivity gain comes from using both tools on the same project, with the filesystem as the handoff surface. Here is a concrete workflow for preparing a research presentation.

Step-by-step

1. Cowork: Stage the project. Point Cowork at your project folder. Ask it to organize the PDFs you've downloaded for the literature review, extract key data tables from the papers, standardize the CSV files a coauthor sent, and produce a structured outline based on your folder-level instructions that encode your presentation conventions.

2. Claude Code: Build the artifact. Switch to the terminal. Claude Code reads the outline and prepared data files, writes the Quarto/Beamer source with your custom theme, generates ggplot2 figures from the cleaned data, creates TikZ diagrams for the theoretical framework, and compiles the whole thing. You iterate on the output until the slides are right.

3. Cowork: Distribute the output. Back in Cowork, ask it to produce a one-page Word summary of the presentation for the seminar series organizer, create a student handout with fill-in-the-blank versions of key equations, and rename and organize the final files for upload to your course site.

A Research Paper Workflow

A Course Prep Workflow

07 Context Management

Both tools operate within context windows that can fill up during complex tasks. Effective management is essential for long-running academic projects.

Claude Code

Use CLAUDE.md files in your project root to encode persistent context: style conventions, compilation instructions, package preferences, project-specific terminology. Keep these files lean — they load into the context window at every session start. Use /compact to summarize conversation history when context fills up. Chunk large projects into focused sessions (e.g., "figures session," "tables session," "text session") rather than trying to do everything in one conversation.

# Project: Trade Policy Paper
## Compilation
- Render with: quarto render paper.qmd --to pdf
- Engine: XeLaTeX with shell-escape enabled
- BibTeX: biber

## Style
- Figures: ggplot2 with theme_uga() from R/style.R
- Colors: Bulldog Red #BA0C2F, Arch Black #000000
- Tables: modelsummary with booktabs format
- Font: Fira Sans for slides, Libertinus for paper

Cowork

Use folder-specific instructions to achieve the same effect without editing files. When you open a project folder in Cowork, its instructions load automatically. You can also set global instructions that apply everywhere — your name, title, institutional affiliation, preferred document formatting, writing style. These persist across sessions and are edited directly in the Cowork interface.

08 Working with Teams

The Claude Code / Cowork pairing creates a natural division of labor within research teams that maps onto existing skill differences.

The PI or lead researcher

Uses Claude Code for estimation, figure generation, and document compilation. Defines project standards in CLAUDE.md. Builds the core technical artifacts.

Graduate students & RAs

Terminal-comfortable students use Claude Code for their own analysis work. Those less comfortable with the CLI use Cowork on the shared project folder to organize data, prepare literature summaries, clean input files, and format output documents. The plugin system means you can package project conventions (naming standards, data formats, documentation templates) into something they install with one click rather than asking them to configure a development environment.

Collaborators at other institutions

Share the project folder via Dropbox, Google Drive, or a git repository. Each collaborator can use whichever tool matches their technical comfort level. The shared filesystem and consistent conventions (encoded in CLAUDE.md and folder instructions) ensure coherence.

Administrative support

Staff who handle course logistics, grant budgets, or event planning can use Cowork to process documents, create spreadsheets, and organize files without any technical training. The GUI interface and natural language prompts make this accessible.

09 Setup & Configuration

Claude Code

Claude Code is a command-line tool that requires Node.js. Install it via npm, then run it in your project directory. It inherits your shell environment, so all locally installed tools (R, TeX, Python, git) are available.

# Install
npm install -g @anthropic-ai/claude-code

# Run in a project directory
cd ~/research/trade-paper
claude

# With explicit model selection
claude --model claude-opus-4-6

Create a CLAUDE.md file in your project root with build instructions, style conventions, and project-specific notes. This file is automatically read at session start.

Cowork

Cowork is built into the Claude Desktop app. Download the app from claude.com/download, open it, and click "Cowork" in the sidebar. Select a folder to work in. Cowork is available on macOS and Windows for all paid subscription tiers (Pro, Max, Team, Enterprise).

Configure global instructions with your identity, role, and general preferences. Then set folder-specific instructions for each project that encode its particular conventions.

MCP Connectors

Both tools support the Model Context Protocol for connecting to external services (Google Drive, GitHub, Slack, etc.). Connectors are configured in the Desktop app settings and are available in both Cowork and regular Claude conversations. For Claude Code, MCP servers can also be configured via the CLI.

Recommended folder structure

project/
├── CLAUDE.md              # Claude Code context
├── data/
│   ├── raw/               # Original data files
│   └── clean/             # Processed by Cowork or R
├── R/
│   ├── estimation.R       # Claude Code territory
│   └── style.R            # Shared ggplot2 theme
├── tex/
│   ├── theme.sty          # Custom Beamer theme
│   └── tikz-defs.tex      # TikZ library
├── figures/               # Output from R scripts
├── slides/                # Beamer source + PDF
├── paper/                 # Quarto source + PDF
├── handouts/              # Produced by Cowork
└── lit/                   # PDFs organized by Cowork

10 Limitations & Caveats

Neither tool is infallible, and the honest limitations are worth documenting.

Context windows fill up. Both tools operate within finite context windows. For large projects, you will need to chunk work into sessions, use /compact (Claude Code) or start fresh conversations (Cowork), and rely on persistent instructions to maintain continuity.

Cowork cannot compile LaTeX. It does not have access to your TeX distribution, R installation, or other locally installed toolchains. Document creation in Cowork uses its built-in skills (Python-based generation of docx, xlsx, pptx, pdf). For anything that requires your specific toolchain, use Claude Code.

Claude Code can hallucinate package APIs. When writing R or Python code, Claude Code may occasionally use function signatures or arguments that don't exist in your installed package versions. Always review generated code before running consequential analyses.

File persistence requires intention. In the Claude.ai web interface, container files are wiped between sessions. Claude Code operates on your actual filesystem, so files persist naturally. Cowork also operates on your local filesystem. But if you use the web chat for intermediate work, remember to download anything you want to keep.

Cowork is in research preview. As of February 2026, Cowork is still being actively developed. Features, plugin availability, and stability are improving rapidly but may change. Claude Code is more mature.