This guide exists because a sharp student looked at an AI-built job-search system and asked four perfect questions: Which AI made this? Where did the data come from? Was the intent predefined? And how do you even prompt it?

Those four questions are the best possible starting line, because they cover the entire territory: the tool, the data, the logic, and the language you use to command it. This manual answers all four in the first six pages — then spends 124 more turning you from a curious reader into someone who can build things that make people ask "wait, who made this for you?"

Who this is for

How the guide works

• One page at a time. Use the sidebar, the Next/Previous buttons, or your keyboard ← → arrows.
• Your progress is saved in this browser automatically. Close it, come back next week — it remembers where you were and shows ✓ on every page you've read.
• Level badges on every page: BASIC INTERMEDIATE ADVANCED ELITE. Nothing advanced is required to enjoy the basics.
• Copy buttons on every prompt — click, paste into Claude, watch it work.
• Honesty labels on factual claims: ✅ verified · 📊 calculated · ⚠️ estimate / changes over time — always re-check prices and limits on official pages, because AI products update monthly.

Question 1: "Which AI tool or LLM was used to make this?"

Short answer: Claude, made by Anthropic — used in two different forms, plus a few non-AI tools doing the boring jobs.

The exact toolchain behind the job-hunt cockpit

So what exactly is an "LLM"?

LLM = Large Language Model. It is a computer program trained by reading a gigantic amount of text — books, articles, code, conversations — until it becomes extraordinarily good at one deceptively simple skill: predicting what text should come next. Ask it a question, and "what comes next" is a good answer. Describe a website, and "what comes next" is the code for that website. That one skill, scaled up massively, is what looks like intelligence. (Full explanation with zero jargon: page 7.)

Chat vs. Claude Code — the difference that matters

Question 2: "Where is the hiring people's email data fetched from?"

Brilliant question — because AI does not magically know anyone's email address. The honest answer is a pipeline: several boring, legitimate steps chained together. Here is exactly how professional contact data is gathered in systems like the cockpit:

The ethics layer (this part matters)

Question 3: "Is the intent predefined?"

This is the most sophisticated of the four questions, and the answer teaches you how all serious AI systems are built. The answer is: the strategy is predefined in code; the wording is AI-generated within strict rails. Two layers, working together:

Layer 1 — The rails (predefined, written as Python rules, never improvised)

Layer 2 — The generation (AI, within those rails)

Inside the rails, Claude wrote each message's actual wording — personalized using the verified facts collected in step 3 of the data pipeline: the person's real role, their company's real projects. So every email is individually written, but no email can break the strategy.

Question 4: "What prompt do we give, and how?"

A prompt is simply your instruction to the AI, written in normal language. There is no secret syntax. But there is an enormous difference between a weak prompt and a strong one — and it comes down to one idea: a prompt is a brief, not a wish. You are briefing a brilliant new employee who knows nothing about your situation.

The 5-part anatomy of a strong prompt

A real prompt in the cockpit's style

You are a senior career strategist. Context: a Project Director with 34 years
in power transmission (utility + consultancy sides) is quietly job-hunting in
the Gulf. Task: write a first-contact email to a Programs Director at a large
utility, introducing him for senior project leadership roles. Format: subject
line (max 65 characters) + 110-130 word body + one-line PS. Constraints:
respectful peer-to-peer tone, zero flattery, zero exaggeration, mention ONE
specific credibility fact, end with a soft ask ("open to a brief call").

Starter prompts for a student (copy any of these)

Explain [topic] like I'm 14, in 5 short points, then quiz me with 3 questions
one at a time. Wait for my answer before revealing the next.

Here is my essay draft: [paste]. Don't rewrite it. Give me the 5 highest-impact
improvements ranked, each with the exact sentence to change and why.

I want to build [idea] for my school project. Interview me: ask me 5 questions
one by one to sharpen the idea, THEN give me a plan with materials and steps.

The 10-Minute Quick Start

Theory later. Right now, get your hands on it. Ten minutes, five moves, and you'll understand more than most people who've "heard about AI" for two years.

What a Large Language Model Actually Is

Strip away the hype and an LLM is one idea executed at planetary scale: a prediction machine for text.

The three stages, no jargon

Why "just predicting text" feels like intelligence

Because to predict text well, you must model the world that produced the text. To continue "The engineer calculated the cable sag because…" you need physics. To continue a chess game's notation you need chess. Prediction at sufficient depth forces understanding-like behavior. Whether it "really understands" is a philosophy debate; what matters practically is that it behaves like a tireless, widely-read collaborator.

What it fundamentally cannot do (unless given tools)

The Context Window — Claude's Working Memory

The context window is everything the model can "see" right now: your messages, its replies, uploaded files, instructions. Think of it as a desk: enormous, but finite. Claude's desk holds about 200,000 tokens ⚠️ (some versions offer 1 million in beta) — roughly 500 pages of text. ⚠️ figures change; the principle doesn't.

The consequences you'll actually feel

The three memory layers (the mental model that unlocks everything)

Anthropic — The Company Behind Claude

Knowing who builds your tools tells you what to expect from them. Claude is made by Anthropic, an AI safety company headquartered in San Francisco.

