Using Claude AI

Two hours, two halves.

Goal: leave able to run a real research task end-to-end with an AI partner.

What is “vibe coding”?

You describe what you want in plain language; the AI writes and runs the code. You steer by results, not syntax.

• Term popularized by Andrej Karpathy (2025): lean on natural language, let the model handle the code.
• You stay in charge of intent, judgment, and verification.
• The model handles boilerplate, syntax, libraries, and debugging.
• It’s not “no code” — it’s code by conversation.

The bottleneck shifts from “can I code this?” to “is this the right thing, and is it correct?”

Why this matters for your research

• Lower barrier — build real tools without being a software engineer.
• Speed — data cleaning, plots, and scaffolding in minutes, not hours.
• Breadth — work across Python, R, Stata, LaTeX, and shell without mastering each.
• Focus — spend your time on the economics, not the syntax errors.
• Reproducibility — every step is captured as code plus conversation.

This is the skill the AFA session is really testing.

The toolbox

This course uses Claude, but the workflow is tool-agnostic.

My take: use the Claude app, not the terminal.

It’s the same Claude Code underneath — the desktop app just wraps it in a friendlier window.

• One app, two modes — switch between plain chat and agentic coding without leaving the window.
• No command line to fear — panels and buttons instead of memorized commands.
• Identical capabilities — same model, same files, same slash-commands and skills as the terminal.
• Anything you see in a terminal demo works exactly the same in the app.

Pick the window you like — the brains are identical.

The loop: how vibe coding actually works

1. Describe the goal + context (data, language, constraints).
2. The AI proposes code.
3. Run it — locally or inside the tool.
4. Inspect the result — numbers, plots, errors.
5. Refine in plain language: “dates are off — parse as YYYY-MM.”
6. Repeat until correct, then lock it in.

Tight loops beat long prompts. Small steps, check often.

Anatomy of a good prompt

• Context — what the data is, what tools you use.
• Goal — the specific outcome you want.
• Constraints — language, packages, conventions.
• Format — how you want the answer back.

Context + goal + constraints + format. Vague in → vague out.

Why skills matter

A skill turns a repeatable task into a one-word command — write the instructions once, reuse them forever.

• Consistency — your standards, applied the same way every time.
• No re-explaining — stop re-pasting the same instructions into chat.
• Cheap — a skill loads only when it’s used, so it barely touches context until you need it.
• Auto-invoked — Claude picks the right skill from its description; you don’t have to remember.
• Shareable — hand the same capability to coauthors and students.

Rule of thumb: if you’ve typed it twice, make it a skill.

Skills in the wild

Some you get for free; some you build.

Type / in Claude to see every skill available to you.

Start with the built-ins; roll your own when you spot a pattern.

Trust, but verify

AI is confident even when it’s wrong. For research, verification is your job — and it’s non-negotiable.

• Hallucinated citations — check every reference exists and says what's claimed.
• Plausible-but-wrong code — eyeball outputs; run sanity checks.
• Silent data errors — print N, ranges, missingness at each step.
• Version control everything (git) so you can see exactly what changed.

Treat the AI as a fast, brilliant, slightly unreliable RA.

Hands-on: your first task

Live demo — from a raw file to a result, by conversation.

1. Drop a messy CSV into Claude.
2. “Clean it, and describe exactly what you changed.”
3. “Plot the time series of the average return.”
4. Spot a problem → fix it by conversation.
5. Export the script so it’s reproducible.

Follow along — bring a dataset you know well.

What you can already do

• Define a research task clearly.
• Pick the right tool for it.
• Run the loop: describe → run → inspect → refine.
• Verify outputs instead of trusting them.
• Keep the whole thing reproducible.

Next hour: plug this into the real research pipeline.

Where AI plugs into your pipeline

AI touches every stage — but you own the design and the checks.

Literature review at scale

• Point an agent at a folder of PDFs → get a structured comparison table.
• OCR older scans into clean text you can search and quote.
• Chase a citation to its source — the agent opens the paper and quotes the page.
• Summarize, cluster, and contrast methods across a whole reading list.

Speed is the easy part — verifying the table is the real work.

Data wrangling

• Merge messy sources; reshape long ↔ wide.
• Fuzzy-match firm or person names.
• Parse dates, units, and currencies consistently.
• Build a clean panel — with every transformation logged.

The tedious 80% — done in minutes, fully documented.

Analysis & replication

• Run a result across many specifications at once.
• Generate robustness and sensitivity tables.
• Replicate a published result from its description.
• Translate code across Stata ↔ R ↔ Python.
• Explain unfamiliar code you inherited.

Ideal for replication packages and referee robustness asks.

Figures & tables

• Publication-quality plots from a description.
• Match a journal’s house style.
• Generate LaTeX booktabs tables straight from results.
• Iterate on aesthetics by talking, not tweaking by hand.

“Make it look like the figures on my website.” — and it can.

Writing & LaTeX

• Draft and tighten prose; cut 800 words to 500.
• Build LaTeX scaffolding; fix cryptic compile errors.
• Draft referee-response letters point by point.
• Translate and clarify — but never let it invent citations.

