AI Tools Lab — working with coding LLMs

Why this page exists

At the build stage of your project you'll generate a real financial model from your own spec — and the quality of that session is decided before you type your first prompt, by two choices: which surface you use (web chat, desktop app, or a terminal agent) and how much of your project the AI can actually see. Most students get both wrong in the same way: they open a blank chat window and start typing from memory. This guide fixes that.

Nothing here is course-specific. The examples lean on the FX hedging project because its Stage 3 links here as required reading, but every rule applies unchanged to ratio models, policy analyses, and anything else you'll build.

Chat vs code — the harness idea

Claude and ChatGPT each come in two fundamentally different forms, and the split matters more than which vendor you pick. The chat form is the familiar one: a text box, a conversation, answers. The "code" form runs the same AI model inside a harness — a program that wraps the model and gives it tools: it can read your files, run commands, edit documents, and execute Git operations, each action shown to you for approval before it happens.

Both vendors ship one: Claude Code (Anthropic) runs in your terminal and works on the files in front of it; Codex (OpenAI) connects to your GitHub repos and runs tasks in a cloud sandbox, opening pull requests with the results. Plans, pricing, and free-tier limits for all of these change often — check claude.ai and openai.com for what's current rather than trusting anything printed in a slide or on this page.

The three surfaces

Start on the web, graduate to the CLI. That's not a compromise — it's the sequence. The web surface teaches you how the model thinks and what a good prompt looks like with zero setup cost. The CLI is where the compounding returns are, once the basics are boring.

The headline: give the AI your repo

Here is the single biggest upgrade available to you, and it costs nothing: stop describing your project and start showing it. An LLM that can see your committed spec, your workbook, your prompt log, and your directory structure stops guessing about conventions and starts checking against them. The difference in output quality is not subtle.

There's a ranking, and it's the same one your build stage grades you on (Stage 3 spells it out for FX hedging):

Handing a spec to an AI — the three routes

In every build stage you write a specification first and an AI builds the artifact from it. The rule that matters more than the choice of tool: the spec goes in as-is. If you find yourself re-explaining the model in the chat, that is a spec defect — add the explanation to the spec, commit it, and regenerate.

Build the workbook described in capabilities/marginal-analysis/spec.md.

Follow the validation rules in that file exactly — they are acceptance criteria,
not suggestions. Every calculated cell must contain a formula referencing the
named inputs, never a pasted value.

If any input, convention, or formula in the spec is ambiguous or missing, STOP
and ask me rather than choosing for me. Do not infer a value I did not state.

When you are done, list which validation rules you verified and which you could
not check.

Whichever route you take, the output is a draft. Audit it against your own validation rules before you commit it, and record what you checked. A model cannot tell you its own output is correct, and asking it to is the most common way people end up trusting a wrong workbook.

When the AI says it can't commit

You connect your repo to a chat window, ask "can you see my repo?", get a confident yes — and then ask it to commit your memo and it declines. This is the most common tooling wall students hit, it costs people an hour, and the fix takes thirty seconds once you know what you're looking at.

Both vendors ship two different GitHub connections, and they are not tiers of the same product. They look almost identical while you're setting them up:

That's the whole explanation for the most common version of this. But three different problems produce the same complaint, and you can't tell them apart from the symptom — so match yours before you start fixing anything:

If you do want the AI doing the committing, that's the CLI agent row of the table above, and the routes section covers handing it your work. Two things to expect: a coding tool may land your work as a pull request — a proposed change you click once more to merge — so if the file doesn't appear immediately, that's not a failure; and these tools live in their own place in the app rather than in the model dropdown next to the message box, which is where most people look first. Vendors move their menus constantly, so trust the vendor's current docs over any path written here.

Claude Code in 10 minutes

The fastest route from "never touched a terminal" to an AI working inside your repo. You already have a terminal if you installed Git — Git Bash on Windows, Terminal on Mac.

1. Install Node.js (version 18 or newer) from nodejs.org.
2. Install Claude Code — one command, once:

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

3. Navigate to your repo and launch. The launch folder matters — start it inside the repo so it can see your project:

   cd path/to/your-repo
   claude

   First launch prompts you to sign in with your Anthropic account.
4. Ask in plain English. No special syntax. It reads your files and responds; anything that changes a file or runs a command waits for your approval.

Power moves worth stealing

Once "explain this file" feels routine, these are the prompts that earn the setup time — written here for the FX hedging project, but the pattern transfers to any build stage:

• Contract check: "Check my workbook against my spec's named-range contract — list any range that's missing, misnamed, or attached to the wrong cell."
• Spec audit: "Compare my Stage 2 spec against the stage brief and tell me which required sections are thin or missing."
• Git without leaving: "Draft a commit message for my Stage 3 build and push it to GitHub."
• Log hygiene: "Read my prompt-log.md and flag any entry missing a used / modified / rejected verdict."

Notice what these have in common: each one asks the AI to check your work against a committed artifact — spec vs workbook, spec vs brief, log vs its required format. That's what the harness buys you that no chat window can.

Prompt patterns that work

Four habits separate prompts that produce deliverable-quality output from prompts that produce plausible-looking filler. Each works on every surface, from a free web chat to a CLI agent.

One more habit worth forming: the figures above are the FX Hedging Lab's sample scenario, so you can run the same inputs there and grade the AI's answer yourself. Whenever a lab mirrors your model, it's a free answer key for exactly this kind of check.

Vendor balance & hygiene

Claude or ChatGPT? Yes. Both are welcome in every course here, both have free tiers that are enough to do the work, and their relative strengths leapfrog every few months — which is exactly why this page won't tell you one is better. What's graded is your spec, your audit, and your judgment; the tool is interchangeable. Pick one, learn it well, and check the vendor's own site for current models and plans.

• Verify, don't trust. AI produces plausible-sounding errors: subtly wrong formulas, invented financial data, a sign flipped in an option payoff. Cross-check every number that matters against your textbook, your spec's validation checks, or the filing it supposedly came from. Your build stage requires a written audit for precisely this reason.
• Never paste sensitive personal data. Course materials and public financial data are fine; your ID numbers, other people's information, and anything you wouldn't put in a public repo are not.
• Log every meaningful interaction in prompt-log.md. This is graded. For each entry: the prompt you used, the key output, and your verdict — used, modified, or rejected. The log is your evidence that the AI was your analyst and not your ghostwriter; your project's stage pages spell out the format.

Check yourself