The story in five beats ⚠️ (as of this guide's writing)

Why the safety-first origin matters to YOU practically

• Fewer fabrications, more "I'm not sure" — the honesty tuning is real and noticeable in daily work.
• Refusals are principled, not random — it declines harmful requests but helps with legitimate dual-use work (security testing, medical information) when context is clear.
• Enterprise trust — the same properties that protect users make it deployable in banks, hospitals, law firms — and in your business.

The Model Family — Which Claude Is Which

"Claude" is a family. The tiers are named like poetry sizes — small, medium, large — and choosing the right one is a real skill (and a real cost lever, p61/p68).

The tiers ⚠️ (as of mid-2026 — the lineup evolves; check claude.com)

Practical selection rules

• Default to the best model you can afford for thinking-heavy work — a better first draft saves three rounds of fixes. Quality compounds.
• Downshift for volume — when the task is "do this simple thing 5,000 times", Haiku-class models at a fraction of the cost win (batch tricks: p68).
• Extended thinking (p33) matters as much as tier for hard logic — a Sonnet thinking carefully often beats an Opus answering instantly.
• In the apps you pick from a model menu; in the API you use exact IDs like claude-sonnet-5 or claude-haiku-4-5 ⚠️.

Claude vs ChatGPT vs Gemini (and "GPTs") — The Honest Comparison

You'll be asked this at every family dinner. Here's the fair answer from someone who uses them all — no fanboy talk. ⚠️ Capabilities shift monthly; the shapes below have been stable.

"What are GPTs?" (the daughter's word — decoded)

Custom GPTs are ChatGPT's mini configured chatbots: someone packages instructions + files + a name ("CV Fixer", "Math Tutor") and shares it in a store. Claude's equivalents are Projects (p20 — private configured workspaces), Skills (p51 — packaged expertise Claude auto-loads), and Artifacts you can share (p19). Same idea — reusable, pre-briefed AI — different packaging.

The founder's actual answer

The Seven Places Claude Lives

Same brain, seven bodies. Knowing which surface to use for which job is an instant productivity doubler (full decision guide: p70).

Plans, Pricing & How Limits Actually Work

Subscription plans (the apps) ⚠️

How limits behave (the part nobody explains)

• Usage flows in rolling windows (e.g. a 5-hour window, plus weekly ceilings on heavy plans ⚠️). Hit a cap → wait for the window to reset. Plan heavy builds accordingly.
• Longer conversations burn more — each reply re-reads the whole chat. Another reason for "one chat, one task" (p8).
• Model choice matters: Opus-class replies cost several times a Sonnet reply's allowance.

The API (pay-per-use) ⚠️

For builders: you pay per million tokens, roughly — Haiku ~$1 in / $5 out; Sonnet ~$3 / $15; Opus-class ~$5–15 / $25–75. Two built-in discounts pros exploit: Batch API −50% and prompt caching up to −90% on repeated context (both explained p68).

Hallucination — Why AI Gets Things Wrong, and the Mindset That Fixes It

Sometimes an LLM states false things with perfect confidence. Not lying — reconstructing. It generates what should be true given the patterns, and usually is. The 2% where it isn't is where amateurs get burned and professionals build habits.

The high-risk zones (memorize these)

The three-question verification habit

Privacy & Safety — The Sensible Rules

You'll hear both "never tell AI anything!" and people pasting their whole life into chats. Both are wrong. Here's the professional middle.

Never paste these (into any AI, ever)

Sensible practice for everything else

Know your settings & rights

• Review privacy/training settings in the app and set them to your comfort ⚠️ (options evolve — check Settings → Privacy).
• Claude Code note: your files are read locally on your machine; content goes to the model only as needed for the conversation. Keep secrets in .env files and tell Claude to never print them (p103).
• Delete conversations you consider sensitive; use incognito-style chats for one-offs ⚠️.

The Five Mental Models That Make You Great With AI

Tools change monthly; mental models compound for years. These five run underneath every page that follows — this page is the skeleton key of the whole book.

Your First Real Chat — Weak Ask vs. Strong Ask

The gap between a mediocre AI experience and a magical one is usually 20 extra seconds of asking properly. Watch the same three tasks done twice:

Side-by-side: the 20-second difference

The 30-second brief (memorize this shape)

SITUATION: [who you are + relevant facts and numbers]
GOAL: [what outcome you actually want]
TASK: [the specific thing to produce]
FORMAT: [table / list / word count / tone]
AVOID: [anything it must not do]

Files, Images & PDFs — Claude Can Read Almost Anything

The 📎 button is where casual users become power users. Claude reads PDFs, Word docs, Excel/CSV, PowerPoint, images/screenshots, code files — and reasons over them, not just skims.

Ten upload workflows worth stealing

What to know before you rely on it

• Vision is genuinely strong — charts, handwriting, UI screenshots, photos of physical things.
• Size limits exist ⚠️ (roughly: files up to ~30MB, big-but-not-unlimited page counts — split monsters into parts).
• Numbers from images: ask it to re-state the extracted figures so you can eyeball-verify before decisions (p14 habit).
• Multiple files at once is fine — "compare these three quotes" is a killer use.

Artifacts — Documents, Websites & Mini-Apps Inside the Chat

Ask Claude to make something substantial and it opens a side panel with the finished piece — a live webpage, a working tool, a formatted document. That panel is an Artifact: editable by conversation ("make the header blue"), versioned, downloadable, and shareable ⚠️ (publishing options vary by plan).

What people actually build as Artifacts

Three prompts to feel the power

Build an interactive family duty roster for 4 people and 6 weekly chores:
drag-free simple tap-to-assign, weekly reset button, progress bar per person,
bright friendly design, works on a phone.

Create a quiz app from these notes: [paste notes]. 15 questions, one at a
time, instant feedback with explanation, score at the end, "retry wrong
questions only" mode.

Design a one-page website for my [service] with: bold headline, 3 benefits,
2 testimonials placeholder, WhatsApp contact button, prices section, elegant
dark theme. I'll iterate on the copy after I see v1.

Projects — A Workspace That Already Knows Your Context

A Project is a folder of chats sharing two permanent things: custom instructions (how to behave) and knowledge files (what to know). It's the cure for re-explaining yourself — mental model #1 (p16) industrialized.

Anatomy of a great Project

Projects that pay for themselves

• Job Hunt — CV, target-role description, application tracker → every chat drafts tailored letters instantly
• Studies — syllabus, past papers, your weak topics → a tutor that knows your exact course
• Family Admin — school calendars, insurance summaries, travel docs → "when is re-registration due?" answered from YOUR papers
• Each business vertical — the operator's pattern: one Project per business, so strategy chats from a phone are fully briefed (this is Untapped Lever #11, p91)

Write instructions that actually work

WHO I AM: [role, situation, key numbers]
THIS PROJECT IS FOR: [scope]
ALWAYS: [3-5 standing orders — tone, format, currency, level]
NEVER: [2-3 hard lines]
DEFAULT FORMAT: [e.g. "tables for comparisons, bullets for plans, ≤300 words
unless I ask for depth"]

Memory — When Claude Remembers Across Chats

Beyond Projects, Claude has a memory feature ⚠️ (rollout varies by plan/platform): it can retain durable facts about you across conversations — your role, preferences, ongoing work — and use them automatically.

The three memory channels, and who controls them

Use it deliberately, not passively

Remember these about me: I'm a [role] in [city]. I prefer answers in tables.
My currency is SAR. My English level is professional but keep explanations
simple. I'm working toward [goal] this year.

• Audit monthly: "What do you remember about me? List everything." Delete what's stale — stale memory is worse than no memory.
• Correct on the spot: "That's outdated — I changed jobs; update your memory."
• Sensitive topics: use an incognito/no-memory chat ⚠️ when you don't want retention.

Styles — Make Claude Write Like You (or Like Anyone)

Styles let you set HOW Claude writes, independently of what it writes: preset modes (concise, explanatory, formal) plus custom styles trained on your own writing samples ⚠️ (feature placement varies by app version).

When each style earns its keep

Build a custom style properly

Web Search — Current Information With Sources

Claude's training has a cutoff date (p7), but with web search it fetches today's information and — critically — cites sources you can click. This turns it from "knowledgeable colleague" into "research assistant with receipts."

Asking for research like a professional

Search for current information: [question]. Requirements: cite each source
with a link, prefer official/primary sources, note the date of each source,
and clearly separate confirmed facts from claims found on only one site.

Research [product/service A] vs [B] as of this month: price, key limits,
user complaints from forums/reviews (not vendor pages). Table format,
sources linked per row, end with a recommendation for my case: [your case].

Before I pay [vendor], search independent reviews only — Reddit, Trustpilot,
forums, not their own site. Quote at least 3 real user verdicts with links,
list red flags, and tell me what to demand as a sample BEFORE paying.

Honest limits

• Paywalled and login-only content is out of reach — it reads the open web.
• Search brings sources, not truth — a cited wrong claim is still wrong. Two independent sources for anything that costs money.
• For deep monitoring (price watching, news tracking) → automation on p59/p87.

Data Analysis — Turn Any Spreadsheet Into Answers

Upload a CSV or Excel file and Claude can run real code on it (the analysis tool executes JavaScript/Python-style computation rather than "eyeballing") — meaning actual sums, joins, pivots and charts instead of guessed arithmetic.

The analysis ladder — same file, increasing power

Real-life files worth feeding it

• Bank/card exports → spending truth, subscription hunting ("find recurring charges I might have forgotten")
• Small-business sales → best products, dead stock, seasonality
• Grades/attendance → trend spotting before report cards do
• Any export from any system — if it opens in Excel, Claude can interrogate it

Voice & Mobile — The Most Underrated Surface

The phone app turns dead minutes — commutes, queues, kitchen time — into finished work. And dictation changes who can use AI at all: typing skill stops mattering.

The dictation superpower (this book's origin story)

Mobile workflows that stick

Make voice input work brilliantly

• End a rambling note with: "Now organize everything I just said into [format]."
• Bilingual is fine — Urdu-English mixing gets understood; ask for output in either.
• Long thought? Say "part 1 of 2", send, continue — then "now combine both parts."

Connectors — Claude Inside Your Actual Life

Connectors plug Claude into the tools where your information already lives — Gmail, Google Calendar, Google Drive, Notion, Slack, GitHub and a growing catalog ⚠️ — so instead of copy-pasting, you just ask. (Under the hood this is MCP, the open standard explained on p63.)

What connected life looks like

The safety model — read this before connecting

Claude in Chrome — A Copilot on Every Webpage

The Chrome extension ⚠️ puts Claude in a sidebar that can see the page you're viewing — and, with your permission, act on it: clicking, filling, navigating. It's the bridge between "chat about the web" and "work the web with me."

Where it shines

The guardrails (they're features, not friction)

• It asks before acting — clicks, submissions, purchases get confirmed with you.
• Certain actions stay yours alone: passwords, payments, CAPTCHAs. The AI politely refuses these — by design.
• Same injection-awareness as p26: pages can contain manipulative text; actions confirm with the human.

Real Office Files — Excel, Word, PowerPoint, PDF

Claude doesn't just describe documents — it manufactures them: genuine .xlsx with working formulas, formatted .docx, complete .pptx decks, filled/merged PDFs ⚠️ (file-creation availability varies by plan/surface; fullest power in Claude Code).

What "real files" means in practice

Getting professional results

• Give the skeleton: "sections: A, B, C" beats "make a report" — structure in, structure out.
• Iterate the file: upload what it made, say what to change; round-trips are cheap.
• Formulas over values: ask for live formulas ("=SUM…") so the sheet keeps working when you edit.
• Brand it once: give your logo/colors/font preferences in the Project (p20); every future document inherits them.

Sharing Your Work — Chats, Artifacts, Teams

Work locked in your account is half-finished. The sharing layer, briefly and honestly ⚠️ (options shift by plan):

The sharing menu

Collaboration patterns that work

• The family template: one person crafts the prompt/Artifact (the travel planner, the study quiz), shares it; others reuse without learning anything.
• The team playbook: shared Project holding SOPs + brand voice + price list → every teammate's chats answer consistently. (The operator's version: live playbooks his sales team reads from a deployed page — Lever #24, p104.)
• The review loop: draft in Claude → share chat link with a colleague → they read the reasoning, not just the output → trust builds fast.

The Life Catalog — 20 Everyday Uses, One Line Each

Part 2's graduation page: the breadth, compressed. Every row is a prompt you can fire today; each teaches a reusable shape.

The Prompt Formula — R·C·T·F·C

Page 5 introduced the anatomy; now we make it muscle memory. Five components — Role, Context, Task, Format, Constraints — and the judgment of when each earns its place.

The formula, weaponized

One scenario, formula applied

ROLE: You are a pricing consultant for small service businesses.
CONTEXT: Home bakery, Riyadh. 40 orders/mo average 180 SAR. Ingredients ~35%,
my time unpriced. Two competitors charge 220-260 SAR for similar quality.
Demand exceeds my capacity most weeks.
TASK: Recommend a new pricing structure.
FORMAT: 3 options in a table (price, expected demand effect, monthly profit
math shown), then your single recommendation in 3 sentences.
CONSTRAINTS: Keep me under 50 orders/mo. Assume 10% customer loss per 15%
price rise. If you need a number I didn't give, ASK instead of assuming.

The two mini-forms for daily speed

Few-Shot Prompting — Show, Don't Tell

Describing a style takes paragraphs and still misses. Showing 2–3 examples transfers it instantly — the single most reliable technique for consistent output. "Few-shot" = "here are a few shots of what I want."

Where examples beat descriptions every time

The template

I need [task]. Follow the pattern of these examples exactly.

EXAMPLE 1
Input: [sample input]
Output: [exactly what you want]

EXAMPLE 2
Input: [different sample]
Output: [matching style]

Now process:
Input: [real input]

Craft notes from heavy use

• 2–3 examples is the sweet spot — one can be over-copied; five adds little.
• Make examples span the variety — a short one and a long one; an easy case and a weird case. The model learns the range, not just the center.
• Include a counter-example when quality matters: "BAD output (never do this): …" — fencing off failure modes is cheap insurance.
• This is exactly how the cockpit's messages held one voice across a thousand drafts: gold-standard samples in the generator's instructions, not adjectives (p4's rails in action).

Extended Thinking — When to Buy More Reasoning

Claude can answer instantly, or it can think first — an internal reasoning phase (visible as a thinking indicator; toggleable/budgetable ⚠️ by plan and surface) before the reply. Knowing when to demand thinking is a real skill.

When thinking pays vs. wastes

Triggering deeper reasoning by prompt (works everywhere)

Think through this step by step before answering. Show your working:
1) list what's known, 2) what must be calculated/decided, 3) work through it,
4) sanity-check the result against common sense, 5) THEN give the answer
with your confidence level and what would change your mind.

Why this matters mechanically (p7 callback)

An LLM predicts token by token — its "scratchpad" is the text itself. Forcing intermediate steps literally gives it more computation on your problem. "Show your working" isn't teacher nostalgia; it's buying the model more thinking.

Structured Output — Answers Shaped Like Tools

Prose is for reading; structure is for using. The moment output feeds a spreadsheet, a system, a decision meeting — demand shape.

The structure menu

JSON for automation — the pattern that runs pipelines

Extract from the text below. Return ONLY valid JSON, no other words:
{
  "person": "",
  "company": "",
  "request_type": "quote | complaint | question | other",
  "urgency": 1-5,
  "summary_one_line": "",
  "suggested_reply": ""
}
TEXT: [paste customer message]

This exact shape — message in, labeled JSON out — is the atom of a thousand business automations (triage, routing, CRM enrichment). You'll meet it again in the API (p67) and the income paths (p122, p126).

Pro reliability tricks

• "If a field is unknown, use null — never guess." This one line kills most hallucinated fields (p14 applied to structure).
• Give one filled example alongside the schema (p32's few-shot) — format compliance jumps.
• For long outputs, number everything — "revise #7" beats re-pasting paragraphs.

Long Documents — Getting Truth Out of 100+ Pages

Claude's huge context (p8) reads entire contracts, theses, annual reports. But "it can hold it" ≠ "you'll get the best out of it" — technique matters at length.

The five laws of long-document work

The contract-reading prompt (frame for any serious document)

[UPLOAD/PASTE DOCUMENT FIRST]
You are a meticulous analyst. Using ONLY this document:
1. 10-line plain-language summary.
2. Every obligation on MY side: quote + location.
3. Every deadline, fee, penalty and auto-renewal: quote + location.
4. The 5 riskiest clauses for me, ranked, each with why.
5. Questions I should ask before signing.
Rule: if something isn't stated, write NOT FOUND — never infer silently.

Decomposition — Big Goals Become Prompt Chains

"Plan my business" gets platitudes. Professionals never prompt the mountain — they prompt the next slope, and chain. The skill: goal → milestones → this week → today's prompts.

Worked example: "launch my home bakery's Instagram in 7 days"

Why chains beat mega-prompts

The Critique Loop — Draft → Attack → Revise

The highest-ROI pattern in all of prompting (mental model #3, p16): never accept draft one. Make the model its own harshest reviewer — quality jumps 2 levels in 2 extra messages.

The three-message loop

Rubric scoring — for anything with a quality bar

Score this [essay/proposal/email] against these criteria, 1-10 each, with
one sentence of evidence per score:
1. Clarity for a busy reader
2. Persuasiveness of the core argument
3. Concreteness (numbers & specifics vs vague claims)
4. Tone fit for [audience]
5. Zero fluff
Then revise to bring every score to 9+, and re-score honestly.

Persona attacks — choose your reviewer

Meta-Prompting — Make Claude Write Its Own Instructions

The elegant secret: the best prompt engineer available is the model itself. When a task is important or recurring, don't write the prompt — commission it.

The commissioning pattern

I need a reusable, excellent prompt for this recurring task: [describe task
and what "great output" means to you]. First ask me up to 5 questions to
capture what matters. THEN write the ideal prompt with placeholders in
[BRACKETS], including role, context slots, format spec, and quality
constraints. Finally show one filled-in example run.

The upgrade pattern — fix a prompt that underperforms

Here's a prompt I use, and an example of the mediocre output it produces:
PROMPT: [paste]  OUTPUT: [paste]
Diagnose why the output is weak (missing context? vague task? no format?).
Rewrite the prompt to fix each diagnosis. Explain each change in one line.

Build your prompt library (the compounding asset)

• Keep one note — "PROMPT LIBRARY" — organized by life area. Every prompt that produces a great result gets saved with a one-line "use when".
• Commission prompts for your top 5 recurring tasks this week: the weekly report, the client reply, the lesson plan, the status update, the content post.
• Graduation path: library note → Project instructions (p20) → slash commands (p50) → skills (p51). Same asset, increasing automation — by the end of Part 4 your library RUNS itself.

Prompt Library I — Work & Business

Fifteen field-tested shapes. Replace [BRACKETS], fire, iterate. Each is deliberately compressed — add YOUR context (p31) for full power.

From these raw notes [paste], write my weekly status: ✅ done, 🔄 in progress
(with % and blocker), ⏭ next week, 🚨 needs decision. Executive tone, scannable in 60 seconds.

Draft an email that [delivers bad news / declines / chases payment] to
[relationship]. Goal: [outcome] while keeping the relationship. Firm, warm,
under 120 words, ends with a clear next step.

Build a [30]-min agenda for [meeting purpose], attendees [roles]. Timeboxed
items, each with an owner and a decision-or-output, plus a parking lot rule.

Write a JD for [role] at [company type]. Sections: mission of the role, 5
outcomes for year 1 (measurable), must-haves (max 5), nice-to-haves, what we
offer. No clichés ("rockstar", "fast-paced").

For hiring a [role], create 8 interview questions mapped to the 4 skills that
matter most, each with what a 1/5 vs 5/5 answer sounds like. Table.

SWOT for [business] given these facts: [numbers, market, competitors]. Rule:
every entry must be specific and evidenced from my facts — no generic entries
like "competition". End: the ONE strategic move the SWOT points to.

Here are my numbers for [period] vs previous: [paste]. What genuinely changed
(ignore noise under 5%)? Rank 3 causes to investigate, each with the exact
question to answer and where I'd find the data.

I'll describe how I do [process] messily: [dictate]. Turn it into a numbered
SOP a new hire could follow alone: steps, tools, common mistakes, quality
check at the end.

Client proposal for [service] to [client type]. Sections: their problem in
their words, outcome promised, approach (3 phases), timeline, investment
(anchor high option first), guarantee, next step. Confident, zero begging.

My service: [what]. Cost structure: [numbers]. Competitors charge [range].
Model 3 price points: monthly profit at realistic volumes (show math),
positioning message for each. Recommend one with reasoning.

Search [competitor]'s public presence. Table: offer, pricing, positioning
claim, visible weaknesses (slow site? bad reviews? gaps?). End: 3 ways I
differentiate honestly. Sources linked.

Turn my goal "[goal]" into 1 Objective + 3 Key Results that are measurable
weekly, with a leading indicator each (something I control), and the first
Monday action.

For project [X], list top 8 risks: likelihood × impact (H/M/L), early warning
sign, mitigation owner, plan-B. Sort by exposure. Table.

Write an escalation to [senior person]: issue [X], impact [numbers], what I
already tried, the specific decision/help needed by [date]. 150 words max,
subject line included, zero drama.

One-page update on [area]: headline (one sentence, the truth), 3 numbers with
trend arrows, what's working, what's not + fix, the ask. They read it in 90
seconds — write for that.

Prompt Library II — Study & Family

Explain [topic] to a smart 12-year-old: one everyday analogy, 5 short points,
one "wow" fact, then 3 questions to check I got it.

From this material [paste/photo], make 20 flashcards (Q on one line, A below).
Mix: 10 recall, 6 understanding, 4 application. Hardest last.

Quiz me on [topic], one question at a time. After each answer: correct/not,
short explanation, difficulty adapts to my performance. Track my score. 10
questions, then a weakness report with what to revise.

Essay question: [paste]. Build an outline: thesis options (pick strongest),
3 arguments with evidence types needed, counter-argument + rebuttal,
conclusion angle. I write the essay myself — you coach.

Exams: [subjects + dates]. Available: [hours/week, when]. Build a realistic
timetable: hardest subjects at my best hours, spaced repetition (revisit each
topic 3×), one rest day, printable table.

My child (age [X]) is stuck on: [problem]. DO NOT solve it. Ask one guiding
question at a time, building on their answers, until THEY reach the solution.
Then give a similar practice problem.

Age-appropriate science project on [interest] for a [X]-year-old: hypothesis
in kid language, materials under [budget], safe steps, what to measure, how
to present it on one poster.

Daily 10-min [English] practice. Roleplay: you're [a customer/interviewer],
I'm [role]. Speak simply, correct my mistakes AFTER each reply (max 2 fixes),
and teach one useful phrase per session. Start now.

Translate this to [Urdu/English]: [text]. Then teach me: 3 vocabulary items
worth keeping, 1 grammar pattern used, and the tone difference between the
languages here.

Interview me (5 questions, one at a time) about income, fixed costs, debts,
goals. Then: monthly budget table, 3 realistic savings moves with amounts,
and one habit to start this week. Currency: [SAR].

7 dinners for [family size]: cuisine [X], budget [Y]/day, [dietary rules],
under 40 min each. Output: menu table + ONE consolidated shopping list by
supermarket section.

[X]-day trip to [place], party: [ages], budget [Z] total, pace: relaxed.
Day-by-day table (morning/afternoon/evening), transport between stops,
[halal] food options, one backup indoor plan per day, budget breakdown.

Symptoms/situation: [describe]. Prepare me for the appointment: questions to
ask the doctor, information I should bring, terms I might hear explained
simply. You are not diagnosing — you're preparing me to get the most from a
professional.

[Photo of form] Explain each field in simple words. Draft my answers from
these details: [details]. Flag any field where a wrong answer commonly causes
rejection.

Write a warm 200-word family WhatsApp update from these events: [list].
Light humor, one photo caption suggestion, ends with a question that gets
the relatives replying.

Prompt Library III — Builders & Creators

These preview Part 4's world — you can fire them in normal chat today, and in Claude Code they become real running systems.

Landing copy for [offer] to [audience]: headline (outcome, ≤9 words), sub,
3 pain→benefit blocks, social-proof placeholder, FAQ (5), CTA. Write at a
9th-grade reading level; zero hype adjectives.

Build a complete single-file HTML page for [purpose]: dark elegant theme,
mobile-first, sections [list], smooth scroll nav, contact via WhatsApp link.
Inline CSS/JS, no external libraries. Production quality.

My table: [name(columns…)]. Write SQL to answer: "[question]". Explain each
clause in one line, then give a second query that double-checks the result a
different way.

Regex to match [pattern description]. Provide: the pattern, plain-English
breakdown, 5 strings that match, 5 near-misses that must NOT match.

Python script (standard library only): [task, e.g. "rename all photos in a
folder to YYYY-MM-DD_number from their EXIF date"]. Include: dry-run mode
that only prints, clear comments, and graceful handling of bad files.

Here's messy CSV data: [paste sample]. Write the cleaning rules you'd apply
(dates, casing, duplicates, impossible values), apply them, output clean CSV
+ a log of every change count.

Show a minimal working example calling [API] in Python: auth from an
environment variable (never hardcoded), one request, error handling, printed
result. Then the same as a reusable function.

Write a README for this project: [describe or paste code]. Sections: what it
does in one sentence, quick start (3 commands), configuration table, common
problems. Assume a smart beginner.

For this function [paste], list test cases as a table: normal cases, edge
cases (empty/huge/wrong-type), and evil cases. Then write the tests in
[pytest].

Refactor this code for readability WITHOUT changing behavior: [paste].
Show before/after of each change with a one-line reason. Flag anything that
looks like a real bug separately — don't silently fix logic.

Bug: expected [X], got [Y]. Code: [paste]. Error: [paste exact message].
Diagnose: 3 candidate causes ranked, the test that distinguishes them, then
the minimal fix for the winner. No rewrites beyond the fix.

I want [task] to run automatically every [schedule] on Windows. Give me the
script + the exact Task Scheduler setup steps + how to verify it ran + where
logs go. Quote the path correctly (spaces!).

I want data from [site/type]. First: is scraping it appropriate (terms,
robots, personal data)? If yes, outline a respectful approach (rate limits,
public data only, caching). If no, name the legitimate alternative (API,
export, dataset).

Spec a one-page dashboard for [audience] tracking [goal]: the 5 metrics that
matter (and 5 tempting-but-useless ones to exclude), layout sketch in text,
update frequency, and the single number that leads the page.

Idea: [describe]. Attack it: who EXACTLY pays, what they use today, why
they'd switch, hardest part to build, cheapest 1-week test that could kill
or confirm it. Verdict: build / test / drop — with reasoning.

The 12 Mistakes — A Diagnostic Checklist

When output disappoints, the cause is on this list. Diagnose, fix, refire. (Print this page for your desk — the Print button handles colors.)

Claude Code — The Same Brain, Given Hands

Everything until now was conversation: you carry insights out of the chat and apply them yourself. Claude Code deletes that last step. It's Claude running on your computer with permission to act: create and edit files, run programs, query databases, use git, browse, deploy. You describe outcomes; it does the work in place.

The difference, felt

Where it runs

Terminal (CLI) Desktop app VS Code / JetBrains panel claude.ai/code (cloud, from any browser) GitHub (tag it on issues/PRs) — same agent, pick your comfort. Non-coders often prefer the desktop app; the terminal is the classic.

The honest frame

Non-Coders Welcome — The Honest Map

The most important sentence in Part 4: the person running the systems in Part 6 does not write code. A 15-year planning engineer, not a programmer — directing AI in plain English (and voice notes). Here's the honest map of what that means for you.

What a non-coder can genuinely build (week one)

What still needs YOU (and always will)

• Judgment: what's worth building, what "good" looks like, when it's wrong.
• Verification: click the thing, check one number, read the output (mental model #5). The operator's laws exist because unverified claims burned him (p76, p79).
• Small-steps discipline: ask for one change, check it, ask for the next. Non-coders who fail usually asked for cathedrals in one prompt (p36's chains apply doubly here).

The vocabulary you need (all of it)

Install & First Launch — 15 Minutes, Once

Three routes; pick one. ⚠️ Exact buttons/versions drift — if anything looks different, ask Claude in the chat app: "walk me through installing Claude Code on Windows, current steps."

Route A — Desktop app (easiest, recommended for non-coders)

Route B — Terminal (the classic)

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

mkdir my-first-project
cd my-first-project
claude

Route C — Inside VS Code / your IDE

Install the Claude Code extension from the marketplace → sign in → it appears as a panel beside your files. Best when you'll also look at code; also the base for the browser-preview workflow.

Sanity checklist before p46

• ✅ It greets you with a prompt box inside your chosen folder
• ✅ Typing "what files are in this folder?" gets a real answer (empty is fine!)
• ✅ You know one fact: it can only touch the folder you started it in (plus what you explicitly allow) — your computer isn't open-season

Your First Session — A Real Walkthrough

Follow this literally; it teaches the rhythm: small ask → watch → verify → next. Total time ~20 minutes.

Create a file called hello.html: an elegant dark page with my name "[NAME]",
a live clock, and a daily changing quote. Then open it in my browser.

Look at my Downloads folder and TELL me (don't do anything yet): how many
files, grouped by type and age. Propose an organization plan.

Create NOTES.md summarizing: what we built, decisions made, and the 3 next
ideas. Keep it updated at the end of every future session.

Reading the transcript (what the scrolling text means)

Under the Hood — The Toolbelt

Claude Code = the model (p10) + a toolbelt + your permission system. Knowing the tools by name turns the transcript from noise into a readable work log — and lets you direct precisely.

The core toolbelt

Directing by tool name (subtle, powerful)

• "Grep for every file that mentions the old price before we change anything" — forces evidence-gathering first.
• "Read the whole file before editing it" — kills blind-edit mistakes.
• "Use the browser preview and verify the button actually works" — demands proof, not claims (p52's hooks can even enforce this).

Permission Modes — Your Safety Dial

Every action requests permission by default. The modes are a dial between control and flow ⚠️ (naming varies slightly by version — the four positions are stable):

The four positions

Granular allow-lists (the smarter path)

Instead of a blunt dial, per-action rules live in a settings file: "always allow git status, ls, reads; always ask for rm, pushes, installs." You approve a safe command once with "don't ask again for this" — friction falls all week while dangerous verbs still knock. (Curated allow-list recipe: Lever #18, p98.)

The judgment rules that matter more than the dial

• Reads are free, writes are checked, deletes are sacred. Approve reads casually; glance at edits; read delete/overwrite commands word by word.
• Backups make courage cheap: with git (p56), the worst approved mistake is one git checkout from undone. No git = no bypass, ever.
• Untrusted content lowers the dial: processing files/pages from the internet? Injection risk (p26/p64) means keep prompts ON for actions.

CLAUDE.md — Teach It Once, Benefit Forever

The single highest-leverage file in this entire book. CLAUDE.md is a plain text file in your project that Claude Code reads automatically at every session start. Whatever it says is simply… known. Preferences, facts, rules — delivered fresh to every future session, forever.

What goes in (with a real skeleton)

# Project: [name]
## What this is
[2 lines: purpose, who uses it]

## Facts Claude must know
- Main files: [x.py does A; site/ holds B]
- The database is [file]; NEVER delete rows — mark status instead
- Prices/data come from [source of truth]

## How I like to work
- Explain in plain English; I'm not a programmer
- Small steps; after each change, verify and show me proof
- All file paths in quotes (Windows spaces!)

## Hard rules
- Never touch anything outside this folder
- Never print secrets or .env contents
- Before any risky change: backup first, then proceed
- If tests/checks fail: STOP and show me, don't improvise

Two levels, one habit

The growth loop — where the magic compounds

Slash Commands — Prompts That Became Buttons

Any prompt you type twice deserves a name. A slash command is a saved prompt file — type /name and the whole thing fires. Your p38 prompt library, industrialized.

Make one in 60 seconds

Look at everything that changed in this project in the last 7 days (git log
+ modified files). Write my weekly status: done / in-progress / blockers /
next week. Save as reports/week-[date].md and show me the highlights.

A starter command set worth stealing

Skills — Expertise That Loads Itself

One step above commands: a skill is a folder of instructions (+ optional scripts/templates) that Claude loads when the task calls for it — you don't even have to invoke it. Commands are buttons; skills are employees with training manuals.

Anatomy

---
name: invoice-maker
description: Create branded PDF invoices from a client name + line items.
  Use whenever the user asks for an invoice or billing document.
---
# Standards
- Template: assets/template.html (logo, colors preset)
- Numbering: INV-[YEAR]-[running number from data/counter.txt]
- Always: VAT 15%, payment terms 14 days, save to invoices/[client]/
- After creating: open a preview and verify totals sum correctly.

The description is the trigger — Claude reads it and thinks "this task matches; load the manual." Say "invoice Ahmed for two consulting days" → the skill fires, standards applied, no reminder needed.

Skills worth building first

• Your document standard — brand, fonts, print-fix CSS, structure for every guide/report you produce (the operator's version guarantees interactive HTML with copy buttons and progress bars — you're reading its output)
• Your QC gate — "before calling anything done: run checks X, Y; screenshot; verify totals" (p23/p37 institutionalized)
• Your deliverable per trade — lesson-plan skill for teachers, quote-builder for contractors, listing-writer for realtors (income relevance: Part 9)

Meta: the skill that makes skills

There's a skill-creator skill: describe a repeated job, and it interviews you, writes the SKILL.md, and installs it ⚠️. Turning-jobs-into-skills is itself a one-sentence job — Lever #4 (p84) shows the operator's backlog of skills waiting to be minted this way.

Hooks — Rules Enforced by the Machine, Not by Memory

The elite tier of customization. A hook is a command that runs automatically on session events: before/after any tool call, on session start/end. CLAUDE.md asks Claude to behave; hooks make behavior physically automatic — even a forgetful model can't skip them.

What events can trigger what (concept table)

A concrete taste (configuration sketch ⚠️ syntax evolves — ask Claude to write yours)

Set up hooks for this project: (1) after any edit to a .py file, run its
tests and show failures immediately; (2) block any bash command that would
delete files outside this project; (3) at session end, update NOTES.md with
what changed. Explain each hook file you create.

Why this page matters beyond convenience

MCP Servers — Plug Databases, Browsers & APIs Into Your Agent

Part 2 showed connectors in the chat app (p26). In Claude Code the same standard — MCP (full story p63) — plugs professional tools into your agent: databases it can query, browsers it can drive, platforms it can call.

The greatest-hits servers ⚠️ (ecosystem grows weekly)

Adding one (the shape, not the memorization)

Add an MCP server so you can query my SQLite database at data/app.db
(read-only). Then prove it works: list the tables and count the rows in each.

Under the hood it's a claude mcp add … command or a JSON config entry ⚠️ — let Claude write it; your job is deciding WHAT gets plugged in.

The two safety lines

Subagents — When One Claude Dispatches Many

Claude Code can spawn subagents: independent Claude workers, each with its own context window and toolbelt, running in parallel on scoped tasks — then reporting back for synthesis. You stop being a user with an assistant and become a director with a staff.

Where parallelism genuinely pays

Directing a fan-out (the shape)

Dispatch 3 parallel agents to research [decision]:
- Agent 1: option A — pricing, limits, 3 independent user reviews with links
- Agent 2: option B — same checklist
- Agent 3: risks & questions we haven't thought to ask
Non-overlapping scopes. Then synthesize: one comparison table + one
recommendation with reasoning. I want sources, not vibes.

The economics (honest)

Plan Mode — Research First, Touch Nothing, Then Execute

The professional's answer to "I'm nervous about letting AI change things." In plan mode Claude is physically read-only: it explores, thinks, and writes a plan document — what it will change, how, what could go wrong, how to verify. Nothing happens until you approve. Then it executes the approved plan.

When plan mode is mandatory (adopt these triggers)

• Anything touching data (databases, bulk file moves, renames at scale)
• Changes to a working system — the thing that already earns/serves
• Multi-file builds where a wrong architecture wastes hours
• Anything you'd struggle to describe precisely — planning surfaces the ambiguity BEFORE it becomes wrong files

The rhythm in practice

Git & GitHub — Undo for Your Whole Project

Git is a time machine for a folder: snapshots ("commits") of everything, forever, reversible. GitHub is the cloud copy. Together they make AI-speed building SAFE: any mistake, however large, is one command from undone. Non-coders: this is FOR you, and Claude does the typing.

The five moves (you'll only ever say these in English)

The workflow that changes your relationship with risk

Rule: commit a snapshot with a clear message after every working milestone,
and BEFORE any risky change. When I say "undo", show me what we'd lose, then
restore the last snapshot on my confirmation.

Branches & PRs — one level up, still plain English

• Branch: "try this redesign on a branch" = a parallel universe; merge if good, delete if not. Main stays safe.
• Pull request (PR): a proposed change wrapped for review — the unit of teamwork on GitHub, and the unit AI-at-work uses too (p60: Claude opens PRs you review from your phone).

Build-Along #1 — A Personal Dashboard, Deployed For Real

Ninety minutes, zero code knowledge, and at the end: a page on the actual internet with your name on it. Every prompt given; the skill being trained is directing + verifying (p46's rhythm at project scale).

Build index.html: my personal dashboard. Dark elegant theme. Sections: live
clock + date (Riyadh), my week's focus list (editable, saves in the browser),
quick links grid (WhatsApp Web, Gmail, YouTube, [your 3]), a daily rotating
quote, weather placeholder. Mobile-perfect. Set up git and commit "v1".

Deploy this to Cloudflare Pages (free). Walk me through the one-time account
step if needed, then deploy and give me the live URL. Then explain how future
updates get deployed in one command.

Build-Along #2 — A Real Data System (The Cockpit Pattern, Miniature)

The architecture behind the job-hunt cockpit (p73), at learnable scale: database → rules → generated dashboard → deploy. Build it once and you'll recognize this skeleton inside half the systems in the world. Example chosen: a family expense tracker — swap in anything (clients, applications, inventory).

Create expenses.db (SQLite): table expenses(id, date, category, amount_sar,
who, note, status). Rule for this whole project: NEVER delete rows — corrections
happen by adding a correcting row or changing status. Seed 15 realistic sample
rows. Show me the table as proof. Git init + commit.

Build build_dashboard.py: reads expenses.db, generates dashboard.html —
this month's total vs last, by-category bar chart, by-person split, last 10
entries table, a red flag if any category is 30% over its 3-month average.
Elegant dark theme. The page is REGENERATED from data, never hand-edited.
Run it, open it, verify the totals match the database with a query.

Automation — Work That Happens While You Sleep

The final promotion: from "Claude does it when I ask" to "it happens." Three tiers, ascending autonomy:

Tier 1 — Scheduled scripts (no AI at runtime, $0)

The build-along's update.bat + Windows Task Scheduler (or cron on Mac/Linux) = the dashboard rebuilds itself nightly. Claude sets it up in one ask:

Create a scheduled task that runs update.bat daily at 06:00. Path has spaces —
quote it properly. Add logging to logs/, tell me how to verify tomorrow that
it ran, and what to check if it didn't.

Tier 2 — Scheduled AI (cloud agents)

Claude's scheduled tasks ⚠️ run agent sessions on a schedule: "every morning at 7, read my project state + inbox summary + calendar, produce my day brief." AI judgment, timer-fired (the operator's unused goldmine — Lever #7, p87).

Tier 3 — Watchers & loops

Long-running guards: watch a folder ("new CV arrives → score it → file it"), watch a site ("price drops → alert me"), self-monitoring systems ("if the SLA check fails → rebuild → notify"). His net-watchdog and send-monitors live here. Rule of the tier: every loop needs a kill switch and a heartbeat — a file that says "I'm alive" and a file that, if present, says "stop."

What to automate first (the honest filter)

• Happens on a schedule + same steps + failure is cheap & visible → automate now (reports, backups, rebuilds).
• Needs judgment on novel input → Tier 2 with human review of output.
• Touches money or other people → automation drafts, human sends. Permanently. (The operator's QC gate: nothing reaches a client without founder review — p72.)

Cloud Claude — Your Agent From Any Browser, Any Phone

Claude Code also lives at claude.ai/code ⚠️: sessions run on Anthropic's machines against your GitHub repos — no terminal, no install, works from a phone in a queue.

The cloud loop

When cloud beats local

GitHub-native Claude

Deeper still: install the Claude GitHub app ⚠️ and @claude becomes a teammate inside issues and PRs — "@claude fix this issue", "@claude review this PR for security problems." Combined with Actions (Lever #9, p89), your repository becomes a factory with an AI employee on shift.

Cost Control — Getting Maximum Brain Per Dollar

Claude Code consumes your plan's usage (or API credit) as it works. Amateurs get surprised; professionals steer. The levers, in order of impact:

The levers

The mindset (from someone who pays real bills with it)

Troubleshooting & The 15 Pro Tips

When things go sideways — the diagnosis table

The 15 tips that separate operators from tourists

1. Name files explicitly — "in build_dashboard.py" beats "in the dashboard thing."
2. Paste errors whole — the full red text, not your summary of it.
3. "Verify by running it" — append to any build ask; claims are not results (p76 in six words).
4. Ask for a dry-run before anything bulk: "show what WOULD change first."
5. Commit before risk — make "snapshot first" reflexive (p56).
6. One session, one mission — context purity is output quality.
7. Let it read before it writes — "read the file and tell me your understanding first" on anything delicate.
8. Turn repeat asks into commands/skills the second time they happen (p50-51).
9. Write rules, not reminders — CLAUDE.md/hooks after every annoyance (p49, p52).
10. Ask for its plan of tool calls when nervous (p47) — transparency on demand.
11. Keep a NOTES.md per project — your future self is a stranger who needs briefing (p74).
12. Prefer boring tech — HTML + SQLite + Python survive; exotic stacks rot (p107).
13. Small models for small jobs — match the tier to the task (p61).
14. Read diffs like a manager — you don't need to write code to SEE "that's touching the wrong file."
15. End sessions with state — "update NOTES.md; what's the first move next time?" Every session becomes resumable.

MCP — The USB-C Port of the AI World

You've now met MCP twice (p26 app connectors, p53 Code servers). Time to actually understand it, because it's becoming the plumbing of the whole industry.

The problem it solves

Before MCP: every AI × every tool needed a custom integration — Claude↔Gmail, Claude↔Notion, every pairing hand-built, N×M chaos. Model Context Protocol (open-sourced by Anthropic in late 2024, since adopted across the industry ⚠️) standardizes the plug: any tool that speaks MCP works with any AI client that speaks MCP. Exactly like USB-C ended the cable drawer.

The three things a server can offer

The mental picture (30 seconds)

The server is a small translator program: it exposes safe, named actions; the AI calls them; the server does the real API work. The AI never holds your Gmail password — the server holds the authorized connection, and shows the AI only the levers you chose to expose. That separation is the security model.

Why an open standard matters to YOU

• Your investment compounds: a connector learned once works across surfaces (app, Code, other MCP clients).
• Niche tools arrive fast: anyone can publish a server — thousands exist ⚠️ — so YOUR industry's tool probably has one, or can (p69: build your own).
• No lock-in: standard plumbing means switching clients later doesn't torch your integrations. The $0-stack philosophy (p106) approves.

Choosing Connectors — Catalog Thinking & The Safety Rules

The catalog, by category ⚠️ (growing weekly — search "MCP servers" for today's list)

The five safety rules (this half-page is the security training)

Eight Workspace Recipes — Gmail, Calendar, Drive as One Brain

The connector catalog's highest-frequency wins live in Google Workspace. Eight recipes, each one sentence to fire, each a daily habit for someone:

Habits that make these safe AND sticky

• Draft ≠ send. Recipes 1, 5, 7 end at drafts; sending stays your click (p64 rule 3). Non-negotiable and permanent.
• Same recipe, same wording → save each as a slash command or scheduled brief (p50, p59 Tier 2) — recipe 1 as a 7am scheduled agent is the classic "AI chief of staff" starter.
• Start with 1 and 2. They pay daily within a week; the rest join as trust builds.

Browser Automation & Computer Use — The Frontier Surface

Two related powers at the edge of the toolbox: driving a browser (p27's Chrome copilot, plus headless Playwright in Code), and driving the whole desktop — screenshots, clicks, typing into ANY application. Real, useful, and deserving of the most respect of anything in this book.

Legitimate wins by tier

The risk model — why this tier has extra rules

The API — Claude Inside YOUR Programs

Every surface so far was Anthropic's packaging. The API is the raw ingredient: your code calls the model directly — the door from "using AI products" to "building AI products" (Part 9's paths 1, 6, 10 live behind it).

The complete starter (this actually runs)

setx ANTHROPIC_API_KEY "your-key-here"

import anthropic

client = anthropic.Anthropic()  # reads the key from the environment

msg = client.messages.create(
    model="claude-sonnet-5",          # or haiku-class for cheap volume
    max_tokens=500,
    system="You are a concise assistant for a small bakery owner.",
    messages=[{"role": "user",
               "content": "Write 3 Instagram captions for fresh mango cake."}]
)
print(msg.content[0].text)

The concepts that matter (and nothing more)

Cost Engineering — Batch, Caching & The Right-Size Rule

API bills are engineering problems with three famous levers. Even if you never code, understanding them explains how AI businesses (Part 9) price profitably.

Lever 1 — The Batch API: −50% for patience ⚠️

Jobs that can wait (up to ~24h processing window) — nightly personalization runs, bulk classification, report generation — submit as a batch at half price. 📊 Example: 5,000 product descriptions × ~600 tokens each ≈ 3M tokens ≈ a few dollars at Haiku-class batch rates ⚠️ — a price no human workforce can meet.

Lever 2 — Prompt caching: pay once for repeated context ⚠️

Your 20-page system prompt / product catalog / style guide, resent every call? Mark it cached: the first call pays full price, subsequent calls read it at up to ~90% off. The design consequence: big stable context + small varying question = beautiful economics. (This is also why long-running Code sessions feel efficient — same principle inside.)

Lever 3 — Right-size the model (the biggest lever of all)

The pattern has a name in this book already: spend genius at design time, pennies at run time (p10, p61). The operator's version even runs bulk LLM work on a separate parallel rig with 18 workers — same doctrine, industrial scale.

Building Your Own MCP Server — Your Tools, Standard Plug

The graduation exercise of Part 5. You have something unique — a database, a folder system, an internal process. Wrap it in MCP and EVERY AI surface you use gains that capability, safely, forever.

What "a server" really is (deflating the mystique)

A small program (often ~50 lines with modern SDKs ⚠️) that: (1) declares its tools — names, descriptions, inputs; (2) receives calls; (3) does the real work; (4) returns results. The AI sees only the levers you declared. That's the whole trick.

Concept sketch — "family expenses" server (from build-along #2's DB)

server "family-expenses":

  tool add_expense(date, category, amount_sar, who, note):
      validates + INSERTs into expenses.db   # never DELETE — house law
      returns new monthly total

  tool monthly_summary(month):
      SELECT totals by category
      returns table + the 30%-over-average flags

  tool export_report(month):
      runs build_dashboard.py
      returns the file path

Result: from ANY Claude surface — phone chat included ⚠️ (remote servers) — "add 85 riyal, groceries, today, me" just… works. Your family system became an AI-native appliance.

The commissioning prompt (you don't write this yourself)

Build an MCP server exposing my expenses.db with the three tools we sketched:
add_expense (with validation, no deletes possible), monthly_summary,
export_report. Read-only everywhere except add_expense. Register it in my
Claude config, then PROVE it: call each tool once and show results. Explain
what you built in plain English.

What's worth wrapping (idea board)

• Your business DB — read-only reporting tools for evidence-grade answers anywhere (the operator's leads DB is the obvious candidate in his own stack)
• Your documents — "search my contracts/notes" as a tool
• Your niche skill — a calculation only your profession does (engineering checks, quantity surveys, dosage tables ⚠️ with professional review) — this is a sellable asset (p123)

The Surface Chooser — One Table to Rule Them All

Part 5 closes with the navigation instrument. Seven surfaces (p12), one question: where does THIS task go?

The decision table

Worked examples (test yourself before reading column 2)

The Operator Mindset — From User to CEO of AI Workers

Part 6 is the book's documentary section: one real person — a senior planning engineer in Riyadh, a non-coder, working nights and weekends — running genuinely automated business systems with Claude. Not a demo account: real databases, real deployments, real scars. The names of things are lightly anonymized; the engineering is exactly as it runs.

The identity shift that precedes every system

What his actual management day looks like

• Direction in plain language — most instructions arrive as voice notes (p25's story); the AI structures, plans, and proposes before executing (p55's GO discipline).
• Review gates where they matter — client-facing sends queue for HIS eyes; internal rebuilds run free. Gates placed by risk, not by anxiety.
• Evidence on demand — "how many leads have no gift page? show the query" — every number answerable, or it doesn't get said (p76).

Case Study I — The Diagnostics Business (End-to-End Anatomy)

The flagship: a B2B service that finds revenue leaks in software companies' sales funnels and delivers board-grade diagnostic reports. Tiers from $900 to $18,000 ✅ (live pricing on its site). Here is the pipeline, node by node — and WHERE AI sits in each:

The pipeline

Numbers that teach (labeled honestly)

Case Study II — The Job-Hunt Cockpit (Her Question, Fully Answered)

The system that started this book (p2-p5 answered its four questions). Here's the full engineering story — built as a gift for a senior colleague's job search, in a few evening sessions.

Requirements → architecture

The parts, and the pattern you already know

• Store: one DB — contacts, bands (817 director-level, 404 PM-level ✅ measured), message drafts, follow-up schedule.
• Enforce: the pitch ladder (p4), 18-email/25-LinkedIn daily caps, subject-length gates, junk-company-name handling — violations fail the BUILD, they can't reach a human.
• Generate: Python builds the cockpit page + role-matched profile pages + tailored CVs from the DB. Pages are never hand-edited (p58's law).
• Verify: deploy checks anchor live-page counts to DB counts by ID — 1,221 in the DB, 1,221 on the page, measured, or no deploy.
• Automate: one rebuild-and-deploy command; daily work is: open cockpit → copy → send → tick.

The Session-Management System — Surviving Crashes, Compaction & Time

The least glamorous system is the one that makes all others possible. Problem: AI sessions END — crashes, context limits (p8), tomorrow. Without discipline, every session starts amnesiac (mental model #1). His answer is a file architecture any serious user can copy today:

The state files

The checkpoint ritual (the heartbeat)

After every substantial unit of work: a checkpoint script refreshes snapshots, state files get updated, and a full "resume from nothing" briefing is produced — including a master-prompt file saved OUTSIDE the workspace as crash insurance. Standard: a window crash is a non-event, costing at most minutes.

Your starter version (10 minutes, tonight)

In this project, create NOTES.md with sections: CURRENT STATE / DECISIONS /
NEXT STEPS. From now on (add to CLAUDE.md): at every milestone and at every
session end, update NOTES.md so a brand-new session could resume with zero
questions. Start by writing today's entries.

The Rules System — A Constitution Born From Incidents

Page 49 showed the mechanism (CLAUDE.md). Here's what it becomes at maturity: 50+ numbered laws, each created the day something went wrong, each citing the incident. Not aspirations — case law.

Sampled from the real constitution (paraphrased)

The meta-rule that makes it work

Your five starter laws (adapt, paste into CLAUDE.md tonight)

LAW 1 — Claims about my data/files show the command or file that proves them.
LAW 2 — Never print secrets; verify silently, report found/missing only.
LAW 3 — Anything costing money or leaving my machine: state it, wait for GO.
LAW 4 — Backup/commit before risky changes; never delete when flagging works.
LAW 5 — At milestones and session end: update NOTES.md (state/decisions/next).
Each new mistake we make together becomes LAW 6, 7, 8… same day, with the
incident named.

The Evidence Law — The Page That Saves You From AI's Worst Failure

The most important 500 words in Part 6. One night, in one session, the operator's AI made three false statements: a reply-rate that was mathematically impossible yet praised as "excellent"; a claim that leads hadn't been emailed — without opening the list that proved they had; and records matched by name that returned the wrong companies entirely. His words that night: "I'm trying to build a $500B company. We cannot work like this."

The law that came out of it

The pre-send gate (run before anything important ships — human or AI)

1. Every number labeled and evidenced?
2. Did I check the negative case (the exclusion list, the other table, the thing that would disprove me)?
3. Any impossible numbers (a rate over 100%, replies exceeding sends, a child larger than its parent)?
4. Am I stating a conclusion the data only suggests?
5. Did I read the actual code/document, or just its name?
6. Would this survive being forwarded to someone who knows the truth?
7. Did I run the cheapest query that could falsify me?

And the enforcement clause that gives it teeth: if a check fails, the fix is to run the query — never to soften the wording. "Approximately" is not a substitute for looking.

The twin law (from the opposite failure)

The Data Moat — The Asset That Grows While You Sleep

Strategy page. Every business in his portfolio obeys one architectural law from client #1: accumulate anonymized intelligence permanently.

The two-layer architecture

The separation is what makes it both ethical and legal ⚠️ (properly anonymized data — no individual re-identifiable — is not personal data under GDPR-style regimes): honor every erasure request fully on layer 1, while layer 2 — the aggregate learning — compounds untouched. Every serious data company (CRMs, consultancies, credit bureaus) runs exactly this.

Why compounding data beats compounding features

At maturity the deliverable itself upgrades: "companies in your revenue band typically lose X% to this leak — you're losing Y%" 📊. No new competitor can say that sentence, at any funding level, without the years of accumulation. Features are copyable; corpora are not.

Your version, whatever your size

• Freelancer: every project's (anonymized) before/after metrics → in a year, "across 40 projects like yours, typical improvement is X" — instant senior credibility (Part 9 relevance: every path).
• Teacher: which explanations produced the biggest test gains, by topic — a private pedagogy dataset.
• Implementation: one table, append-only, written at every delivery. Build-along #2 skills are all it takes (p58). The law to copy verbatim: never promise to delete the anonymized layer, and never build a button that can.

Deliverables as Products — The Interactive HTML Standard

A house rule with outsized returns: every guide, report, and client deliverable ships as an interactive HTML page — not a PDF, not a wall of chat text. You are inside the evidence right now.

The standard's required ingredients (his checklist, adopted for this book)

Why HTML beats the alternatives (the strategic view)

• Vs PDF: interactive, updatable, trackable, phone-perfect — and still prints to PDF when someone insists.
• Vs chat answers: a chat scrolls away; an artifact is an ASSET — linkable, shareable, improvable, sellable (p124).
• Vs slide decks: depth survives; nobody ever asked a webpage to "just send the deck."

The Scar Catalog — Eight Real Mistakes, Eight Permanent Upgrades

Most AI content shows highlight reels. Here is the blooper reel — because each blooper became architecture, and that transformation is the actual skill of working with AI. All eight are real, dated incidents from the operator's logs.

The Empire Blueprint — Where This Is All Pointed

Part 6 closes with the ambition that organizes everything you've seen: a portfolio of ~100 fully-automated async businesses, run by one operator directing AI. Audacious? Yes. But the blueprint's LOGIC is teachable and true at any scale — including a portfolio of one.

The template every vertical inherits

The honest physics of it

Untapped #1 — Version Control the Whole Workstation

Part 7's format: 25 levers the operator himself hasn't fully pulled — audited honestly against his real setup. Each page: the gap → the exact fix → the payoff math. These are ranked among the highest-value pages in the book because they're written from the INSIDE of a serious deployment, and every gap named here is one YOU can close in your own practice from week one.

The gap ✅ (verified)

The empire's working directory — engines, cockpit builders, state files, hundreds of scripts — is not a git repository. Protection today: manual backup copies and data-safety laws. One bad bulk edit, one overwrite, one disk failure between backups = archaeology instead of a 10-second restore. It's mistake-#8 energy waiting for a bigger stage.

The fix (one evening)

Initialize git for this workstation. First write a .gitignore that excludes:
all secrets/credentials files, databases over 50MB (list them), temp/log
folders. Then: initial commit, and add a rule to CLAUDE.md — commit with a
clear message after every substantial milestone. Show me the restore command
for "undo everything since the last commit" and test it on a dummy file.

Payoff math 📊

Untapped #2 — A Test Battery That Runs Itself

The gap

The empire's critical gates — lead-assignment rules, suppression screens, quota caps, QC checks — are exercised by use and by ad-hoc verification scripts, not by a standing test suite. Past incident: a narrow database query made safety gates fail silently closed — exactly the class of regression a 5-line test catches the minute it's born.

The fix

Create a pytest suite for my critical rules: (1) the suppression screen
actually blocks a suppressed email; (2) the daily cap refuses item 19;
(3) the assignment rule never splits one company across two owners;
(4) the QC gate fails a 70-char subject. Use a COPY of the DB, never live.
Add a test.bat that runs all tests, and a CLAUDE.md rule: run tests before
any deploy; a red test blocks the deploy.

Payoff math 📊

A regression caught at test time costs ~2 minutes. The same regression discovered in production — wrong sends, silent gate failures — costs hours plus trust (his own incident logs price this precisely). Ten tests × ~30 seconds of maintenance vs. one prevented silent failure per quarter: the ROI isn't close.

Untapped #3 — Auto-Checkpoint Hooks (Discipline Without Willpower)

The gap

The checkpoint ritual (p74) — state files, briefs, master prompt — is LAW, but its execution rides on the session remembering to do it. History shows the pattern: rules enforced by memory eventually miss (that's why "mechanism beats intention" became his meta-law). A 4-hour scheduled backstop exists ✅; the per-session guarantee doesn't.

The fix

Configure a session-end/stop hook that automatically: (1) runs checkpoint.py,
(2) verifies CURRENT-STATE.md and NEXT-SESSION-BRIEF.md were modified in the
last hour — if not, flag loudly, (3) appends a one-line session summary to
checkpoints.log. Also add a session-START hook that prints the top of
NEXT-SESSION-BRIEF.md so every session begins briefed. Test both by starting
and ending a dummy session.

Payoff math 📊

Untapped #4 — Mint Your Routines Into Skills

The gap

The workstation runs elite skills (/forge, /webforge, /military-grade ✅) — but many DAILY routines still live as remembered procedures in memory files: the cockpit rebuild order (a 7-step sequence with a known trap), the deploy-verify ritual, the weekly hygiene sweeps. Each is executed correctly when remembered correctly — packaging them as skills would make them self-loading and trap-proof. The skill-creator tool sits installed and underused for exactly this.

The fix

Using skill-creator: turn my [cockpit rebuild] routine into a skill. Interview
me for the steps and the KNOWN TRAPS (e.g., "rebuild_all skips new fields",
"never run gen_outreach — it's dead and would clobber"). The skill must:
execute the steps in order, hard-stop on any trap condition, and end by
running the verification script and showing me the evidence.

Payoff math 📊

Each minted skill converts a ~15-line memory file + human vigilance into a one-word invocation with built-in guardrails. Five routines × a few uses weekly × minutes saved and mistakes prevented — but the REAL yield is transferability: a skill can be handed to a future teammate (or a future you, post-vacation) intact. Institutional knowledge stops living in one person's recall.

Untapped #5 — Deliberate Subagent Orchestration

The gap

After the cost blowouts (p79 #3), agent fan-outs went from reflex to near-taboo — a correct over-correction that's now leaving value unclaimed. The restriction has since lifted ✅, but the muscle memory remains solo-by-default even where parallel waves are clearly superior: independent QC of client-facing batches, vendor research triangulation, multi-file audit sweeps.

The fix — a dispatch doctrine (not a mood)

AGENT DOCTRINE: Solo by default. Fan out (2-4 agents, non-overlapping scopes,
explicit deliverable each) when: (a) independent review of anything
client-facing, (b) 3+ way research comparison, (c) audit of 10+ files.
Every dispatch states expected cost band first. Synthesis is one table.
Never exceed 4 agents without a fresh explicit GO.

Payoff math 📊

Untapped #6 — Plan Mode by Default Above a Size Threshold

The gap

Plans ARE law in this operation — "complete plan in chat, GO before execution" ✅ — but the enforcement is conversational, not modal. The difference: in true plan mode the AI is physically read-only until approval (p55); in conversational planning, an eager session can still start editing "helpfully" mid-plan. Rare, but the wrong-path builds that DID happen each started exactly there.

The fix

PLAN-MODE TRIGGER: any task expected to touch 3+ files, any schema change,
any change to a live/deployed system, any task I describe with "redesign",
"migrate", "restructure", or "new system" → enter plan mode FIRST. The plan
must include: files touched, risks, rollback path, and the verification
steps that will prove success. Execution only after my explicit approval.

Payoff math 📊

A plan costs ~2-5 minutes of reading. His own logs price the alternative: wrong-path builds have cost half-days plus unwind time. If the trigger fires 3×/week and prevents ONE wrong-path build a month, the lever pays ~10× monthly. 📊 (Planning also front-loads the ambiguity questions — half its value is the questions asked before any file exists.)

Untapped #7 — Scheduled AI: The 7am Chief of Staff

The gap

Tier-1 automation is mature here — scheduled Python everywhere (watchdogs, refreshes ✅). Tier-2 — scheduled AI judgment (p59) — is untouched: no morning brief, no automated anomaly narrator, no scheduled QC sweep with reasoning. Every morning starts with manual orientation that a timer-fired agent could pre-digest.

The fix

Create a scheduled agent, weekdays 06:30: (1) read CURRENT-STATE.md +
yesterday's progress file + the review queue + the send logs; (2) check the
SLA/verification outputs for anything red; (3) produce MORNING-BRIEF.md:
"overnight events / anything red with evidence / today's top 3 from the
brief / one risk I'm not watching". Keep it under 300 words. Never take
actions — report only.

Payoff math 📊

Untapped #8 — Run the Empire From a Phone

The gap

Operations are desk-bound: the machinery lives on one Windows machine, dispatchable only from its keyboard. Cloud Code sessions + the mobile app (p60) would make the whole system directable from anywhere — but they require the repos on GitHub, which requires Lever #1. Today, travel days are outage days.

The fix (the dependency chain, honestly)

Payoff math 📊

Every travel/hospital/family-emergency day converts from "operations frozen" to "operations directed from a pocket." For a one-operator company, resilience of the OPERATOR is resilience of the COMPANY — this lever is business continuity insurance priced at one evening of setup.

Untapped #9 — CI: Checks and Deploys That Run Themselves

The gap

Every deploy-verify today runs locally, launched by hand ✅. GitHub Actions — free automation that fires on every push ⚠️ (generous free tier) — would run the test battery (#2), the cockpit-standard verifier, and the link-checker on EVERY change automatically, then deploy only on green. The verify-gates exist; the factory conveyor doesn't.

The fix

Create a GitHub Actions workflow: on every push — (1) run the pytest battery,
(2) run verify_cockpit_standard and the link checker, (3) if ALL green,
deploy to Cloudflare Pages; if anything red, block and open an issue with
the failure evidence. Add a badge to the README showing current status.
Explain the workflow file to me line by line, plain English.

Payoff math 📊

Untapped #10 — Cloud Artifacts for Client-Facing Interactivity

The gap

Deliverables are already elite interactive HTML (p78 ✅) — self-hosted on Pages. Unused: the Artifact publishing surface (p19/p29) for the lighter tier — instantly-shareable interactive pieces (calculators, mini-audits, proposal companions) that need no deploy pipeline at all: generate → publish → send the link in the same conversation ⚠️ (plan-dependent publishing).

Where each belongs (the decision line)

The fix + payoff 📊

Build an interactive "revenue-leak quick estimator" for [prospect's industry]:
5 sliders (their metrics), live leak estimate with the math visible, one CTA
line at the end. My branding colors. Publish it and give me the link — I'm
sending it inside a reply within the hour.

📊 A custom interactive inside a same-day reply, vs. a PDF attachment next week: the impression gap IS the conversion gap in early sales. Cost: minutes. This lever monetizes speed-to-wow — and for YOUR practice (no deploy pipeline at all yet), published Artifacts are the zero-infrastructure way to ship p78-grade deliverables from day one.

Untapped #11 — App-Side Projects Per Vertical

The gap

All operational context lives in Claude Code's file world (CLAUDE.md, memory files ✅ — the right home for BUILD work). But strategy thinking — pricing debates, campaign angles, "should vertical #2 launch first" — happens ad-hoc in whatever chat is open, unbriefed. The chat app's Projects (p20) with per-vertical knowledge would make every strategy conversation start fully-loaded — especially from the phone, where Code isn't the natural surface.

The fix (an hour, once)

Payoff math 📊

Untapped #12 — Move Bulk LLM Work to Batch + Cache Economics

The gap

Bulk generation (personalization waves, page generation) currently runs through chat-credit sessions or a parallel rig sized for speed ✅ — correct for urgency, expensive-per-unit for the patient 80%. The p68 levers — batch −50%, cached context −90% on repeats ⚠️ — are understood but not wired into the standing pipelines.

The fix

Refit the [personalization] pipeline for batch economics: (1) restructure
prompts so the stable 90% (rules, examples, style guide) is a cached prefix
and only per-lead facts vary; (2) route non-urgent runs through the Batch API
with a morning results-collection step; (3) add a cost log per run so we SEE
the delta. Keep the fast path available behind a flag for genuinely urgent
waves. State expected cost per 1,000 items before and after.

Payoff math 📊 (illustrative shape, label-checked)

Untapped #13 — Systematic Visual QC via Browser Automation

The gap

The QC laws are strong — render-gates, screenshot-verification for client deliverables ✅ — but their EYES are still substantially human. The Playwright-class servers already installed (p53 ✅) could sweep every deployed page on every rebuild: sections present, no leaked template tokens, no invisible-text disasters, phone-width sane — with screenshot evidence filed automatically.

The fix

Build visual_qc.py using the browser tools: for each URL in pages.txt —
(1) load desktop + phone widths, (2) assert the required blocks exist (list
per page type), (3) scan text for template leftovers ("{{", "None", "[object"),
(4) screenshot both widths into qc/[date]/, (5) write PASS/FAIL per page with
the failing evidence. Wire it as the LAST step of every deploy; FAIL blocks
the deploy announcement. Run it now on the live pages and show me the report.

Payoff math 📊

Untapped #14 — Computer Use for Windows-Only Chores

The gap

Everything scriptable is scripted ✅ — but a residue of Windows-native, no-API chores still consumes operator hours: portal form-filling, GUI-only exports, settings hidden behind wizards. Computer use (p66's third tier — screenshots + clicks + typing) is installed and essentially idle for these.

The fix — with the tier's respect rules

Task: [the GUI chore, e.g., "export last month's statement from this desktop
app"]. Rules: (1) narrate each step BEFORE clicking; (2) I watch the first
two runs live; (3) screenshot before/after each consequential click into
logs/; (4) anything involving passwords or payments: STOP and hand to me;
(5) if the screen doesn't match expectations, STOP — never improvise clicks.

Payoff math 📊

Untapped #15 — Systematize the Voice Habit

The gap

Dictation is already the operator's primary input ✅ (this book's origin, p25) — but each voice-dump is processed ad-hoc in whatever session receives it. There's no standing voice pipeline: dictation → auto-classification → routed to state files / task lists / decision log. Structure is re-improvised every time.

The fix

Create a /brain-dump command: I paste (or dictate into) a messy transcript.
You: (1) split it into DECISIONS / TASKS (with owner+priority) / IDEAS /
QUESTIONS / FACTS-TO-REMEMBER; (2) append each to its home file
(DECISIONS.md, tasks file, ideas file, memory candidates); (3) show me the
routing table for a 10-second review before writing; (4) flag anything that
contradicts an existing decision or rule, citing it.

Payoff math 📊

Untapped #16 — Scheduled Memory & Rules Hygiene

The gap

The memory system is exceptional — 100+ curated files, an index, linking ✅. The gap is decay management: superseded entries linger (the index itself carries at least one "SUPERSEDED by…" note ✅), stale facts risk being recalled as current, and the constitution's own sharpness rule ("rules that never fire in 30 days get proposed for deletion") has no scheduled enforcer. A consolidation skill exists, unused on a cadence.

The fix

Run memory consolidation: (1) list entries contradicted by newer entries or
marked superseded — propose merges/deletions with evidence; (2) list memories
citing files/flags that no longer exist (verify each with a check, don't
assume); (3) list rules that haven't fired in 60 days — propose archive;
(4) produce a diff-style report; execute ONLY what I approve. End with the
index rewritten clean.

Payoff math 📊

Untapped #17 — Meter the Machine (Usage & Cost Analytics)

The gap

Cost DISCIPLINE is strong (GO-gates, one-GO-one-run ✅); cost VISIBILITY is impressionistic. No standing dashboard answers: usage by day? by project? which routine eats the plan? did last month's efficiency levers (#12) actually land? Tools exist idle: /usage, /cost, community meters (ccusage-class), API usage exports ⚠️.

The fix

Build usage tracking: (1) a nightly job appending /cost + /usage snapshots
(and API usage where applicable) to usage_log.csv with date + project tag;
(2) a weekly section in the morning brief (Lever #7): usage by project,
week-over-week delta, the single biggest consumer, and one concrete
efficiency suggestion with expected savings; (3) an alert line if any day
exceeds 2× my trailing average.

Payoff math 📊

Untapped #18 — Curated Allowlists: Fewer Prompts, Same Fences

The gap

Sessions run fast via broad trust earned over months ✅ — but the formal middle layer (p48) is under-curated: a written allowlist of always-safe commands (read-only git, ls, status checks, the standard verify scripts) vs. always-ask verbs (deletes, pushes, installs, anything touching live). Today that judgment lives in habit; new sessions/machines/teammates don't inherit habit.

The fix

Scan my recent session history for the read-only commands I approve
constantly. Write a settings allowlist: auto-allow those (git status/log/diff,
ls, the verify scripts, python checks that write nothing); ALWAYS-ask for:
rm/del, git push, installs, registry/scheduler changes, anything with "deploy"
or the DB files in the command. Show me the file, explain each rule, and
list what will now stop prompting.

Payoff math 📊

Untapped #19 — Worktrees: Two Claudes, One Repo, No Stepping on Toes

The gap

Parallel work today = parallel risk: two sessions in one folder can collide on the same files. Git worktrees (unlocked by Lever #1) give each session its own physical directory on its own branch — same repository, zero collisions — the infrastructure for "the guide build grinds in tree A while the urgent cockpit fix lands in tree B."

The fix (the whole skill is three sentences)

Create a worktree for [task-name] on a new branch; open a session there for
[the big slow task]. Meanwhile I'll keep this session on main for urgent
work. When the worktree task is done: verify, merge to main, remove the
worktree, and show me the merged diff summary.

Payoff math 📊

Untapped #20 — Headless Claude: The Glue of Full Autonomy

The gap

Scheduled Python is everywhere (Tier 1 ✅); scheduled AI is Lever #7. The bridge between them is headless mode — claude -p "instruction" running non-interactively inside any script — and, at product scale, the Agent SDK (the same machinery as a library). Today, pipelines that need judgment mid-flow still route through interactive sessions; headless would let the SCRIPT summon judgment exactly where needed and continue.

The fix — the sandwich pattern

rebuild_rotation.bat:
  python export_candidates.py            # deterministic: gather + filter
  claude -p "Read candidates.json; apply the assignment doctrine from
    CLAUDE.md; write assignments.json; list any lead you were unsure about
    in review.txt with reasons"          # judgment, headless, rails-bound
  python apply_assignments.py            # deterministic: validate + write DB
  python verify_counts.py                # the Evidence Law, in code

Deterministic bread, intelligent filling, verification crust — rails+engine+gate (p4) with the engine summoned programmatically.

Payoff math 📊

Untapped #21 — Speak Institution: .docx / .pptx / .xlsx Outputs

The gap

The house standard is interactive HTML (p78 ✅ — genuinely superior for humans reading on screens). But procurement departments, boards, and government offices ask for Word, PowerPoint, Excel — and the file-creation skills (p28) that would produce them at house-quality are installed and idle. Today an institutional ask would mean manual reformatting; that's artisan work a skill should own.

The fix

Create an "office-export" skill: given any of my HTML deliverables, produce
(a) a .docx with our branding (cover, headings, tables, page numbers),
(b) a 10-15 slide .pptx executive version (headline + evidence per slide,
speaker notes), (c) where the deliverable has data: an .xlsx appendix with
live formulas, not pasted values. House rules apply: real values only,
claim labels preserved, a final render-check before "done".

Payoff math 📊

Untapped #22 — Interrogate Your Own Databases Weekly

The gap

The databases hold answerable gold — funnel conversion by segment, response patterns by title/geography/day, cohort aging, which gift pages convert views to replies ✅ (the events are logged) — but analysis happens ONLY when a question is asked manually. No standing analytical heartbeat. The sqlite MCP (p53 ✅) makes this a one-ask lever.

The fix

Weekly analytics run against the leads DB (read-only): (1) funnel this week
vs trailing 4 (contacted → opened → replied → meeting), with the QUERY shown
for every number; (2) top 3 segments by reply rate (title band × industry ×
geography), minimum n=30 before claiming anything; (3) one "surprise" — a
pattern I probably don't know, with its evidence and a suggested experiment;
(4) write analytics/[date].md and add the headline to the morning brief.

Payoff math 📊

Untapped #23 — Harden the Fortress: Scans, Backups, Drills

The gap

Secret HANDLING is elite (never-in-chat law, redaction pipes, registry ✅ — born from p79 #5). The untapped ring: proactive scanning (is any secret sitting in a file about to be committed by Lever #1's git?), backup encryption + restore drills (backups exist; when was a restore last REHEARSED?), and injection-awareness audits for the pipelines that ingest strangers' content (scraped pages, inbound replies — p64 rule 4 at pipeline scale).

The fix

Security pass: (1) scan the workstation for secret-shaped strings (key
patterns, tokens) OUTSIDE the approved secret files — report locations only,
never values; (2) add a pre-commit hook blocking commits containing them;
(3) verify backups cover the DBs + state files, add encryption, and run a
RESTORE DRILL to a scratch folder — prove the restore works; (4) list every
pipeline that ingests external text and confirm each treats content as data
(no instruction-following on scraped/replied text). Report as a table:
risk / status / fix applied.

Payoff math 📊

Untapped #24 — Arm the Team: Live Playbooks Over Static Messages

The gap

The human sales team runs on deployed cockpits + playbook pages ✅ — strong. The untapped ring: shared AI context. Updates travel as posted messages; questions flow back to the operator; the team's collective learning (what worked in replies, objection patterns) lives in scattered chats. Team-shared Projects (p29) — or even a deployed FAQ page auto-built from their questions — would let the playbook ANSWER, not just inform.

The fix (privacy-shaped)

Payoff math 📊

Untapped #25 — The Stack Itself: Sequencing & The 100× Question

The 25th lever is meta: the levers MULTIPLY, and the multiplication has an optimal order. Here's the honest math and the sequence.

The tally ⚠️ (estimates, labeled — each page showed its own basis)

📊 Sum: roughly 14-22 operator-hours per week ⚠️ plus the unquantifiables (a prevented disaster, a caught regression, an evidence-based pivot). Against a nights-and-weekends operating budget of ~25-30 hours, that's not "100× productivity" as arithmetic — it's something better: the difference between a person running systems and systems running themselves with a person directing. That qualitative flip is the honest meaning of 100×.

The sequence (dependencies respected)

The $0-Stack Philosophy — Own Everything, Rent Almost Nothing

Part 8 is the supporting cast: the free tools around Claude that make everything in this book run at near-zero cost. But first, the philosophy that selects them — because tool choice is strategy.

The operator's three-layer law (battle-tested)

Why "free + owned" beats "cheap + rented" (the real arguments)

Python + SQLite — The Free Engine Room of Everything

Two boring, invincible technologies run every system in Part 6. Neither costs anything; both will outlive every startup on your phone.

Python — the language your AI speaks natively

• What it is: the world's most readable programming language — and the one LLMs write best, by a wide margin. You'll never write it; you'll READ it occasionally (p44's manager skill: spotting "that touches the wrong file").
• Why standard-library-first matters: the operator's house rule bans exotic dependencies where stdlib works. Fewer moving parts = scripts that still run in 5 years. Ask for it explicitly: "standard library only where possible."
• Install once: python.org → latest 3.x → tick "Add to PATH" (Windows). Claude Code handles the rest forever.

SQLite — a real database that is just… a file

The pairing pattern (you already built it)

Build-along #2 (p58) — SQLite stores → Python enforces → HTML displays — is the house architecture of everything from expense trackers to the cockpit to the diagnostics business. It has no subscription, no vendor, no expiry.

Cloudflare Pages, Workers & KV — A Global Company's Infrastructure, Free Tier

Everything you deploy in this book lands here ⚠️ (limits as of writing — always check current):

The three free pillars

Deploying is genuinely one sentence

Deploy this folder to Cloudflare Pages as [project-name]. First deploy: walk
me through the free account + one-time login. Every future time: just deploy
and give me the URL. Add "deploy" as a slash command for this project.

Worth knowing before you scale on it

• Custom domains are free to attach (the domain itself ~$10/yr at a registrar) — yourname.com on Pages costs the domain alone.
• Static-first architecture (p73's choice) means the free tier carries real businesses: pages are files; only tiny dynamic bits need Workers.
• Alternatives exist — Netlify (similar, kind free tier), GitHub Pages (simplest, public repos) — the pattern transfers; pick one and stop shopping.

Git + GitHub — The Free Safety Net (Arsenal View)

Pages 56 and 81 made the case; this page is the arsenal card — what the free tier actually gives you and the habits that extract it.

What free actually includes ⚠️

The three habits that matter (everything else is optional)

VS Code — The Free Window Into Everything

Visual Studio Code (free, Microsoft) is where you LOOK at what your AI is doing: files, folders, diffs, databases — one window. Non-coders: this is a file manager with superpowers, not a programming exam.

Why it earns a place in a non-coder's dock

The 15-minute setup

The Free-Tier Shortlist — Services That Earn Their Slot

Beyond the core stack, a small set of freemium services carry real weight ⚠️ (tiers change constantly — verify before depending; the operator's vendor law from p79 #1 applies to the PAID upgrade of every row):

The selection discipline (why this list is short)

• Each row survived the p106 three-layer test: the job genuinely can't be self-forged (deliverability infrastructure, form hosting with spam handling, scraping proxies).
• Each has a working free tier, not a 14-day teaser — you can operate at $0 until revenue justifies upgrades.
• Before ANY paid upgrade: independent reviews + a sample + 2 alternatives compared — the p23 due-diligence prompt exists for exactly this moment.

Local AI — Running Models on Your Own Machine

You can run open-weight models (Llama, Mistral, Qwen families ⚠️) on your own computer, free, offline, via Ollama (ollama.com — install, ollama run llama3, done). This page is the honest "when that's smart, when it isn't."

The honest comparison

Where local genuinely wins

• Radioactive-privacy drafts — content that must never transit any cloud (then refine the DE-identified version with Claude)
• Unlimited brainstorm/classification volume at literally zero marginal cost — bulk first-pass sorting the cloud model then reviews (a p68 economics play)
• Offline situations — flights, field sites, unreliable internet
• Learning how LLMs behave — poking a model you fully control teaches p7 viscerally

The Automation Landscape — Zapier, Make, n8n… and the In-House Answer

The daughter's generation will hear these names constantly, so here's the fair map — followed by the house position, which is unfashionable and correct for operators like this book's.

The fair map ⚠️

The house position (stated as strongly as it's held)

The honest decision rule (for everyone else)

• You have Claude Code + this book → in-house Python. You hold the cheaper, stronger position; use it.
• You're advising someone who WON'T direct AI (a relative wanting one Gmail→Sheets flow, zero appetite for more) → Zapier's free tier is honestly fine. Right tool for the operator they actually are.
• Either way: anything involving money, sending to humans, or bulk actions inherits the same laws — human gates, logs, kill switches (p59, p64).

The Wider Free-AI Shelf — What Else Deserves a Bookmark

Claude-first does not mean Claude-only. The complements worth knowing, each in one honest line ⚠️ (capabilities shift monthly):

The integration pattern (this is the skill)

Complements slot into Claude-run workflows, not beside them: transcription FEEDS the voice pipeline (p95); image prompts are WRITTEN by Claude; NotebookLM handles source-Q&A while Claude does the thinking, building, and shipping. One brain orchestrating instruments — not five apps fighting for the same job.

The Anti-Tool Rule — Part 8's Closing Discipline

The most contrarian page in the book, and among the most valuable: every tool you add is a tax — learning, maintenance, another login, another failure mode, another place your data lives. Tool minimalism is a competitive edge disguised as boringness.

The five-question gate (before ANY new tool, free or paid)

The audit that pays annually

Here's my tool list with what each does and costs: [list]. For each: (a) used
in the last 30 days? (b) overlaps another? (c) replaceable by a script in my
stack? Recommend: KEEP / REPLACE-IN-HOUSE / CANCEL, with reasoning and the
replacement plan where relevant. Be ruthless — defaults favor cancellation.

Before the Ten Paths — The Honest Math

This part was requested as "ways to make $10,000 a month from home." Here it is — but this book earns its trust by refusing to sell dreams, so the math page comes first and nothing after it contradicts it.

What $10K/month actually decomposes into 📊

The three-stage truth about ramp ⚠️

Path 1 — The Productized Audit (The Operator's Own Play)

First-client path (the unglamorous truth)

Path 2 — Deliverables Freelancing (Fastest First Dollar)

The weekend launch plan

Path 3 — Websites for Local Businesses

The acquisition play (this path lives or dies here)

Path 4 — Executive Ghostwriting & Content Engines

Landing the first two

Path 5 — Career Services: The Cockpit as a Business

Why this path suits first-timers unusually well

• Demand is ambient: everyone knows a job-seeker THIS MONTH. Your first 5 clients are one family WhatsApp announcement away — no cold anything.
• Results are visible fast: interviews land in weeks → testimonials with faces → referral physics.
• The empathy moat: p73's lesson — positioning candidates relative to each recipient, truthfully, kindly — is a QUALITY bar most competitors (spray-and-pray CV mills) never touch. Care, encoded, is the differentiation.

Path 6 — Lead Generation as a Service (Highest Skill Bar)

The offer ladder (risk-ordered)

Path 7 — Templates & Digital Products (The Volume Game)

The playbook that actually works

Path 8 — Courses & Paid Guides (Teaching as an Asset)

The format ladder (start small, climb with proof)

Path 9 — Back-Office Automation for Small Businesses

The engagement pattern (audit → quick win → retainer)

Path 10 — Data Services (Where Verification Culture IS the Product)

The trust-manufacturing playbook

The 30-Day Plan — Zero to Hero, Day by Day

Everything in this book, sequenced into ~45-60 minutes a day. Tick pages off in the sidebar as you go — the progress bar is your streak.

Week 1 — Foundations & fluency (Parts 0-2)

Week 2 — Prompting mastery (Part 3)

Week 3 — Hands (Part 4)

Week 4 — Systems & the road (Parts 5-9)

Glossary — Plain Words for Every Term

FAQ — Short Answers to the Questions Everyone Asks

The original four, now in one breath each

The ten that always follow

Your Next Move

The fork — choose by who you are today

A closing letter from the desk where this was built