A Week with Claude Code: A Field Manual

Field manual · 7 days · terminal, not chat

You were right about one thing: a chat window you type questions into isn’t a revolution. That’s why this week looks different. You get an agent in the terminal — it reads your files, runs commands, tests its own code, and fixes it until it works. You decide what it’s allowed to do. The plan: from zero to your own orchestra of models — with subagents, skills, and schedules — in seven days, a few dozen minutes each.

~/any-folder                                    claude · session 1

$ claude
> take a look at this folder and tell me what's here
● Reading the structure… 14 files, 3 directories
● Opening README.md, package.json…
It's a Node.js project. Main logic lives in src/,
no tests, and there's a "deploy.sh" in the scripts
nobody's run since 2023. Where do we start?

D0 — Installation · 15 minutes

Before You Start Complaining, Install It

Claude Code is a terminal program. Official installer, one line:

# macOS / Linux / WSL
$ curl -fsSL https://claude.ai/install.sh | bash

# Windows (PowerShell)
PS> irm https://claude.ai/install.ps1 | iex

# check + update (you'll need this in D4)
$ claude --version
$ claude update

Then go into any folder — a project, a directory of invoices, whatever — and type claude. On first run it’ll log you in through the browser and remember you.

Formality. Claude Code requires a paid plan (Pro/Max/Team) or API credits — a free account won’t cut it. Your week of access takes care of that — claim it here while it’s available — log in and go.

Strongly recommended — do this right away. Still in this same session, install the superpowers plugin: /plugin install superpowers@claude-plugins-official. It’s a set of battle-tested work habits — Claude asks questions and plans first, debugs systematically instead of guessing, writes tests before code. You’ll feel the difference from the first task.

Within a session: /help shows commands, /resume goes back to an earlier conversation, Esc interrupts Claude mid-move. That’s everything you need for today.

D1 — Trust · rules of the game

Let It Look First, Not Touch

Day one exists so you see the mechanics before you risk anything. Claude Code asks for consent before every file change and before any command you haven’t approved. It can read on its own — it only writes once you let it. Every proposal shows up as a diff: you approve it, reject it, or tell it to do it differently.

Warm-up tasks, all safe:

“look through this folder and tell me what’s here” — in a directory of code or a mess of old projects,
“explain to me line by line what this script does” — on something you inherited and haven’t touched out of fear,
“clean up my Downloads: propose a folder structure and show me the plan before you move anything.”

At the end of the day, in the folder you’ll be working in, run /init. Claude will look over the project and generate a CLAUDE.md — a context file it’ll read at the start of every session. Review it and cut the obvious stuff: a short CLAUDE.md means a faster, cheaper Claude.

D2 — Recon · what to automate

Don’t Go Hunting Yourself. Make It Find Things

The classic mistake: a person sits down and thinks “what could I automate here.” Flip it. Describe your ordinary week to Claude — brutally specific — and let it point out the candidates:

~/work                                                    claude

> I'll describe my typical work week to you. [dump everything
  here: reports, copying data between files, renaming things,
  status updates, emails with attachments, manually checking
  logs] List the tasks that: I repeat more than once a week,
  I do from a fixed checklist, or that involve moving data
  from place A to place B. For each one, judge whether it's
  a job for a plain script or for an agent with a brain.

You’ll get a list. The rule for picking your first victim: boring + frequent + low-risk. Don’t start with anything that touches production, money, or someone else’s data. Pick one thing — tomorrow we break it.

The distinction that’ll save you money. If a task is 100% predictable (same steps, zero decisions) — that’s a job for a plain script, which Claude writes once and then runs for free forever after. Bring in an agent where something along the way needs judging, interpreting, or deciding. This line comes back in D7.

D3 — The loop · the “aha” moment

It Writes, Runs, Reads the Error, Fixes It

Today you’ll see a difference you can’t demonstrate in free ChatGPT. There, you get code, copy it, run it, paste the error back, get a fix, copy again… You are the loop. Here, the loop happens without you:

~/work                                                    claude

> Write a script that does [yesterday's pick].
  Show me the plan first. Once I approve it: write it,
  run it on sample data, and fix it until it works.
● Plan: 1) parse input 2) validate 3) save…
● Writing report.py… running it… ✗ KeyError: 'date'
● I see the problem — the column's called 'Date', not 'date'. Fixing…
● Running again… ✓ 3 files processed
Done. The script also handles files without a header —
I found two of those in your data.

Two habits that change everything:

“Show me the plan first.” For bigger things, make it plan before writing (there’s even a planning mode for this). You catch bad assumptions cheaply, before they turn into code.
Define “done.” Not “write a script,” but “…and don’t call it finished until it passes on these three sample files.” An agent with a success criterion checks itself.

