# Claude Code — first 30 minutes

You already use Claude.ai. Claude Code is the same Claude, running in your
terminal, with access to your files. The thing that makes it useful for
you isn't "writing apps" — it's **improving the tools you already have**
one small change at a time.

This guide gets you from zero to productive in 30 minutes. No CS degree
required.

## Install (5 min)

1. Open Terminal (Cmd+Space → "Terminal")
2. Paste:
   ```bash
   curl -fsSL https://claude.ai/install.sh | sh
   ```
3. Run `claude` once. Sign in with the same account you use for Claude.ai.

You're done. Same Pro subscription. Same Claude. New surface.

## Set up your tools folder (5 min)

Make one folder where every tool lives:

```bash
mkdir -p ~/film-tools
cd ~/film-tools
```

Drop all the kit scripts here:
- `bridge.py`
- `cull.py`
- `cutdowns.py`
- `filmkit.py`
- `ingest.py`

Plus the `playbooks/` folder for reference.

Now open Claude Code from that folder:

```bash
cd ~/film-tools
claude
```

It boots with full awareness of your tools. You can ask things like
"explain how cull.py works" or "add a --silent flag to bridge.py" and
Claude knows what you mean.

## The 10 copy-paste tasks

These are the tasks you should actually try in week one. They teach the
shape of useful Claude Code work without requiring you to learn Python.

Paste any of these into Claude Code as your first message:

### 1. Add a feature to a tool
```
Add a --dry-run flag to cutdowns.py that prints the ffmpeg commands it
would run without actually rendering anything. Keep the existing behavior
unchanged.
```

### 2. Make output friendlier
```
Modify cull.py's report so the table is sorted by duration descending
within each severity tier. Add a column showing the average frame rate.
```

### 3. Wrap an ffmpeg one-liner
```
Take this ffmpeg command and turn it into a Python script called
proxy.py that takes a folder and renders ProRes Proxy 422 LT versions
of every .mov inside it: `ffmpeg -i in.mov -c:v prores_ks -profile:v 0
-vendor apl0 -pix_fmt yuv422p10le -c:a copy out.mov`
```

### 4. Build a simple opener
```
Create a Mac shell script called open-latest that opens the most
recently modified Resolve project (.drp file) from ~/Footage. Make it
executable.
```

### 5. Diagnose an error
```
I ran this and got this error: [paste exact terminal output]. What's
going on, and what's the simplest fix?
```

### 6. Add a default
```
Make filmkit.py default the --root parameter to a path stored in
~/.filmkit-root if that file exists, falling back to ~/Footage if not.
```

### 7. Generate a fixture
```
Create a sample-doc-outline.md in claude-pack/ that matches the Bridge
format and is at least 8 beats long. Use a story about a coffee farmer.
This is for me to test Bridge with.
```

### 8. Refactor for readability
```
Read cutdowns.py. Suggest 3 small changes that would make it easier to
maintain. Show me each change as a diff. Don't apply anything yet.
```

### 9. Convert a format
```
Take any JSON file matching this shape: {"cuts": [{"start": "...", "end":
"...", "label": "..."}]} and convert it to the markdown format
cutdowns.py expects.
```

### 10. Make a script double-clickable
```
Wrap bridge.py so I can double-click a .command file in Finder and it
prompts me for the outline file via macOS dialog, then runs the bridge
with sensible defaults.
```

## The rule that keeps you out of trouble

**Never ask Claude Code to "make an app".** Ask it to improve one
command that already works.

Big asks lead to slop. Small asks lead to compounding improvements that
ship every day. Your tools will get better in 30-minute sessions, not
weekend marathons.

## When something breaks

Paste the exact error message. Claude Code will fix it 90% of the time.

If you find yourself in a hole:
```
Roll back your changes to bridge.py and explain what I asked that
caused this. Don't fix it yet.
```

`git status` and `git diff` show what changed since the last good state.
Even if you don't know git, Claude Code does.

## When you outgrow this

After two weeks of small wins, you'll have your own personal toolchain
that matches exactly how you work. At that point, ask:

> *"Look at all the tools in this folder. Suggest three workflows we
> haven't built yet that would compress my editing time the most.
> Rank by impact."*

That's how the kit grows.