Your voice and your claims; its speed and its syntax.

Workflow automation

Move from chatting to agents that do multi-step work on your files.

• Claude Code reads and edits a whole project.
• Chain steps: clean → estimate → tabulate → compile.
• Batch the same task over hundreds of files.
• Schedule recurring jobs; save reusable scripts.

Automate the boring 80%; spend your time on the 20% that’s economics.

No git? Use the copy-folder trick.

You don’t need to learn version control to work safely. This is “manual git” — and it’s enough to start.

1. Before you start, duplicate your project folder (paper/ → paper-backup/).
2. Work as normal — let the AI change files.
3. Happy with the result? Delete the backup. Done.
4. Not happy? Delete the working copy and restore the backup.

Date your copies — paper-2026-06-02 — so you can keep a few. Five minutes, total peace of mind.

When you’re ready, real git just automates exactly this.

Stop clicking “allow”

By default, Claude Code asks before it edits a file or runs a command. Safe — but click-heavy once you trust it.

• Shift+Tab cycles modes: normal → auto-accept edits → plan.
• /permissions pre-approves the safe commands you use a lot.
• Full speed: launch with --dangerously-skip-permissions to skip every prompt.

⚠ Only skip permissions on a throwaway copy or sandbox — never with sensitive data or untrusted content.

Made a copy? Let it run free, then review the result — not every step.

Context is the model’s working memory

Everything shares one window — the system prompt, your CLAUDE.md, every file read, every tool output, and the whole chat so far.

• It’s finite. Fill it and older details get pushed out or summarized away.
• It hurts quality. A bloated context makes answers slower, pricier, and less accurate — the model attends less reliably to any one fact.
• Auto-compact kicks in near the limit — helpful, but summarizing can drop the detail you cared about.
• So treat context as precious: load what’s relevant, not everything.

Inspect with /context · summarize with /compact · reset with /clear.

A lean, focused context isn’t just cheaper — it gives better answers.

Make your usage last

Long conversations cost more, slow down, and drift. A few habits keep you fast and lean.

• /clear — start a fresh chat for each new task (project memory is kept).
• /compact — squeeze a long chat to free space, same task.
• /context — see what’s filling the window.
• /model — drop to a smaller model for simple jobs.
• Point at specific files, not the whole repo.

One task per conversation. /clear early, /clear often.

Use many agents, not one big chat

Each agent runs in its own fresh context — so split a big job across several instead of cramming it into one.

• One agent reading 10 papers runs out of room by paper six. Ten agents — one per paper — each stay sharp.
• Each returns just its result; your main context stays clean.
• Run them in parallel → faster, and no single context overflows.
• An orchestrator agent dispatches the others and merges their findings.

Divide the work, divide the context — one focused agent per job.

Build your own econ commands

A “skill” turns a prompt you reuse into a one-word command. Type /econ-write and it runs your saved instructions.

Make one: a SKILL.md in ~/.claude/skills/econ-write/ — a short description plus your instructions. You add yours; I can scaffold more.

Your best prompts, saved once and shared with your students.

Reproducibility & documentation

This is exactly what the AFA session asks you to capture.

• Keep your conversation transcripts (including initial prompts).
• Log time spent and document human contributions.
• Track line-contribution % — what was AI, what was you.
• Commit code and prompts to git; a README that regenerates everything.

Reproducibility isn’t bureaucracy — it’s the new credibility.

Pitfalls & best practices

Speed without verification is just faster mistakes.

Ethics & disclosure

• Know each journal’s AI policy before you submit.
• Disclose AI use honestly — the AFA session requires it.
• You are accountable for every result and every citation.
• AI is a tool, not a co-author.
• Protect confidential data and referee material.

Disclosure builds trust; concealment destroys it.

Hands-on: build a mini pipeline

1. Pick a dataset you care about.
2. Clean it → run one regression → make one figure → output one LaTeX table.
3. Wrap it into a single script you can re-run.
4. Save the prompts alongside the code.

Goal: one reproducible artifact you actually keep.

Turn your notes into a knowledge vault

Obsidian stores everything as plain Markdown (.md) in a local folder — exactly what Claude reads and writes best.

• Your whole vault is plain text → Claude reads, searches, and edits all of it directly — no export, no API.
• Notes link to notes ([[wiki-links]]) → a graph of ideas that compounds as it grows.
• Local and yours — private, portable, future-proof.

A folder of PDFs isn’t a system — linked Markdown is.

Obsidian + Claude: the workflow

1. Install Obsidian — a vault is just a folder of .md files.
2. Point Claude Code at that folder — open it as your project.
3. “Read this paper; write a note with the key claims and [[link]] it to related notes.”
4. Ask across everything: “What do my notes say about X?” — Claude reads the whole vault.
5. Let it surface connections and gaps you missed.

Free for personal use · obsidian.md · your vault stays on your machine.

Capture once; let Claude connect, retrieve, and grow it.

Three rules, whatever the tool

Verify · Version · Attribute — the whole course in three words.

Recap & where to go next

Start with one real task this week. That’s the whole secret.