D4 — Models and effort · the cost engine

There’s No Such Thing as “The AI.” There’s a Price List of Brains

Up to now you’ve been running on the default model. Time to meet the whole garage, because starting tomorrow you’ll be juggling them. The /model command shows your options:

Model	What it’s for	Cost / rate-limit burn
Fable 5	the heaviest, hours-long tasks; architecture, hard debugging, reviewing someone else’s work	most expensive, burns limits ~2× faster than Opus
Opus 4.8	your everyday flagship for complex work	expensive
Sonnet 5	routine work, a solid middle ground	moderate
Haiku 4.5	fast, mechanical, high-volume	cheap and instant

Switching: /model fable, /model opus, /model haiku… The /model best alias picks the strongest model available on your account (Fable 5, or if you don’t have that — the latest Opus). There’s also the opusplan hybrid: Opus thinks in planning mode, Sonnet executes.

Effort — the thinking-depth dial

The second slider is /effort (levels from low to max). Higher effort = the model reasons longer before answering = better decisions and a bigger bill. On Fable 5 you can’t turn thinking off — you only control how deep it goes.

The wallet rule. Pay for thinking, not for retyping. The most expensive model with high effort goes where decisions get made. Cheap models go where it’s mechanical. Tomorrow we turn this into a system.

Trap. Fable 5 has safety classifiers (cyber/bio) and can switch a session over to Opus 4.8 on its own, sometimes over perfectly innocent code. If the status line shows a different model than the one you picked — that’s this. Switch back with /model fable. It also needs Claude Code ≥ 2.1.170, hence claude update back in D0.

D5 — Subagents · orchestration

One Architect, Cheap Labor

A subagent is a separate, specialized instance of Claude that your main session spins up for a specific job. It has its own context window, its own tool permissions, and — most importantly — its own model. It does its thing, comes back with a concise result, and its mess (files it searched, logs, dead ends) doesn’t clutter your main conversation.

This opens up the pattern this whole week stands on:

The pattern: architect + workers. The main session runs on the strongest available model (/model best) at high effort — it understands the problem, plans, delegates, and evaluates the results. Execution goes to subagents pinned to cheaper models: research on Sonnet, mechanical work on Haiku. The expensive model generates the fewest tokens (decisions), the cheap ones generate the most (code, searching). Quality stays, the bill drops.

Creating them: don’t write the files, delegate it

A subagent is a Markdown file with a YAML header in .claude/agents/ (project-scoped) or ~/.claude/agents/ (yours, everywhere). But the simplest thing is to just ask Claude to write it itself:

~/work                                        claude · /model best

> Create me two subagents:
  1) "researcher" — searches the code and the web, changes
     nothing, returns a concise summary with sources.
     Model: sonnet.
  2) "grunt-work" — carries out mechanical, well-specified
     tasks: formatting, renaming, simple scripts.
     Model: haiku.
● Creating .claude/agents/researcher.md…
● Creating .claude/agents/grunt-work.md…

The generated file looks roughly like this — and you can edit it however you like (changes are picked up live, no restart needed):

.claude/agents/researcher.md                       yaml + markdown

---
name: researcher
description: Searches for information in the code and on the
  web, returns a concise summary with sources. Use proactively
  when something needs investigating before a change.
tools: Read, Grep, Glob, WebSearch, WebFetch
model: sonnet
---
You are the researcher. You don't change files. You gather
facts, cite paths and sources, and finish with a summary
of at most 10 bullet points plus a recommendation.

The description field isn’t documentation, it’s a trigger — the main session uses it to decide on its own whether to delegate (the phrase “use proactively” emboldens it to). You can also force it manually: mention the agent with @ (“have @researcher check…”), and the --agent name flag sets it for the whole session.

A Day in Conductor Mode

~/work                            claude · /model best · /effort high

> Goal: [the automation you picked in D2, the real version].
  Before you start: delegate research to @researcher (how
  this is done today, what could break). Then give me
  a plan. Hand the mechanical implementation to @grunt-work.
  You supervise the whole thing and do a review at the end.

Trap. The order for resolving a subagent’s model: the CLAUDE_CODE_SUBAGENT_MODEL variable → the call parameter → the agent file’s model: → the session’s model. If the pinned model isn’t available on your account, Claude Code silently falls back to the session model — nothing warns you. When results look suspiciously expensive or suspiciously weak, check the transcript for who actually did the work.

And to be fair: a subagent has overhead (it starts with a clean context, results come back as a digest). It’s not worth it for two-minute tasks. Use it when the work is loud (lots of reading/attempts) or parallel (several independent threads at once).

D6 — Skills · procedural memory

Stop Explaining the Same Thing a Third Time

