AI Superpowers
for Everyone

How to Use This Guide

This is a field guide, not a textbook. There are no exams, no prerequisites, and no chapter you have to slog through before things get interesting. The goal is simple: get you from curious to actually doing things — as fast as possible, with no unnecessary detours.

The guide runs in three parts. Part 1 is about using AI chat (specifically Claude) as a force multiplier in your daily work and life — thinking, writing, researching, creating. You can start here right now, no technical background required. Part 2 covers the foundational tech layer underneath everything — APIs, the terminal, Git, security — so that when you start building, nothing feels mysterious. Part 3 is where you build things: real projects, real automations, tools that actually save you time.

Read it in order if you're starting from zero. Jump to whatever section solves your current problem if you're not. Every section ends with something you can actually do — a prompt to send, a command to run, an output you could show someone. That's the whole point.

Why This Moment Matters

Something real is happening right now. AI tools — not the science-fiction kind, but practical, available-today tools — have crossed a threshold where they are genuinely useful for ordinary tasks. Writing a tough email. Learning something new. Making a hard decision. Summarizing a 40-page document. Building a small piece of software without knowing how to code.

This is not hype. The tools exist, they work, and the people who learn to use them well are going to have a meaningful advantage — in their work, in their thinking, in what they're able to build.

The barrier isn't technical. You don't need a programming background. You don't need to understand how any of this works under the hood. What you need is a clear mental model of what these tools are good at, how to talk to them effectively, and the confidence to actually try things.

That's what this guide is for. Let's get into it.

The Five AI Chat Modes

Most people use AI chat the same way every time — they type a question and read the answer. That works fine. But there are at least five meaningfully different ways to use a tool like Claude, and each one unlocks something different. Think of these as modes, not features. Same tool, different posture, very different results.

Mode 1: Thinking Partner

The old advice for getting unstuck was to explain your problem to a rubber duck — an inanimate object that forces you to articulate what you're actually thinking. The theory: the act of explaining often reveals the answer. It works, but the duck doesn't talk back.

Claude does. This makes it something qualitatively different: a thinking partner that can ask clarifying questions, offer frameworks you haven't considered, poke holes in your reasoning, and help you see a decision from multiple angles. It's not magic — it doesn't know your situation better than you do. But it can help you think out loud in a way that moves you toward clarity.

This mode is most powerful for decisions with multiple competing factors, conversations you're nervous about, plans that feel fuzzy, and situations where you're not sure what you're actually trying to optimize for.

Mode 2: Research and Synthesis

Claude has processed an enormous amount of text and can give you useful overviews of almost any topic — from how a specific medical treatment works to the landscape of CRM software options to the history of a legal concept to what's actually in that 80-page contract you need to understand by tomorrow.

This mode is genuinely useful. But it comes with a rule that's worth taking seriously: don't just accept what Claude tells you. Verify it. Claude can hallucinate — generate text that sounds confident and correct but is factually wrong or made up. It doesn't always know what it doesn't know. And its training data has a cutoff, which means anything that happened recently may be wrong or missing.

Use Claude to understand terrain, not as a primary source. Ask it to explain how something works, give you a framework for thinking about a topic, or summarize a document you paste in. Then use that understanding to ask better questions elsewhere.

The document summary use case is particularly strong. Paste in a long document — a lease, a contract, a research paper, a terms of service — and ask Claude to summarize it, identify the key terms, flag anything that looks unusual, or explain a specific section in plain English. This is one of the highest-value things you can do with an AI chat tool and it requires no technical skill whatsoever.

Mode 3: Writing and Communication

Writing is where most people first get real value from AI chat, and for good reason: drafting is hard, editing is tedious, and getting the tone right is genuinely difficult. Claude is good at all three.

The key to using this mode well is being specific about what you want. "Write an email" is a weak instruction. "Write a professional but warm email to my landlord asking him to fix the broken heater — I've already asked twice and I want to be firm without being aggressive, keep it under 150 words" is a much better one.

Mode 4: Learning Accelerator

Claude is a patient, infinitely available tutor that can explain almost any concept, adjust its explanation based on your level, and quiz you until something sticks. This is one of the most underused ways to interact with AI chat.

The difference between reading an explanation and learning something is active engagement. Claude supports this in ways that passive content cannot: ask it to explain the same thing three different ways until one clicks, ask follow-up questions without embarrassment, have it quiz you, ask it to connect a new concept to something you already understand.

Mode 5: Creativity

Creative blocks are often just a shortage of raw material — you don't have enough options to choose from. Claude is excellent at generating quantity: ten ideas instead of one, five angles instead of the one you've been stuck on, a dozen names when you're running out of steam.

This mode works for brainstorming, ideation, naming, concept generation, worldbuilding, coming up with examples, finding analogies, and getting unstuck when you've been staring at a blank page for too long.