A skill is a folder with a SKILL.md file: a written-down procedure, convention, or piece of knowledge that Claude loads only when a task calls for it. Day to day it costs ~100 tokens (just the description in the table of contents), so you can have dozens of them without slowing anything down. Keep personal ones in ~/.claude/skills/, project ones in .claude/skills/ — the latter you commit to the repo and the whole team gets them automatically.

Don’t Write Skills. Distill Them From the Work

The best moment for a skill is right after you’ve finished something that’s going to come back. Then, one sentence:

~/work                                                    claude

> Save what we just did (the steps, the order, what to
  watch out for) as a skill called "weekly-report"
  in ~/.claude/skills/. Word the description so the skill
  triggers on: report, weekly summary.
● Creating ~/.claude/skills/weekly-report/SKILL.md…

~/.claude/skills/weekly-report/SKILL.md             yaml + markdown

---
name: weekly-report
description: Builds a weekly report from files in ~/reports.
  Use when "report," "weekly summary" comes up, or when
  results from the last 7 days need to be pulled together.
---
1. Collect files from ~/reports modified in the last 7 days.
2. For numbers, use scripts/count.py — don't do math "in your head."
3. Output format: header, 3 takeaways, table, anomalies.
4. Save to summary-YYYY-MM-DD.md and show the diff against
   last week.

Three things that decide whether a skill works at all:

The description is the trigger. A vague description = a skill that never fires. Write into it the words you actually use in your prompts.
Pack deterministic steps into scripts. A skill can contain a scripts/ directory — let code do the counting, sorting, and conversions, not the model. Cheaper and repeatable.
You can call it manually: /weekly-report works like your own command.

For inspiration: the official anthropics/skills repo on GitHub — ready-made skills for documents, testing, and creating… more skills (skill-creator). But start by distilling your own work, not from someone else’s library.

D7 — Automation · schedules and loops

Things That Happen Without You

The finale. Everything you’ve built can run without an open terminal. Headless mode: claude -p "task" executes the instruction and finishes — perfect for schedules.

# crontab -e                                        cron · Linux/macOS

# Monday 8:00 — report generates itself (one line!)
0 8 * * 1  cd ~/work && claude -p "Use the weekly-report skill and save the output to ~/reports/out/"

# daily 7:30 — the deterministic script from D3:
# zero Claude, zero tokens
30 7 * * *  ~/work/scripts/cleanup.sh

On Windows, Task Scheduler does the same thing. Notice the D2 split in action: whatever’s deterministic — a plain script in cron, for free; whatever needs judgment — claude -p, ideally with a skill, so it follows the same procedure every time.

The principle of limited trust. A cron job doesn’t have you standing next to it to click “no.” Start with read-only tasks (reports, summaries, alerts to a file). Only grant write access to something that’s run flawlessly for a week — and point the output at a separate directory, never at live data.

And loops during the day? You leave the agent with a goal and a stop condition — “fix the tests in this module and finish when they all pass” — and go get coffee. It’s the same loop from D3, just longer, and on your terms.

Routing board · decisions

What Goes Where

After a week you’ve got five drawers. Recognize them by the symptom, not by fashion:

Symptom	Mechanism	Why
a project fact needed in every conversation (“we build via `make build`”)	CLAUDE.md	read every time — which is why it has to stay short
a procedure/checklist you paste or dictate one more time	Skill	loaded on demand, nearly free at rest
a recurring type of task: loud research, mechanical grunt work, work on a different model	Subagent	isolates context and lets you pin a cheaper model
100% predictable steps, zero decisions along the way	script + cron	written once by Claude, then runs for free
a rule that MUST run every time (e.g. formatting after every edit)	Hook	enforced by the program, not by the model’s memory — a topic for a second week
a one-off thing	plain prompt	don’t build infrastructure for something that won’t come back

Cheat sheet

Ten Things at Your Fingertips

Command	What it does
`claude`	starts a session in the current folder
`claude -p "task"`	headless mode — execute and exit (cron)
`claude update`	update (Fable 5 needs ≥ 2.1.170)
`/model best · fable · haiku`	model selection; “best” = strongest available
`/effort low…max`	thinking depth — and the bill
`/init`	generates CLAUDE.md with project context
`/agents`	review your subagents; create new ones by asking Claude
`@agent-name`	force delegation to a specific subagent
`/skill-name`	manually fire a skill like your own command
`/resume · Esc · /help`	go back to a conversation · interrupt · command list

How I know this. Everything verified against the official Claude Code documentation (July 2026):

Quickstart · Models and configuration
Subagents · Skills
anthropics/skills — the official repo of example skills

Prepared by Bart with Claude’s help. You’ve got a week of access — the clock’s started.