The key posture for this mode: use Claude to generate options, not to make the final call. You're the creative director. Claude is the overachieving junior staffer who will try anything you ask and never complains about iterations.

Prompting Fundamentals

A prompt is not just a question. It's an instruction, a context package, and a format spec all at once. Most people write weak prompts — not because they're doing anything wrong, but because no one told them how. Here are the three moves that change everything. For advanced techniques including prompt chains, code generation, and working with AI in professional workflows, see the Prompting field guide.

Move 1: Give Context

The single biggest difference between a weak prompt and a strong one is context. Claude knows nothing about you, your situation, your constraints, or your goals unless you tell it. Context has three layers: who you are (or who the output is for), what you're trying to accomplish, and what you've already tried.

Move 2: Be Specific About Output Format

Claude can produce almost any format you want — but only if you tell it what format that is. Spend ten extra seconds specifying the output and save yourself multiple rounds of editing. Useful things to specify: length ("under 200 words"), tone ("professional," "warm," "like a friend explaining it"), audience, and structure ("as a table," "in the format of an email").

Move 3: Iterate Rather Than Starting Over

When Claude's first response isn't quite right, the instinct is to close the chat and start fresh. Don't do that. The conversation is the product. Each iteration builds on what came before. When you get an output that's close but not right, tell Claude specifically what's wrong: "This is too formal," "The third section misses the point," "Make this shorter without losing the key message."

The 60+ Prompt Library

These are ready to copy and use. Each one is complete — paste it into Claude, fill in the bracketed parts with your specifics, and send. They're organized by category so you can find what you need fast.

Planning and Decisions

Writing and Communication

Research and Learning

Work and Productivity

Creative Projects

Personal Life

Understanding Complex Topics

Part 1 Quick-Start Exercise

Let's put everything in Part 1 to work on a real task. We're going to write a tricky email together — the kind most people put off because they don't know how to thread the needle between firm and polite.

The scenario: Your apartment's kitchen faucet has been dripping for six weeks. You told your landlord about it three weeks ago. He said he'd get someone out. Nothing has happened. You need to send a follow-up that gets results without burning the relationship.

Step 1: Go to claude.ai and start a new conversation.

Step 2: Send this prompt — "I need to write an email to my landlord following up on a repair that hasn't been fixed. The issue: my kitchen faucet has been dripping since [date]. I reported it on [date]. He said he'd get someone out but nothing has happened. I want to send a message that is firm and makes clear I expect this to be resolved soon, but that doesn't come across as aggressive. Please give me two versions: one shorter and more direct (under 100 words) and one slightly warmer and more detailed (150-200 words)."

Step 3: Read both versions. Notice which one sounds more like you.

Step 4: Pick the version you like better and give Claude specific feedback — "I like the second one but it's a bit too formal," or "Can you add a line asking him to confirm a date?" You're not starting over. You're building on what Claude gave you.

How the Web Works

Here is everything that happens in the half-second between you pressing Enter on a web address and a page appearing on your screen. Understanding this takes about five minutes and will make everything else in this guide click into place.

Files, Servers, and Browsers

Every website is, at its core, a collection of files. There are files for the layout (HTML — HyperText Markup Language, the structure of a page), files for how it looks (CSS — Cascading Style Sheets), and files for anything interactive (JavaScript). Those files live on a server — a computer that listens for requests from the internet and sends back responses. When you visit a website, a server somewhere receives your request and sends your browser the page files.

Your browser — Chrome, Safari, Firefox — is the program that makes those requests and then renders the files into the visual page you see. The browser asks; the server answers; the browser displays what it gets back.

What HTTP Is

HTTP (HyperText Transfer Protocol) is the set of rules that governs how web browsers and servers communicate. When you type a URL and press Enter, your browser sends an HTTP request to the server. The server sends back an HTTP response containing the page content, plus a status code. 200 means everything is fine. 404 means "I can't find that file." 500 means something broke on the server's end.

HTTPS is the secure version — the connection is encrypted. That's why you want to see the padlock icon in your browser bar on any site where you log in or enter a credit card.

APIs and API Keys

You are going to use APIs constantly. Every AI tool you connect to, every weather feed you pull, every service that sends data to something else — it all runs through APIs. Before you touch one, you need to understand what an API key is and why it matters that you handle it correctly.

What an API Is

An API (Application Programming Interface) is a defined way for two software programs to talk to each other — a waiter that carries your request to the kitchen and brings the result back. The API defines what requests are valid, what format they should be in, and what format the responses will come back in. When Claude Code fetches data from a weather service, it is calling that service's API. When you sign up for Anthropic's API to use Claude in your own tools, you are getting access to an API.

What an API Key Is

To use most APIs, you need an API key — a secret code that identifies you to the API service, similar to a password, that lets the service know who is making requests and whether to charge them. It usually looks like a long string of random characters: sk-ant-api03-abc123xyz.... This key is how the service knows the requests are coming from you, tracks your usage, and bills you.

Where API Keys Live: The .env File

API keys do not belong in your code. They live in a file called .env. A .env file stores secret values — like API keys — separately from your code, so they never appear in your codebase or on GitHub. Your code reads these values by name; it never has the actual key written inside it. For a deeper understanding of REST, authentication, rate limiting, and building integrations, see the APIs field guide.

ANTHROPIC_API_KEY=sk-ant-api03-your-key-here
OPENAI_API_KEY=sk-proj-your-other-key-here
WEATHER_API_KEY=your-weather-key-here

Markdown

Markdown is the formatting language of the developer world, and you already know more of it than you think. If you've ever used **bold** in a Slack message or started a line with # in a note and had it become a heading, you've used Markdown. It takes about twenty minutes to learn the part you'll actually use.

Markdown is a lightweight way of formatting text using simple symbols — like # for headers, ** for bold, and - for list items — that is readable as plain text but renders as formatted output in GitHub, documentation tools, and many AI chat interfaces.

The Five Elements That Cover 90% of Use Cases

# Big heading (H1)
## Medium heading (H2)
### Smaller heading (H3)

**bold text** and *italic text*

- Bulleted list item
- Another item

1. Numbered list
2. Second step

`inline code` or triple backticks for code blocks

[Link text](https://url-here.com)

JSON

JSON will show up constantly once you start working with APIs and AI tools. You do not need to write it or parse it programmatically. You just need to be able to read it without panicking. That takes about ten minutes.

JSON (JavaScript Object Notation) is a text format that most APIs use to structure and exchange data. Despite the name, it has nothing to do with JavaScript as a programming language — it's just a universally agreed-upon format for data. Almost every API in existence uses it.

The Pattern: Read This Once and You'll Know It

JSON is made of two building blocks. Objects — a set of key-value pairs, wrapped in curly braces {}. Arrays — an ordered list of items, wrapped in square brackets []. These two structures nest inside each other. That's how you get complex data in a readable format.

{
  "location": { "city": "Chicago", "state": "IL" },
  "current": {
    "temp_f": 42,
    "condition": "Partly cloudy",
    "humidity_percent": 68
  },
  "forecast": [
    { "day": "Tuesday", "high_f": 45, "condition": "Rain likely" },
    { "day": "Wednesday", "high_f": 39, "condition": "Snow showers" }
  ]
}

Reading this: the outer object has three keys. location is itself an object. current is an object with weather readings. forecast is an array (note the square brackets) containing two objects — one for each day.

How AI Models Actually Work

Understanding a few things about how AI models work will make you a significantly better user of them. Not because you need to know the math — you don't — but because the mental model changes how you prompt, how you interpret outputs, and how you react when something goes wrong.

Tokens: The Unit AI Thinks In

AI models do not read words. They read tokens — the unit an AI model uses to process text. Roughly one token equals three to four characters or about three-quarters of a word. Models have limits measured in tokens, not words or pages. Every AI service charges by the token and limits conversations by the token. When you understand tokens, the pricing and limits make sense.

Context Windows: The Model's Working Memory

A context window is the amount of text a language model can "see" and work with in a single conversation — everything above this limit is invisible to it. Think of it as a scrolling notepad with a fixed size. Every message you send, every response the model gives, every document you paste in — it all goes on the notepad. Once the notepad is full, older content scrolls off and disappears. The model does not archive it. It simply stops seeing it.

This is why Claude might seem to "forget" something you said at the beginning of a long conversation — that message has literally fallen out of the context window. It is a hard technical limit, not a memory failure. Practical takeaways: paste the most relevant context at the start of each new conversation. If something seems "forgotten," repeat it.

Why Hallucination Happens

Hallucination is when an AI model generates text that sounds confident and plausible but is factually wrong or made up. It happens because the model predicts likely-sounding words rather than retrieving verified facts. The model is not lying — it is producing a plausible-sounding answer based on patterns. It has no internal signal that says "I am making this up."

The Terminal

The terminal is one of those tools that looks intimidating until the moment it clicks, and then it feels like a superpower. You type a command, the computer does it. No clicking through menus. No waiting for a UI to load. Everything Claude Code does happens through the terminal.

The terminal is a text-based interface for giving your computer direct commands by typing — also called the command line or shell. On a Mac, open it by pressing Cmd + Space, typing "Terminal," and pressing Enter. On Windows, use Windows Terminal or PowerShell. For a deeper dive into shell commands, scripting, and customization, see the Terminal field guide.

Five Commands That Cover 80% of What You'll Need

ls          # lists files in your current location
cd Desktop  # navigates into the Desktop folder
cd ..       # goes up one level
mkdir my-project  # creates a new folder
touch hello.txt   # creates a new empty file
rm hello.txt      # deletes a file (permanent — no undo)
which node  # confirms node is installed and shows where
node --version    # checks which version is installed

Files, Folders, and Project Structure

When Claude Code generates a project for you, it will create a folder with a specific structure — multiple files, each with a purpose. Once you know what each piece is for, you can navigate any project confidently.

my-morning-briefing/
├── README.md       # explains what the project does
├── .env            # your secrets — never shared or committed
├── .gitignore      # tells Git which files to ignore
├── package.json    # project manifest and dependencies
├── index.js        # the main code file
└── utils/
    ├── weather.js
    └── calendar.js

README.md — the welcome mat. Explains what the project does and how to run it. .env — your secrets file. API keys live here in KEY=value format. Never gets shared or pushed to GitHub. .gitignore — tells Git which files to ignore. The .env file is always listed here. package.json — the project manifest. Lists dependencies that get installed when you run npm install.

Git Basics

Git is the tool that saves your project's history. Every meaningful change you make, you save a snapshot of it. If something breaks, you can go back. Think of it like a video game save system, except it saves everything and lets you describe each save point in plain English.

Git is a version control system that tracks every change you make to a set of files, letting you go back to any previous state. The folder Git is tracking (with its history) is called a repository — a project folder containing all your files plus the full history of every change you've ever committed.

The Three Commands You'll Use Constantly

git add .                          # stage all changed files
git commit -m "Added weather API"  # save a snapshot with a message
git push origin main               # send commits up to GitHub

Think of git add as selecting which changes go into your next snapshot. git commit creates the snapshot with a message you write yourself. git push sends your committed snapshots from your local computer up to GitHub so they're stored in the cloud. For branching, merge conflicts, and more advanced workflows, see the Git field guide.

GitHub

GitHub is where your code lives in the cloud. It's your backup, your portfolio, and (in Part 3) your deployment platform. Git is the tool running on your computer. GitHub is the website — cloud storage and collaboration for Git repositories.

Go to github.com and create an account. Enable 2FA (Two-Factor Authentication) before you do anything else — GitHub will prompt you for this during setup. Use an authenticator app rather than SMS if possible.

Creating a Repository and Pushing

Click + in the top-right corner of GitHub and choose New repository. Give it a name (use lowercase letters and hyphens, not spaces). Check "Add a README file." Click Create repository. Then to connect it to a local project:

git remote add origin https://github.com/yourusername/your-repo.git
git branch -M main
git push -u origin main

After that initial connection is made, the workflow is the same every time: edit code, git add, git commit, git push.

Environment Setup

Before you can build with Claude Code, your computer needs three things: a code editor, and the runtimes that let code actually run. This section walks through installing them and nothing else — you are not learning to code here, you're making sure the tools exist.

VS Code: Your Code Editor

VS Code (Visual Studio Code) is a free code editor made by Microsoft — the most widely used tool for writing and viewing code. Download it at code.visualstudio.com. The three important parts: the sidebar (file explorer), the editor area (where files open), and the integrated terminal — open it with Cmd + ` on Mac or Ctrl + ` on Windows.

Node.js and Python: The Runtimes

Node.js lets JavaScript code run on your computer. Download the LTS version at nodejs.org. After installation: node --version should return a version number. Node also installs npm — verify with npm --version.

Python is a widely used programming language. Mac users, check first: python3 --version. If you see a version, you're done. If not, download at python.org. Windows users: during installation, check "Add Python to PATH."

Security

Security is not a checklist you complete before you "go live." It is a set of habits you build from the moment you start making things. This section pulls together all of it in one place. Read it before you start any Part 3 project.

API Keys and Secrets

Three rules that are non-negotiable: never put an API key directly in a code file. Never paste an API key into a chat window — not Claude, not ChatGPT, not Slack, not GitHub. Never commit an API key to Git. The mechanism that enforces all three: the .env file, combined with .gitignore.

What .gitignore Does

A minimal .gitignore for almost any project:

.env
node_modules/
.DS_Store

When Claude Code generates a project, it will usually create a .gitignore automatically. Check it before your first push. Confirm .env is in there.

Permissions and Prompt Injection

Principle of least privilege: only give tools the access they actually need. If a script only needs to read your calendar, it should not have permission to send emails. When authorizing a new app with Google, read the permissions list — "Read calendar" is very different from "Read, compose, send, and delete all email."

Prompt injection is an attack where malicious instructions are hidden inside content that an AI agent reads — like a webpage or document — to hijack the agent into doing something you never intended. As you build automations that process external content, design them with skepticism. Always build in a confirmation step before any irreversible action (sending an email, making a purchase, deleting a file).

Account Security

Use a password manager (1Password, Bitwarden, or iCloud Keychain). Enable 2FA on GitHub, the Anthropic Console, and every AI platform you use. An authenticator app is more secure than SMS-based 2FA. For a comprehensive treatment of secrets management, HTTPS, dependency risks, and more, see the Security field guide.

What Claude Code Actually Is

Before you install anything, you need to understand what Claude Code actually is — not technically, but conceptually. Because once you get this, everything else in Part 3 will click.

Claude Code is an AI that lives in your terminal and can touch your files. A regular Claude conversation lives in a browser window. You type, Claude responds. Nothing happens to your computer. Claude Code is different. It runs inside your terminal. When you give it an instruction, it doesn't just respond with words — it can create files on your computer, read files that already exist, run code to test whether something works, and make changes.

The mental model you need is this: You are the architect. Claude Code is the builder. When you hire a contractor, you don't need to know how to wire electricity or hang drywall. You need to know what you want the finished room to look like. You need to describe it clearly. You need to say "that window is in the wrong place — move it." That is your job. Claude Code's job is the technical details of actually building it.

Claude Code Setup

Getting Claude Code installed and running takes about ten minutes if you've completed the environment setup in Part 2. Here's how to do it from start to finish.

Step 1: Install Claude Code

Open your terminal. Type the following exactly and press Enter:

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

The -g flag means "install globally" — so you can use it from any folder on your computer. You'll see a stream of text as the installation runs. When your terminal prompt reappears at the bottom, the installation is complete.

Step 2: Get Your API Key and Store It

Go to console.anthropic.com. Click API Keys → Create Key. Give it a name like "claude-code-local." Copy the key — you will only see it once. Then store it:

export ANTHROPIC_API_KEY="your-key-here"

For a permanent setup (so you don't have to do this every time you open a new terminal), add this line to your .zshrc or .bash_profile file. Claude Code can walk you through this if you ask it.

Step 3: Verify and Launch

cd ~/Desktop
mkdir my-first-project
cd my-first-project
claude

You should see Claude Code's interface appear — a prompt waiting for your first instruction. Type "Say hello and tell me what tools you have available." If you see a response, you're set up and ready to build.

The Three-Question Brief Framework

Before you write a single prompt to Claude Code, you need to know what you're building. Not in technical detail — you don't need to know which programming language or which libraries. You need to know the thing in human terms. The Three-Question Brief is how you do that. It takes five minutes and will save you hours of going in circles.

The Three Questions

Question 1: What is this for, and who will use it? A tool built for yourself to use in the terminal every morning is a completely different thing from a tool your whole team uses in a browser — even if they technically "do the same thing."

Question 2: What does it do — and what does it NOT do? The "does not do" part is just as important as the "does" part. Writing it out forces you to make decisions and keeps scope from growing until the project is impossible to finish.

Question 3: What does done look like? Not a perfect system — the first version of anything is never perfect. Just the first working version. Be specific and concrete: "I can run one command in the terminal and see a formatted morning briefing printed to the screen." That is a real definition of done. "It works well" is not.

Debugging by Describing

Something will not work. That is not a flaw in the plan — it is part of the plan. What matters is what you do when something goes wrong. The good news: with Claude Code, the way you fix problems is the same as the way you build things. You describe what is happening in plain English.

The principle: describe, do not decode. Error messages are written for developers who already know the codebase. Trying to decode them on your own is often the long way around. The short way: describe what you expected to happen, describe what actually happened, and paste the error message if there is one. Let Claude Code do the decoding. For systematic debugging techniques beyond AI-assisted workflows — binary search, stack traces, browser DevTools — see the Debugging field guide.

Five Example Projects

These are real projects you can build with Claude Code. Each one has a defined, showable output — something you could pull up on your laptop and demonstrate to someone in about thirty seconds. Start with the one that solves a problem you actually have. That is always the right first project.

Project 1: Personal Webpage

What you're building: A simple, clean personal webpage — your name, a short bio, a few things about you, and optionally some links. Something that looks intentional and professional and lives at a real URL.

Why this one first: A webpage is the clearest possible demonstration that you built something. You can open a browser, type an address, and show someone the result. It is the most shareable possible first project.

Project 2: Morning Briefing Script

What you're building: A script that pulls together the things you want to see at the start of your day and displays them in the terminal. One command, and your morning context appears.

Why this project matters: Most people start their day by opening five different apps and tabs to piece together the same information they check every single morning. This script collapses that into one command.

Project 3: Smart Journal

What you're building: A command-line journaling tool that saves entries with the date and time automatically, and lets you search through past entries by keyword. Because you built it, you can change it whenever you want — add tags, mood tracking, a command that summarizes the week.

Project 4: Email Automation

What you're building: A script that drafts emails for you based on a template and context you provide. You run the script, give it a few details, and it outputs a complete draft you can copy and send. Most email takes time not because the message is complicated but because starting from a blank page is hard.

Project 5: Research Assistant Agent

What you're building: An agent that takes a topic you give it, gathers information, and produces a structured research summary you can actually use. Research is one of the highest-time-cost tasks in most knowledge work — this automation does the first two steps (finding and reading) and gives you a head start on the third (synthesizing).

Automation: The Core Mental Model

You've built five projects. You know Claude Code can make things. Now let's talk about the pattern underneath every useful automation — the one framework that, once you internalize it, will let you design automations for basically any situation you encounter.

Every automation, no matter how simple or complex, is the same three things: Trigger → Process → Output.

A trigger is the event that starts the automation — something happens, or is scheduled to happen, and that kicks everything else off. A process is what the automation actually does — it reads something, calls an API, runs a script, calls Claude, analyzes data. An output is what the automation produces — a file, an email, a Slack message, a terminal display. Something exists after the process runs that did not exist before.

Automation: Personal Productivity

Personal productivity automations affect your own daily experience — how you start your day, how you manage information, how you prepare for what's coming. They're also the easiest place to start because you control all the inputs. You build it, you use it, you immediately feel whether it works.

Pattern 1: Morning Briefing

Trigger → Process → Output: Every morning at a scheduled time → call weather API, read task list, optionally call Claude to generate a daily focus sentence → formatted text in your terminal, or an email to yourself, or a Slack message to a personal channel.

Setting up a schedule trigger: On a Mac, you can use cron (a tool that runs commands at scheduled times) to run your script automatically. Ask Claude Code: "How do I set up a cron job on Mac to run my briefing.py script every weekday at 8am?" It will give you the exact command.

# Prompt to build the briefing
"Build a morning briefing script that: fetches today's weather for [city]
using the Open-Meteo free API, reads my top 3 tasks from ~/tasks.txt,
calls the Anthropic API to generate one sentence suggesting my most
important focus for the day based on the tasks, and prints all three
sections with clear headers. Format it cleanly."

# Prompt to automate it
"Set up my morning briefing to run automatically every weekday at 7:30am
on my Mac using cron. Show me the exact cron command and explain how to
add it without breaking anything already scheduled."

Pattern 2: Inbox Triage

Trigger → Process → Output: A scheduled time each morning → connect to your email via API, read subject lines and senders, call Claude to categorize and summarize → a formatted list showing: emails that need action today, emails to review later, and emails you can safely ignore.

Both Gmail and Outlook require OAuth authentication. Claude Code handles the setup — the first time you run the script, it will open a browser window asking you to authorize access. After that, it runs silently.

"Build an inbox triage script that connects to my Gmail account using the
Gmail API, reads the last 20 unread emails (subject, sender, first 200
characters of body), calls Claude to categorize each one as: ACTION
(needs a response today), REVIEW (worth reading but not urgent), or SKIP
(newsletters, notifications), and prints a categorized summary with the
most important emails at the top. Walk me through the Google API setup
step by step."

Automation: Team and Work Outputs

Team and work output automations create documents, reports, and communications that you used to produce manually. The defining characteristic: the output goes somewhere outside your personal workflow — to your team, your manager, your client, or a shared document system.

A note on trust: automated outputs that go to other people need a higher bar for review than automations that only affect you. Build in a review step. Never set up an automation that sends an email or publishes a document without you seeing it first.

Pattern 1: Weekly Status Reports

Trigger → Process → Output: Every Friday at 4pm → read your notes folder for the current week, call Claude to synthesize into a structured report with: key accomplishments, work in progress, blockers, and next week's priorities → a formatted Markdown document saved to a shared folder, or a draft email to your manager.

"Build a weekly status report generator. It should: read all .md files in
my ~/notes/YYYY-WW/ folder (current week format), call Claude to synthesize
them into a status report with four sections: Accomplished This Week,
In Progress, Blockers, and Next Week's Priorities. Save the output as
StatusReport-[date].md on my Desktop and show me a preview. Do not send
or share anything — just create the draft."

Pattern 2: Client Brief Generators

Trigger → Process → Output: You run the script manually when starting a new client project → the script asks you 8-10 structured questions, feeds your answers to Claude → a formatted document saved to a client folder, ready for review and sharing.

"Build a client brief generator that runs as an interactive command-line
questionnaire. It asks me: (1) client name and company, (2) project name,
(3) the core problem we're solving, (4) the desired outcome, (5) timeline
and key milestones, (6) key stakeholders, (7) known constraints,
(8) how we'll measure success. After I answer all questions, it calls
Claude to format my answers into a professional client brief and saves it
as [ClientName]-Brief-[date].md."

Automation: Data and Files

Data and files automations take documents, spreadsheets, PDFs, and raw data and turn them into insights, summaries, and structured outputs. This category often produces the most immediately visible time savings — reading a 40-page PDF manually takes an hour; this automation takes thirty seconds.

One important note: be thoughtful about what data you send to the API. Do not send data containing other people's personal information, proprietary company data, or information covered by NDAs without verifying that your organization's policies permit it.

Pattern 1: PDF Summarizers

Trigger → Process → Output: You run the script with the PDF filename as an argument → extract text from the PDF, send it to Claude with instructions to summarize → a Markdown file saved alongside the PDF with the key points, action items, and questions the document raises but doesn't answer.

"Build a PDF summarizer script. I run it with: python summarize.py doc.pdf
It should: extract text from the PDF using pdfplumber, send it to the
Anthropic API asking for: a 3-sentence overview, the 5 most important
points, any recommendations or action items, and 3 questions the document
raises but doesn't answer. Save the output as [filename]-summary.md. If
the PDF is too long, chunk it and summarize each chunk, then synthesize."

Pattern 2: Spreadsheet Analyzers

Trigger → Process → Output: You run the script with the file path as an argument → read the spreadsheet using pandas, generate summary statistics, send to Claude for analysis → a written analysis saved as a Markdown file, plus optionally a chart saved as an image.

"Build a spreadsheet analyzer: python analyze.py data.csv
It should: read the file using pandas, calculate basic statistics (row
count, column names and types, missing data), identify the 3 columns most
likely to be key metrics, call Claude asking it to: describe what this
data appears to be tracking, identify the 3 most notable patterns or
anomalies, and suggest 2-3 questions worth investigating. Save as
[filename]-analysis.md."

Pattern 3: Contract Scanners

Trigger → Process → Output: You run the script with the contract PDF as an argument → extract text, send to Claude with instructions to identify and explain key contract terms → a structured plain-English summary with a "questions to ask before signing" section.

Important: this is a reading aid, not legal advice. Use it to identify what to ask a lawyer about — not as a substitute for professional legal review.

"Build a contract scanner: python scan-contract.py contract.pdf
It should extract text and call Claude with this task: 'Identify and explain
in plain English: (1) payment terms and amounts, (2) duration and renewal
terms, (3) termination conditions for both parties, (4) any IP provisions,
(5) liability and indemnification clauses, (6) any non-compete terms. For
each section, explain what it means in one sentence and flag anything
unusual. Also generate Top 5 Questions to Ask Before Signing — specific
to what this contract actually says.' Save as [contract-name]-review.md."

Where to Go From Here

You've come a long way. You understand how the web works, how AI models work, and how to talk to both of them. You've built five projects and designed automations that run on your behalf. You have the foundation. What comes next is up to you.

n8n and Make (formerly Integromat) are visual automation platforms — tools that let you build the same Trigger → Process → Output workflows you've been building, but with drag-and-drop interfaces and hundreds of pre-built connectors to apps like Gmail, Slack, Notion, Airtable, and more. Both have free tiers.

More complex agents are the horizon of what AI can do right now. An agent can browse the web, read emails, manage a calendar, and make decisions — autonomously, over a sequence of steps. As the underlying AI capabilities improve, these agents become more capable and more reliable. Learning to design and direct agents is one of the highest-leverage skills you can build in the next year.

The skill that transfers everywhere is the one you've already built: the ability to describe clearly what you want and to iterate toward it. That skill works in every AI tool you will ever use, not just Claude Code. You are not at the beginning anymore. You are at the beginning of the next part.

Ready-to-Use Prompts That Work

Complete, copyable prompts across the most common use cases. Each one is written to work from a cold start. Paste, fill in the bracketed parts, and send.

Thinking and Decisions

"I'm trying to decide between [Option A] and [Option B]. Here's my situation:
[2-3 sentences of context]. Here's what I care most about: [your top 1-2
priorities]. Play devil's advocate on the option you think I'm leaning toward,
then give me your honest recommendation and the most important question
I haven't asked yet."

"I'm stuck on [problem]. Here's what I've already tried: [list]. Here's what
I know for sure: [constraints]. Don't give me the obvious answer — push past it.
What's the framing I might be missing?"

"I'm planning to [thing you're about to do]. Imagine it's six months from now
and it went badly. What went wrong? List the three most likely failure modes.
Then tell me what I should do in the next two weeks to prevent each one."

Writing and Communication

"Write a [professional / warm / direct] email to [recipient description].
The situation: [2 sentences]. What I need them to do: [specific ask]. Tone
should be [tone]. Keep it under [word count] words. Do not use these phrases:
'I hope this email finds you well,' 'Please don't hesitate,' or 'Best.'"

"Here's a draft I wrote: [paste draft]. Improve it. Make it clearer, sharper,
and more likely to get a response. Show me the revised version, then explain
in two bullet points what you changed and why."

"Here are my notes from a meeting: [paste notes]. Extract: (1) decisions made,
(2) action items with the person responsible and deadline, (3) open questions
that still need answers. Format as a clean list I can share with the team."

Research and Synthesis

"Give me the definitive overview of [topic] written for a smart non-expert.
Structure it as: (1) what it is in one paragraph, (2) why it matters, (3) the
three things most people get wrong about it, (4) what I should read next if I
want to go deeper. Cite specific sources where possible."

"Here is a [report / article / transcript]: [paste document]. Give me: a
3-sentence summary, the 5 most important points, any specific recommendations
or numbers I need to know, and one thing this document says that surprised you
or seems worth questioning."

Learning

"Explain [concept] to me like I'm smart but have no background in [field].
Use one analogy from everyday life. Then give me three questions I should be
able to answer if I've understood it correctly."

"I'm trying to learn [topic]. Ask me 5 questions — progressively harder — to
test whether I actually understand it, not just whether I've heard the words.
After each answer, tell me if I'm right and fill in any gaps."

Claude Code Prompts

"I want to build [plain-English description of project]. Before you write any
code, ask me the three questions you need answered to build exactly what I
described rather than the most common interpretation. Then build it."

"This is what I expected to happen: [describe expected behavior]. This is what
actually happened: [describe actual behavior]. Here is the error message:
[paste error]. What is wrong and what is the fix? Show me exactly what to change."

"Explain this code to me in plain English, section by section: [paste code].
For each section, tell me what it does, why you did it that way rather than
another way, and what would break if I deleted that section."

The Prompting Formula

Use this structure when the freeform approach is not producing the results you want. It works for Claude, for Claude Code, and for any other AI tool.

I am [who you are — your role, context, and relevant background].

I want to [your goal — be specific about what you are trying to accomplish].

The output should be [format + length + tone — tell it exactly what done looks like].

Here is the relevant context: [everything Claude needs to know that it cannot
figure out from the goal alone].

Why this formula works: It gives Claude the four things that determine output quality — who is asking (so it calibrates to your level), what you actually want (task clarity), what done looks like (format specification), and the context it needs to do it well. Missing any one of these is where vague responses come from.

Claude Code Commands to Remember

These are the terminal commands you will use most often when working with Claude Code. Written in plain English so you know what each one actually does.

claude                        # Opens Claude Code in the current folder
claude "your instruction"     # Sends a single instruction without opening session
claude --continue             # Continues the most recent session
claude --help                 # Shows all available flags and options
npm install -g @anthropic-ai/claude-code  # Installs or updates Claude Code
npm update -g @anthropic-ai/claude-code   # Updates to latest version
node --version                # Checks Node.js version
which claude                  # Confirms Claude Code is installed

ls                  # Lists files in current folder
cd [folder-name]    # Navigate into a folder
cd ..               # Navigate up one level
mkdir [folder-name] # Creates a new folder
pwd                 # Shows your current location
python [script.py]  # Runs a Python script
node [script.js]    # Runs a JavaScript file
pip install [pkg]   # Installs a Python library
npm install [pkg]   # Installs a Node.js library

Security Checklist

Run through this before sharing any project or pushing to GitHub. Five minutes now prevents disasters later.

Three Rules to Live By

These are not rules about what Claude can and cannot do. They are principles for using AI well — for getting better results, staying safe, and keeping your judgment intact.

Rule 1: Verify before you trust. Claude is extremely capable and will occasionally be confidently wrong. Any specific fact, statistic, name, date, or claim that matters — especially one that will appear in something you share with others — should be verified from a primary source. Use Claude's output as a fast first draft, not as ground truth.

Rule 2: Iterate, do not restart. When Claude gives you something that is not quite right, your first instinct should be to refine the conversation, not to start over. Add context. Correct the specific thing that was wrong. Ask it to approach the problem from a different angle. The conversation is a workspace. Starting over throws away everything you have already established.

Rule 3: Keep your keys secret, keep your scope tight. Keeping your keys secret (in .env files, out of chat windows and GitHub) prevents security incidents. Keeping your scope tight (deciding what the project is and is not before you build it) prevents projects from growing until they are impossible to finish. Both habits are easier to build from the start than to fix after something goes wrong.

Resources to Go Deeper

The best places to go when you're ready for more.

Anthropic

console.anthropic.com — where your API keys live and where you monitor usage. docs.anthropic.com — the official documentation for the Anthropic API and Claude models. docs.anthropic.com/claude-code — official Claude Code documentation.

Automation Platforms

n8n.io — open-source visual automation tool; self-hostable, free tier available, excellent for connecting apps. make.com — visual automation platform with a large library of app connectors and a generous free tier.

Learning Environments

replit.com — a browser-based coding environment; useful for trying out scripts without needing a local setup. github.com — where your projects live; also where most of the world's open-source code is hosted and discoverable.

Staying Current

Ben's Bites (newsletter) — daily digest of what is happening in AI, written for a general audience. The Rundown AI (newsletter) — similar coverage, slightly more tool-focused. simonwillison.net — Simon Willison's blog; technical but accessible, excellent for understanding what AI tools can actually do.

Security

haveibeenpwned.com — check whether your email address has been in a known data breach. 1password.com or bitwarden.com — password managers; if you're not using one, start today.