You don’t need all of them. You need the seven that separate people who use AI from people who talk about AI.

This isn’t a 200-term AI glossary; it’s the AI vocabulary 2026 actually runs on: the terms that show up in every product launch, every investor deck, and every workflow that’s actually saving people time right now.

I run a newsletter called AI in Public where I build, break, and ship AI tools every week.

These seven AI terms come up in almost every conversation I have with founders, creators, and operators who are making real money with AI, not just posting about it.

If you’re looking for AI concepts for beginners explained without jargon, or you just want the AI terms explained fast so you can get back to work, this is that list.

If you understand these, you’ll know more about how AI actually works than most people who use it every day.

Let’s go.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

1. LLM (Large Language Model)

What it actually means: An LLM is the engine behind ChatGPT, Claude, Gemini, and every AI chatbot you’ve used. It’s a software model trained on enormous amounts of textbooks, websites, code, and conversations, so it can predict and generate human-like language.

What does LLM mean, in one sentence?

An LLM (Large Language Model) is an AI system trained on massive amounts of text so it can predict and generate human-like language. It’s the “brain” inside tools like ChatGPT, Claude, and Gemini, not a product on its own.

Why it matters for you: When someone says “we fine-tuned our LLM” or “this LLM handles 200K tokens,” they’re talking about the brain of the operation. Every AI tool you use, from writing assistants to code generators to customer support bots, is powered by one.

The term most people get wrong: People say “AI” when they mean “LLM.” AI is a broad field. An LLM is a specific type of AI, the one generating your emails, blog posts, and code. Knowing the difference instantly sets you apart in any AI conversation.

Creator workflow: Before you pick an AI tool, check which LLM it runs on. A tool using an older model (like GPT-3.5) will give you noticeably worse output than one running Claude Opus or GPT-5.5, even if the wrapper looks identical.

2. Tokens

What it actually means: Tokens are how an LLM reads and measures text. Think of them as the “units” of language the model processes. Roughly: 1 token ≈ ¾ of a word. So a 2,000-word article is about 2,700 tokens.

What are tokens in AI?

Tokens are the small chunks of text, roughly ¾ of a word each, that an AI model breaks language into before it can read or generate anything. Every AI tool has a token limit (a “context window”), and both your prompt and the AI’s response count against it.

Why it matters for you: Every AI tool has a token limit, called a **context window. This determines how much information the model can “hold in its head” at once.

• GPT-5.5: 128K tokens (~96,000 words)

• Claude Opus 4: 200K tokens (~150,000 words)

• Gemini 3.1 Pro: 2M tokens (~1.5 million words)

The practical impact: If you paste a 60-page document into an AI tool and it ignores the first 40 pages, you’ve hit the context window. The model literally cannot see that text anymore.

Mistakes creators make with tokens

1. Pasting entire books and expecting perfect recall. Even models with large context windows degrade in accuracy on text in the “middle” of a long input.

2. Not realizing tokens = cost. API-based tools charge per token. A 10,000-token prompt costs real money at scale.

3. Ignoring output tokens. Your prompt and the AI’s response both count toward the limit.

Prompt tip: Instead of dumping everything at once, chunk your input. Give the model a 5-page section, ask it to summarize, then move to the next. You’ll get dramatically better output.

3. Hallucination

What it actually means: When an AI generates information that sounds confident and fluent, but is completely made up. F*ke statistics, invented citations, nonexistent people, URLs that lead nowhere.

What is an AI hallucination?

An AI hallucination is confident, fluent-sounding output that is factually wrong or entirely invented, a fake statistic, a citation that doesn’t exist, a URL that leads nowhere. The model isn’t lying; it has no concept of truth, only of the most statistically likely next word.

Why it matters for you: This is the reason you can’t blindly publish AI-generated content. Sometimes the model’s prediction is a fact. Sometimes it’s fiction wearing a suit.

Real examples of hallucinations

1. An AI citing a “2024 Harvard Business Review study” that doesn’t exist

2. Generating a legal brief with fake case law (this happened; a lawyer was sanctioned for it)

3. Creating a product comparison that includes features a product never had

How to catch hallucinations - a checklist:

• Verify every statistic with a primary source

• Click every URL the AI generates (many will be 404s)

• Cross-reference names, dates, and claims with a quick search

• Ask the AI: “Are you confident this is accurate? What’s your source?” (This doesn’t guarantee accuracy, but it sometimes triggers self-correction)

• Never publish AI-generated facts without human verification

Creator workflow: I use a “trust but verify” system. AI writes the first draft. I fact-check every claim manually. This cuts my writing time by 60% while keeping accuracy at 100%. The AI handles structure and flow; I handle truth.

4. Prompt Engineering

What it actually means: The skill of writing instructions that get an AI to produce the output you actually want. It’s not “talking to AI”; it’s designing inputs that control the quality, format, tone, and depth of outputs.

What is prompt engineering?

Prompt engineering is the skill of writing structured instructions, role, context, task, format, and constraints that control the quality and shape of an AI’s output. The gap between a beginner and an expert using the identical AI tool is rarely the tool. It’s the prompt.

Why it matters for you: A well-engineered prompt can turn a $20/month ChatGPT subscription into a tool that replaces $2,000/month worth of freelancers.

Here is the detailed cheat sheet guide that will help you learn prompt engineering faster (even if you are a beginner)

Prompt engineering mistakes to avoid

Creator workflow: I keep a “prompt library,” a simple doc with my 15 best-performing prompts organized by use case (writing, research, code review, content repurposing). Every time I refine a prompt that works, it goes into the library. This alone saves me 3-4 hours per week.

5. RAG (Retrieval-Augmented Generation)

What it actually means: RAG is a technique where the AI retrieves real, up-to-date information from external sources (documents, databases, websites) before generating a response, instead of relying solely on what it learned during training.

What is RAG in AI?

RAG (Retrieval-Augmented Generation) is a technique where an AI looks up real, current information from an external source, a document, database, or the live web, before it answers, instead of relying only on what it memorized during training. It’s the difference between an AI guessing from memory and an AI checking its work.

Why it matters for you: LLMs have a knowledge cutoff. They don’t know what happened last week. RAG fixes this by connecting the model to live data.

A simple analogy: An LLM without RAG is like a brilliant consultant who read everything published before 2025 but hasn’t checked the news since. RAG gives that consultant a phone so they can look things up in real time.

Where you’re already using RAG (and don’t know it)

Perplexity AI searches the web before answering your question.

ChatGPT with browsing retrieves live web pages before responding.

Claude, with file uploads, reads your documents before generating.

Notion AI pulls from your workspace data to answer questions.

Why creators should care about RAG

If you’re building an AI-powered product, knowledge base, or even a chatbot for your business, RAG is what makes it accurate. Without RAG, your chatbot answers questions based on vibes. With RAG, it answers based on your actual data.

Practical example: A newsletter writer builds a chatbot trained on their 200 past articles. Without RAG, the bot makes up answers. With RAG, it pulls the exact article where you covered that topic and quotes it accurately.

6. AI Agent

What it actually means: An AI agent is a system that doesn’t just answer questions; it takes actions. It can browse the web, write code, run commands, use tools, make decisions, and complete multi-step tasks without you guiding every step.

What are AI agents?

AI agents are AI systems that plan, take actions, and complete multi-step tasks on their own, browsing the web, writing code, using tools, instead of just answering a single question and waiting for your next prompt. This is the shift from “AI as chatbot” to “AI as coworker.”

Why it matters for you: This is the biggest shift happening in AI right now. An agent doesn’t wait for your next prompt. It plans, executes, evaluates its own work, and adjusts.

Chatbot vs. Agent

Real agent examples in 2026

1. Claude Code - reads your codebase, writes code, runs tests, fixes bugs, and creates pull requests. You describe the feature; it builds it.

2. Hermes Agent - automates research and complex task workflows

3. Devin - an AI software engineer who handles end-to-end development tasks

4. OpenAI Operator - browses websites and completes tasks like booking or purchasing

I created a cheat sheet guide on how to build AI Agents from scratch in 2026 - save this becuase you needed it later.

How creators are using agents right now

1. Content research: “Research the top 10 competitors in [niche], analyze their content strategy, and give me a gap analysis.” The agent browses their sites, reads their content, and delivers a report.

2. Code-based projects: Founders use Claude Code to build entire MVPs by describing what they want in plain English.

3. Newsletter automation: Agents that monitor RSS feeds, summarize relevant news, and draft newsletter sections.

The “agent” test: If you have to manually paste, copy, switch tabs, and guide every step, you’re using a chatbot. If you describe the goal and walk away, you’re using an agent.

7. MCP (Model Context Protocol)

What it actually means: MCP is an open standard (created by Anthropic) that lets AI models connect to external tools, data sources, and services through a single, standardized protocol. Think of it as a USB-C port for AI, one universal connector that works with everything.

What is MCP (Model Context Protocol)?

MCP is an open standard that lets an AI model connect to external tools and data sources through one universal protocol. Instead of a custom integration for every app, you build one MCP connection, and any MCP-compatible AI can use it.

Why it matters for you: Before MCP, every AI integration was custom-built. Want Claude to talk to your Google Calendar? Custom code. Want it to read your Notion? Different custom code. Want it to access your database? Yet another integration. MCP standardizes this. One protocol. Any tool. Any model.

What MCP enables

• Your AI assistant reads your Gmail, checks your calendar, and drafts a response, all through MCP connections

• A coding agent accesses your GitHub repos, runs tests, and deploys through MCP

• A research agent pulls from your company’s internal docs, CRM, and analytics through MCP

Why this term puts you ahead

Most people haven’t heard of MCP yet. But it’s already reshaping how AI tools are built. If you’re evaluating AI products, ask: “Does this support MCP?” If yes, it can connect to your existing stack. If not, you’re locked into whatever integrations they chose to build.

Creator insight: I use MCP connections in Claude Code every day, it’s how I connect Claude to my browser, my file system, and my project tools all at once. The term sounds technical, but the concept is simple: it’s what makes AI actually useful beyond a chat window.

The Cheatsheet: 7 AI Terms in 30 Seconds

Bookmark this table - it’s the fastest AI terms cheat sheet you’ll find.

Common Mistakes: What Happens When You Don’t Know These Terms

1. You pick AI tools based on marketing, not models. You pay for a fancy wrapper running GPT-3.5 when a free tool uses GPT-5.5.

2. You paste 100 pages into ChatGPT and wonder why the output is garbage. You Didn’t understand token limits.

3. You publish an AI-written article with fake statistics. You didn’t know about hallucinations.

4. You write “write me a blog post” and get generic slop. You didn’t learn prompt engineering.

5. You build a chatbot that makes things up. You didn’t implement RAG.

6. You manually do 47 steps that an agent could handle. You didn’t know agents exist.

7. You use an AI tool that can’t connect to anything. You didn’t ask about MCP.

What to Do Next: Your 2026 AI Vocabulary Action Plan

• You don’t need to memorize definitions. You need to use these terms:

• This week: Check which LLM your main AI tool uses. Upgrade if it’s outdated.

• This week: Run one prompt through the Role-Context-Task-Format-Constraint framework and compare it to your usual prompting.

• This month: Try one AI agent tool (Claude Code, Hermes, or Operator) for a real task.

• This month: Ask your next AI tool purchase: “Does this support RAG? Does it support MCP?”

• Ongoing: Never publish AI-generated content without running the hallucination checklist above.

FREE GIFT FOR MY READERS

15 Agentic AI Terms You Must Know

Frequently Asked Questions

What are the most important AI terms to know in 2026?

The seven that matter most for practical use are LLM, tokens, hallucination, prompt engineering, RAG, AI agents, and MCP. Together they explain how AI models work, why they sometimes make things up, how to control their output, and how they connect to real tools; everything else is detail on top of these seven.

How many AI terms do I actually need to learn?

You don’t need 50, and you definitely don’t need 200. Seven core AI terms cover the concepts that show up in nearly every AI product, workflow, or conversation. Learn those deeply before you chase a longer glossary.

What’s the difference between AI and an LLM?

AI is the broad field of building systems that mimic human intelligence. An LLM (Large Language Model) is one specific type of AI, the kind trained on text to generate language, and the thing actually powering tools like ChatGPT and Claude.

Is ChatGPT an AI agent?

Not by default. Base ChatGPT is a chatbot; it answers one prompt at a time and waits for you. It becomes agent-like when it’s given tools (browsing, code execution, memory) that let it plan and complete multi-step tasks without your guidance at every step.

Do non-developers need to understand MCP?

Yes, at least at a basic level. You don’t need to build an MCP server, but knowing that MCP is what lets an AI tool connect to your calendar, files, or CRM helps you evaluate AI products and ask “does this support MCP?” before you buy.

What’s the best way to learn AI terminology as a beginner?

Start with the seven terms in this AI glossary, use each one in a real task within a week of learning it, and only then expand outward. AI concepts for beginners stick far better through use than through memorizing definitions off a list.

5 Credible Sources to Go Deeper

1. Anthropic’s Research Blog: The company behind Claude publishes detailed, accessible explanations of MCP, AI agents, and model architecture.

2. MIT Sloan’s Generative AI Glossary: Academic-quality definitions without the academic density.

3. TechCrunch AI Glossary: A living document updated regularly with practical, journalist-quality explanations of 30+ terms.

4. Simon Willison’s Blog: An independent developer who writes the most practical, no-BS breakdowns of AI concepts, tools, and terminology on the internet.

5. Coursera’s AI Terms & Definitions: Structured learning path if you want to go from vocabulary to actual skill-building.

Every day and every week, I break down the AI tools, workflows, and strategies that creators and founders actually use- no theory, no fluff, no “top 10 AI tools” listicles.

If this article saved you a Google search (or five), you’ll get a lot out of AI in Public.

Subscribe for free

AI in public

Strategic Insights, Proven workflows and systems for AI Professionals.

By Hamza Khalid

Here are a few issues that you might have missed (go check them out):

• How to Build Claude Skills

• How to build an app with Claude Artifacts

• Claude for Chrome

• 20 Resources to master Claude in 7 Days

• Vibe Coding: The Complete Claude’s Beginner Guide 2026

• 15 Claude Prompts that save me 30 hours a week

• 25 Ways to Use Claude (90% of People Know Only 3)

• How to Set Up Hermes Agent (Step-by-Step Guide)

You’ll get deep-dive on the AI terms, tools, and tactics that are actually moving the needle for small teams and solo creators.

Paid subscribers get my prompt libraries, workflow breakdowns, and early access to guides like this one.

I build, test, and write about AI tools in public so you don’t have to figure this out alone.

And for shorter takes between issues, follow me on X → Hamza Khalid

-Hamza 💙

I opened it the next day and threw it my hardest problem: restructure my entire Obsidian vault’s tag taxonomy, 5,500+ notes, without breaking a single internal link.

Four clarifying questions, then it just did it.

Two hours, one pass, zero broken links.

Three days later, it was gone.

Not rate-limited, gone.

Anthropic suspended it on June 12, 2026, to comply with US export controls.

Access came back on July 1, 2026, with updated safeguards layered on top of what shipped in June.

So this isn’t a launch-day reaction.

It’s what’s actually true now, after the model got pulled and came back different.

What you get today is free

By the end of this issue, you’ll have:

• 10 copy-paste prompts to test each capability yourself, tonight

• Anthropic’s actual prompting playbook for Fable 5

• A full master prompt: a cinematic 3D scroll-driven website

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

If you finish this issue and actually run the prompts, you will:

• Stop wasting Fable 5 on tasks it’s overkill for (and know exactly when it’s worth the 2x price tag over Opus 4.8)

• Know why your old Claude skills might be making Fable 5 perform worse, not better

• Have a working 3D animated website built from a prompt sequence you can reuse for client work

• Understand the refusal/fallback system well enough that you never mistake it for a bug again

10 things Fable 5 actually did

I cross-checked every one of these against Anthropic’s own launch documentation and independent coverage.

1. It beat Pokémon FireRed using only its eyes. No map tool, no game-state feed, no navigation harness. Screenshots in, moves out, start to finish. Previous Claude models needed a full scaffolding rig just to survive the first gym.

2. Stripe ran a 50-million-line Ruby migration through it in one day. That’s work that would normally eat a team’s time for two months.

3. It builds and uses its own memory. Anthropic tested this with Slay the Spire, a strategy deck-builder. Giving Fable 5 a persistent notes file improved its performance three times more than the same setup helped Opus 4.8, and it reached the game’s final act three times as often.

4. It designed real drug candidates. Using Mythos 5 (Fable 5’s unrestricted sibling, more on that below), Anthropic’s protein design team saw roughly a 10x speedup on parts of drug discovery. Nine of fourteen protein targets produced strong candidates now under further investigation. One hypothesis about an E. coli protein was independently confirmed by a lab that didn’t know Mythos had produced it.

5. It played Factorio like an engineer. Factorio punishes short-term thinking; you need working supply chains, not lucky clicks. Fable 5 planned and built an automated factory on its own.

6. It built a CAD tool, then used the CAD tool it built. A full browser-based CAD editor with its own AI copilot, created by Fable 5, then used by Fable 5 to design a 3D-printable object. Tool and output, one session.

7. It wrote music having never “heard” any. A fluid simulation with motion synced to an EDM remix, both generated in code, based purely on pattern understanding of musical structure.

8. In genomics, it outperformed a model published in Science, at 100x smaller size. Mythos 5 spent over a week largely autonomous, working with single-cell data across 138 animal species, and its trained model beat the published benchmark.

9. It survived 1,000+ hours of dedicated red-teaming with zero universal jailbreaks found before external security researchers were brought in for another round.

10. Its safety system doesn’t just refuse; it fails over. Instead of hitting a dead end, sensitive requests in cybersecurity, biology, or chemistry route automatically to Claude Opus 4.8. You still get an answer. It’s just not from Fable 5.

Old way vs New way

Old way: treat every new Claude release the same, run your existing prompts and skills unchanged, judge based on vibes after five minutes.

New way: re-evaluate your entire prompt and skill stack every time a model like this ships, because the instructions that made a weaker model behave well can actively hold a stronger one back.

That single idea is the most important thing in Anthropic’s own prompting guide for this model, and almost nobody is talking about it. So let’s go there next.

Loop Engineering, Skills, Vision & Memory: the operating system

Loop engineering 101

Fable 5 is built for autonomous work, not single-turn replies, and Claude Code gives you two commands to run it that way.

/goal Launches a task that runs until it’s actually done: “/goal keep researching until you can answer these 5 questions.”

/loop Runs on an interval and doesn’t stop until you cancel it: “/loop every 30 minutes, flag any email that actually needs me.”

Think of it like this: instead of you sitting in the loop between every prompt and every fix, you design the loop once and Fable 5 handles the back-and-forth, only surfacing when it hits your success criteria.

The barbell strategy. This is the move for keeping token costs sane on long runs. Use Fable 5 for the first 10%, planning the loop. Hand the middle 80%, the actual grunt work, off to cheaper subagents like Sonnet or Haiku. Bring Fable 5 back for the last 10% to verify the finished work against the original spec. You get Fable-level judgment at the two moments that matter most, planning and verification, without paying Fable-level pricing for routine execution.

Building skills for Fable 5, three ways

A skill is a recipe you teach once, and Fable 5 reuses it forever. I build mine one of three ways:

From a past chat. The fastest way in. If you’ve already done real work in Claude- financial analysis, writing, research, whatever- you can ask it to analyze that whole conversation, pull out your patterns and preferences, and turn it into a reusable skill.

From scratch. Open the skill creator, list out everything you do regularly (a Google Sheet works fine for this), and build the skill from that list.

From data. My favorite, and the highest-leverage of the three. Feed it a real dataset, hundreds of tweets from creators in your niche, for example, and have it mimic the tone and structure. Every piece of output becomes training data. You give feedback on what landed and what flopped, and the skill compounds.

One thing worth knowing: your skills live in your local folder, not inside Claude’s memory. You own them. You can port them to a different model entirely the day you want to.

Where vision actually pays off

Fable 5’s vision is one of the most underused parts of this whole release.

Real use cases beyond the Pokémon demo:

• Document & data - pull exact figures out of charts, graphs, and scientific figures buried in PDFs

• Design & UI critique - drop a screenshot of any interface and get a specific, detailed breakdown of what’s wrong with it

• Development - screenshot a dashboard and have it reverse-engineer the logic underneath

• Content & creative - drop a screenshot of a creative you like and have it replicate the structure, not the exact asset

• Agentic / computer use - read a live interface and act on it directly, no helper harness required

The context system (memory that actually persists)

None of the above hits its ceiling without context. Here’s the four-step setup I run:

Step 1: a local folder. Something like /claude-context on your machine. Everything in it becomes context. Fable 5 can pull from every session: a map of your business, your standard operating procedures, one-pagers on key clients or projects, strategy docs, a running log of decisions and outcomes.

Step 2: a memory file. Inside that folder, claude-memory.md. This is where Fable 5 writes down what it learns about you over time. One standing instruction makes it self-updating: “Every time I give you major context about my business or situation, update claude-memory.md with the key details.”

Step 3: an instructions file. claude-instructions.MD sets the rules: how memory gets stored, how output gets formatted, what it should always or never do. It’s the standing brief Fable 5 reads before every session.

Step 4: Connect it. Point Claude Code at the folder with /add, or reference it directly in your CLAUDE.md. From that point on, every loop, every skill, every session starts with Fable 5 already knowing your world.

The real prompting guide (not a workaround, the actual playbook)

I read Anthropic’s official Fable 5 prompting documentation front to back and tested every pattern in it. Here’s what actually changes how well Fable 5 performs for you, translated out of documentation-speak.

1. Pick an effort level on purpose

Fable 5 has adjustable effort, from low to high. I default to high for anything real, drop to medium for routine stuff, and only reach for xhigh on genuinely hard problems. Here’s the thing nobody tells you: low effort Fable 5 often beats xhigh effort on older models. Don’t assume you need to max it out. I wasted real money before I figured this out.

2. Expect long turns, and tell it not to overthink simple asks

Fable 5 will happily run for minutes, sometimes hours, on a hard task. On simple tasks, it can start over-planning if you don’t set a boundary. This is the line I now paste into every serious session:

When you have enough information to act, act. Don't re-derive facts we've
already established, don't re-litigate a decision I've already made, and
don't narrate options you're not going to pursue. If you're weighing a
choice, give me your recommendation, not a full survey.

3. Give it the “why,” not just the “what”

This one changed my output quality more than anything else on this list. Fable 5 uses context about intent to make better calls on its own. I stopped writing bare instructions and started framing every real request like this:

I'm building [X] for [audience]. They need [outcome]. Given that, here's
what I want you to do: [request].

4. Make it show its work with receipts, not vibes

On long runs, models can report progress that sounds confident but isn’t grounded in anything real. I now add this to every multi-step task:

Before you tell me something is done, check it against an actual result
from a tool call in this session. If something isn't verified yet, say so.
If a test failed, tell me it failed and show me the output. Don't hedge
and don't oversell.

This one nearly eliminated the “I finished it!” reports that turned out to mean “I think I finished it.”

5. Tell it explicitly what NOT to do on its own

Fable 5 is proactive by default. That’s usually great. Occasionally it’ll draft an email you didn’t ask for or create a backup branch you didn’t request. Set the boundary up front:

If I'm describing a problem or thinking out loud, your job is to tell me
what you found, not to fix it. Wait for me to ask before you make changes.
Before you run anything that changes real state, double check the evidence
actually supports that specific action.

6. Let it delegate

Fable 5 is much better than prior models at running multiple subagents in parallel and managing them without babysitting. If your task has independent pieces, say so directly:

Break this into independent subtasks and delegate what can run in
parallel. Keep working on your part while those run. Only step in if
a subagent goes off track.

7. Build a memory file

This is the single highest-leverage habit from the whole guide. Give Fable 5 a place to write notes across a session, or across sessions:

Keep a running notes file. One lesson per entry, one-line summary at the
top. Record what worked and what didn't, and why it mattered. Update an
existing note instead of duplicating it. If a note turns out to be wrong,
delete it, don't just add a correction.

I use this exact pattern for my LinkedIn-comment-meme skill now, and it’s genuinely gotten sharper at matching my face-lock rules over a week of sessions.

8. On autonomous runs, tell it not to stop and ask permission

If you’re running Fable 5 unattended (overnight, on a schedule, in a pipeline), it can sometimes pause and ask “want me to continue?” when nobody’s there to answer. Add this for any unattended run:

You're operating without me watching in real time, so don't ask "should
I..." questions, just proceed on anything reversible that follows from
the original request. Before you end your turn, check your last message.
If it's a plan, a promise, or a question instead of finished work, go do
the work now.

9. Rewrite your old skills; don’t just port them

This is the counterintuitive one. Skills built for weaker models tend to be extremely prescriptive, step-by-step instructions that assume the model needs hand-holding. On Fable 5, that same prescriptiveness can box it in and make output worse than if you’d just described the outcome you wanted. When I moved my skill library over, I went through each one and asked: Is this teaching Fable 5 something it doesn’t already know how to do, or is this micromanaging a model that’s smarter than the instructions assume?

10. Don’t ask it to narrate its own reasoning in the response

This is a real, practical gotcha and it’s worth knowing about for reasons that have nothing to do with getting around anything: if your prompt or skill tells Fable 5 to “explain your thinking step by step” as part of its visible answer, that specific pattern can trip a safety classifier built to catch reasoning extraction attempts, and you’ll get bounced to Opus 4.8 for a completely benign task. If you genuinely need to see its reasoning process, that’s what the model’s structured thinking output is for, not asking it to retype its internal thoughts into the reply.

Real-world example: building a 3D animated website live

This is where I put the whole prompting guide to work at once.

Goal: not a five-line “build me a website” prompt, a real master prompt, the kind you write once, save, and reuse on every client project.

I built mine around a cinematic scroll-driven product site, the same genre as the Apple-product-page style sites that convert insanely well for launches.

Below is the exact master prompt.

Please copy the whole thing into Terminal with Fable 5 selected; don’t summarize it first or trim it down.

THE MASTER PROMPT (copy everything below this line)

Build a cinematic, scroll-driven 3D website for a flagship product
(default to an original sports car concept unless I specify a real
product, in which case use only generic/placeholder assets, not any
real brand's actual design files or logos). The site should feel like
an Apple product page crossed with a configurator: every scroll input
drives one continuous, physically-smooth animation, not discrete page
sections. The goal is retention (people keep scrolling to see what
happens next) and conversion (ending in a clear CTA).

TECH STACK
- Three.js (or React Three Fiber if using React) for the 3D model/scene
- GSAP + ScrollTrigger for scroll-synced timelines (pin sections, scrub
  animation tied to scroll progress, not scroll speed)
- Lenis or similar for smooth/inertia scrolling so the scrub feels
  buttery, not jumpy
- A placeholder glTF/GLB model, note in comments exactly where a
  production model would be swapped in
- Native <video> elements (object-fit: cover, muted/autoplay/loop),
  not iframes
- WebGL fallback: if unsupported or low-power, serve a pre-rendered
  video/image sequence instead of failing

STRUCTURE — SCROLL AS TIMELINE
Treat the page as one GSAP timeline broken into scroll-pinned acts.
Each act pins the viewport while scroll distance scrubs its animation,
then releases into the next. No hard cuts, every transition is a morph
(camera arcs, not cross-fades).

Act 1 — Reveal (0-15% scroll): dark stage, single spotlight, product
assembles from off-frame parts snapping together with a subtle bounce,
kinetic-type headline syncs to the last part locking in, ghost CTA
"scroll to explore."

Act 2 — Exploded view (15-35%): product explodes apart along each
part's natural axis, driven by scroll progress so scrolling back
reverses it live. Each part gets a leader-line label callout. Camera
orbits slowly during the explosion for parallax.

Act 3 — Reassembly + full rotation (35-45%): parts snap back together,
camera pulls back for a scroll-scrubbed 360 turntable (scroll down =
rotate right). This is the hero shot: rim lighting, reflections,
ground-plane reflection.

Act 4 — Detail deep-dives (45-80%): camera dollies/pans/pushes into
each of 3-4 key features in sequence, the rest of the product blurs or
fades to silhouette, a spec callout panel slides in per feature.
Numbers (specs, stats) count up on entry. Every camera move is
continuous across features, never a hard reset.

Act 5 — Environment/lifestyle (80-90%): product transitions from a
studio background into a real-world environment via a full-bleed
video layer, matched to the product's last camera angle so it reads
as one continuous scene. Parallax across foreground/midground/
background video layers.

Act 6 — Conversion (90-100%): scroll unpins, normal flow resumes.
Primary CTA, secondary CTA, trust signals. Sticky header CTA reappears
once the user scrolls past Act 1.

MOTION PRINCIPLES
- Everything scroll-scrubbed inside pinned acts, nothing autoplays
  independent of scroll, the user should feel like they're driving it
- power2.inOut or custom cubic-bezier easing on all transforms, never
  linear
- 60fps target: transform/opacity only, will-change set deliberately,
  avoid layout-thrashing properties
- Cursor-follow micro-parallax tilt on the 3D model during scroll-idle
  moments
- Persistent thin progress indicator showing position through the acts
- Preload the next act's assets one act ahead so nothing stutters

VIDEO INTEGRATION
- Background video layers (position: fixed, or a canvas texture if
  compositing into the 3D scene)
- CSS mix-blend-mode + gradient overlays to keep text legible over video
- Sync playback to scroll where it matters:
  video.currentTime = scrollProgress * video.duration
- Clearly commented placeholder paths (e.g. /videos/hero-loop.mp4)
- WebM + MP4 fallback, lazy-load anything below the fold

VISUAL LANGUAGE
- Near-black stage background, one confident accent color, off-white
  type
- Bold condensed sans for kinetic headline reveals, clean geometric
  sans for spec data
- Studio three-point lighting on the 3D model, HDRI environment map
  for realistic reflections
- Consistent foreground/midground/background parallax throughout, not
  just in the hero

PERFORMANCE & ACCESSIBILITY
- Detect prefers-reduced-motion, serve simplified fades instead of
  full scroll-scrub, skip the explode animation
- Lazy-load the 3D model, defer Three.js init until hero is in view
- Minimal branded loading state while assets load
- All CTAs and spec text stay in the DOM and screen-reader accessible
  even though visually driven by canvas/video

DELIVERABLE
Single-page app (or one HTML file if vanilla JS), with:
- Clear comments marking each Act
- A config object at the top for easing, colors, and asset paths
- Mobile fallback: replace scroll-scrub with swipe-triggered or
  auto-advance-paused-on-tap sequences, since pinned scroll-scrub is
  often janky on mobile Safari

Before you tell me this is done, verify it against something real:
confirm the 3D scene renders without console errors, confirm each
act's scroll-trigger actually fires at the right scroll position, and
confirm mobile fallback engages correctly. Show me the evidence for
each, don't just tell me it works.

Notes on using this prompt

If Fable 5 tries to condense scope on a single pass, split it: paste the tech stack and structure sections first to get the scaffold, then feed the motion/video/visual sections as a follow-up refinement turn. Swap the product description for whatever you’re actually building; this works identically for a sneaker drop, a SaaS launch, or a real estate flagship listing. The act structure doesn’t change; only the content inside each act does.

This website is developed with a single prompt, no back and forth, no video and image reference. It just took 2 minutes to develop only. Fable 5 did the everything for me.

Slow down here for a second, because this is the part people skip.

The biggest mistake I see in how creators are covering Fable 5 right now is treating it like a bigger version of the last model.

It’s not. It’s a model built to be trusted with real autonomy, and it will only reward you for that if you actually give it the room, the context, and the boundaries to use it.

If you’re still writing five-line prompts and judging the result in ten seconds, you’re testing a different, weaker version of this model than the one that exists.

The gap between people getting mediocre results and people getting the results in this issue isn’t access. It’s whether they actually rewrote how they talk to it.

Recap checklist

• [ ] Fable 5 launched June 9, got suspended June 12 over export controls

• [ ] Came back July 1 with updated safeguards

• [ ] Fable 5 = Mythos-class capability with safety classifiers

• [ ] Mythos 5 = same model, restricted access, Project Glasswing only

• [ ] Sensitive requests don’t dead-end; they fall back to Opus 4.8 automatically

• [ ] Default to high effort, don’t assume xhigh is always better

• [ ] Give it the “why” behind requests, not just the “what”

• [ ] Build a memory file for anything that spans sessions

• [ ] Rewrite old skills for outcomes, not step-by-step hand-holding

• [ ] Never ask it to narrate its reasoning inside the visible response

• [ ] Set explicit boundaries before long autonomous runs

• [ ] Run the self-verification pattern on every build task

Read more

Claude stops halfway through a task and waits for you to say “continue.”

Claude tells you your idea is “brilliant” when it’s mediocre.

Claude makes up a stat with total confidence.

Claude refuses something completely harmless because one word in your prompt spooked it.

So when Anthropic dropped Sonnet 5, I didn’t read the press release.

I made a list - eight things I’ve personally hated about Claude - and spent the day testing whether this model actually fixed them.

By the end of this issue, you will get The Complete Sonnet 5 Guide - what changed, when to use it over Opus, the exact effort-level settings I'm now running for writing, coding, and research, plus copy-paste prompts built for how this model actually works.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

Meet Claude Sonnet 5

Here’s what actually shipped, in plain terms, before I get into the eight complaints.

Claude Sonnet 5 launched June 30, 2026.

Anthropic is calling it the most agentic Sonnet model yet, built to plan multi-step work, operate tools like browsers and terminals, and run on its own at a level that used to require a bigger, pricier model.

It’s now the default model for everyone on the Free and Pro plans, with access on Max, Team, and Enterprise too.

I don’t take Anthropic’s word for any of that.

I spent the day testing it against the exact complaints I’ve been logging about Claude for the last six months.

Introduction to Claude Sonnet 5 by Anthropic

Sonnet 5 vs Opus 4.8 vs Haiku

Not every model is for every job. Here’s how they actually stack up right now:

Haiku 4.5: The speed tier. Fastest responses, cheapest to run. Use it for quick, low-stakes tasks: summarizing a paragraph, answering a simple question, anything where you need an answer in seconds and don’t need deep reasoning. Not built for multi-step work or agentic tasks.

Sonnet 5: The new default. Near-Opus intelligence at a fraction of the cost. Plans multi-step work, uses tools, and self-checks its output. Introductory pricing: $2 per million input tokens and $10 per million output tokens through August 31, 2026, then moves to $3 and $15. This is the model most people should be running for most tasks starting today.

Opus 4.8: The ceiling. Still the most capable model for the hardest reasoning, the longest context windows, and parallel agent workflows. Priced at $5 per million input tokens and $25 per million output tokens. Reach for it when accuracy on a complex judgment call matters more than cost.

The gap between Sonnet and Opus used to be wide.

Sonnet 5 closed most of it.

A model good enough to trust with real work, priced like the option you use by default instead of the one you reach for when you’re desperate.

By the end of this issue, you won’t just know what changed in Sonnet 5.

You’ll know exactly which of your own recurring Claude frustrations are gone, which ones are just quieter, and which model to reach for depending on the job.

You’ll go from “hoping Claude finishes the task” to knowing, before you hit enter, whether it will.

Old Way vs New Way

Old way: Give Claude a multi-step task, watch it complete one part, then manually prompt it to “continue” for every remaining step.

New way: Give Sonnet 5 the same task once. It plans the full sequence, executes each step, and checks its own output before handing it back - without you asking it to.

That single shift is the difference between Claude being an assistant you supervise and Claude being a collaborator you delegate to.

The 8 Problems We Lived With. How Sonnet 5 Fixed Everyone.

For the last six months, these eight things have been the tax on using Claude for real work. Every Claude user I talk to has hit at least four of them. Sonnet 5 went down the list.

1. It stops halfway through multi-step tasks

Before Sonnet 5: You give it a job with three parts. It does one, then waits. You type “continue.” It does the second. You type “continue” again. A task that should take one prompt takes four.

After Sonnet 5: I gave it a real newsletter task - pull subscriber growth numbers from a CSV, calculate week-over-week percentage change, then draft a summary paragraph using that number. It ran all three steps without me touching the keyboard. It even flagged that one of my CSV column headers was ambiguous, made a reasonable assumption, and told me what it assumed instead of silently guessing or stopping to ask.

The “continue” era is over.

2. It agrees with everything you say

Before Sonnet 5: You pitch a weak idea. Claude calls it “a strong direction.” You share a mediocre hook. Claude says, “Great start!” You never get the honest pushback you actually need.

After Sonnet 5: I fed it a deliberately vague newsletter hook - no number, no tension, no specific claim - and asked for feedback. It told me directly that the hook would lose readers in the first two lines, then rewrote it three ways. No hedging. No flattery preamble. Anthropic’s own safety evaluations back this up - Sonnet 5 engages in sycophantic behavior at a measurably lower rate than its predecessor.

3. It hallucinates facts with total confidence

Before Sonnet 5: A made-up statistic, delivered with zero hesitation. You only catch it because you happened to double-check. If you didn’t check, it’s now in your published work.

After Sonnet 5: I asked it three questions I already knew the answers to, including one obscure pricing history question where older models have guessed wrong before. On the one it wasn’t sure about, it said so and suggested I verify rather than invent a number. That’s the behavior I want. Not perfect memory. Honest uncertainty.

4. It refuses things that aren’t actually a problem

Before Sonnet 5: You ask for something completely benign, and it reads danger into a single word. A productivity tips email gets flagged because you used the word “hack.” You spend more time rephrasing your prompt than writing the actual content.

After Sonnet 5: I asked it to draft outreach copy with the phrase “a few productivity hacks.” No hesitation, no lecture, no over-cautious rewrite. It just wrote the copy. A Lovable co-founder made the same point in Anthropic’s launch materials - the model now refuses genuinely unsafe requests cleanly, without over-applying that caution to harmless ones.

5. It doesn’t check its own work

Before Sonnet 5: You get a first draft with an obvious error. Claude never mentions it. You catch it, fix it yourself, and wonder why a model this smart doesn’t re-read its own output before handing it over.

After Sonnet 5: I asked it to write a short script and gave it room to run. Unprompted, it wrote a test for the function, ran it, caught an edge case it had missed, and fixed it before showing me the final version. I didn’t ask it to do any of that. Self-checking is now default behavior, not something you have to prompt for.

6. It’s vulnerable to prompt injection in agentic tasks

Before Sonnet 5: Give Claude access to tools and browsing, and a malicious instruction hidden in a webpage or document could hijack the session. Every agentic workflow came with a silent risk you couldn’t fully control.

After Sonnet 5: I can’t responsibly publish an actual injection attempt here, but Anthropic’s own system card shows meaningfully improved resistance to prompt injection attacks in agentic contexts compared to the previous Sonnet. For anyone running Claude with tool access unattended, this is the one to watch most closely over the next few weeks as more people stress-test it.

7. Tool use feels clunky and inconsistent

Before Sonnet 5: Browser and terminal actions that work great once, then fail the next time silently. You run the same task twice and get two completely different levels of follow-through. You stop trusting it with anything unattended.

After Sonnet 5: I ran the same research-and-summarize task through Claude with web search five times in a row. Consistent behavior across all five runs. No dropped steps, no silent failures. One week of testing isn’t a permanent benchmark, but the consistency was noticeably better than anything I’ve seen from Claude on agentic tasks over the past few months.

8. Opus-level performance costs Opus-level money

Before Sonnet 5: The model good enough to trust with real client work was also the expensive one. You either paid Opus prices or you babysat a cheaper model that couldn’t finish the job.

After Sonnet 5: Sonnet 5 launches at $2 per million input tokens and $10 per million output tokens through August 31, before moving to $3 and $15. Opus 4.8 runs $5 to $25. For the first time, the model doing near-Opus-quality agentic work isn’t the model with the Opus-sized bill. The tradeoff between quality and cost just got a lot smaller.

Best Practices / Use Cases

Where I’m actually pointing to Sonnet 5 starting this week:

• Client automation builds in Claude Code - multi-step jobs that used to need babysitting

• First-draft content generation - newsletter sections, social copy, outlines

• Research summaries with web search - where consistency across repeated runs matters

• Anywhere I was previously paying Opus prices out of caution, not necessity

Where I’m still reaching for Opus 4.8: the highest-stakes reasoning work, anything requiring the largest context windows, or tasks where I genuinely need the ceiling, not the value option.

Mentor Moment

Here’s the thing I want you to slow down and actually sit with: a model launch is not the same as a habit change.

Sonnet 5 fixing “stops halfway through tasks” only matters if you stop writing prompts for a model that stops halfway through tasks.

Most people will keep manually chaining “continue” prompts out of habit, the same way people keep checking a watch after they switch to a phone.

The model changed.

Rewrite your prompts to match it, or you’re leaving the upgrade on the table.

Recap Checklist

• [ ] Sonnet 5 completes multi-step jobs end-to-end without “continue” prompts

• [ ] Lower sycophancy and hallucination rates than Sonnet 4.6, per Anthropic’s own safety reporting

• [ ] Refuses genuinely unsafe requests, without over-flagging harmless ones

• [ ] Self-checks its own output unprompted

• [ ] Stronger resistance to prompt injection in agentic/tool-use contexts

• [ ] More consistent behavior across repeated tool-use runs

• [ ] Near-Opus performance at Sonnet-tier pricing

• [ ] Now the default model for Free and Pro plans

Read more

Open a new tab. Watch a 12-minute video. Feel smart for an hour. Forget it by Thursday.

Buy another course. Never finish it. Buy the next one anyway.

That’s not learning. That’s collecting.

The people who actually get good at this read books. Not because books are trendy - because a book forces the kind of slow thinking a 12-minute video can’t fake.

I spent the last few weeks pulling from every serious AI reading list I could find - the ones execs pass around, the ones engineers pass around - and narrowed it down to the 15 that earn a spot on your desk in 2026.

Nothing here is filler. Every one of these changes how you build, not just how you talk about building.

By the end of this issue, you will get a Notion-ready AI Engineer Reading Tracker - all 15 books’ links, pre-loaded reading order, time estimates, and a “Claude prompt” column you paste in before you start each one. No setup. Open it, start reading, start tracking.

It’s waiting for you after this issue. Keep reading.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

Why I almost gave up on books entirely

Eight months ago, I decided books were a waste of time for AI work.

The field moves weekly.

A book takes a year to write and edit.

By the time it ships, the model it references is two versions old.

I was half right. Books about tools age fast. Books about how systems are built don’t.

The mistake I was making: treating every AI book like a tutorial I needed to finish cover to cover, in order, taking notes by hand.

That’s not how anyone retains a 300-page technical book.

I’d read 40 pages, get pulled into client work, come back three weeks later having forgotten chapter one.

What changed? It wasn’t a new book. It was a new way of reading them - with Claude doing the priming and the extraction, so my actual reading time went toward understanding, not re-reading.

Who this list is actually for

Quick gut check before you scroll further, because half of book lists like this waste your time recommending things you don’t need.

An AI Engineer in 2026 is not a researcher. Not someone training models from scratch. It’s someone who takes existing models - Claude, GPT, Gemini - and builds real products on top of them using prompting, RAG, fine-tuning, and agents. That’s closer to software engineering than it is to a PhD thesis.

If that’s the role you’re building toward - or already in - these 15 books are sorted into the order that gets you there fastest.

The old way vs the new way of reading technical books

Old way: Buy the book. Read linearly. Hope something sticks. Move to the next book with zero connection to the last one.

New way: Prime the chapter with Claude before you open the book. Read with Claude open in a second tab to translate anything confusing in real time. Close the book and force the ideas into a 30-day action plan before you let yourself start the next one.

This one change - closing every book with an action plan instead of just a “nice read” - is what separates people who finish 15 books and build nothing from people who finish 5 and ship constantly.

The 15 books, in the order I’d actually read them

LAYER 1 - FOUNDATION

Book 1: Automate the Boring Stuff with Python by Al Sweigart

What it is: The best “learn Python” book ever written, made permanently free by the author himself. From page one, you are building scripts that rename files, scrape websites, and send emails automatically - not memorizing syntax in a vacuum.

What it gives you: Python fluency through immediate real-world feedback. You write 10 lines of code. Something happens in the world. You want to keep going. That loop is what most beginner books never create.

Who it’s for: Anyone who can’t write Python yet. If you already code, skip it.

🔗 Automate the Boring Stuff with Python

Book 2: Advanced Python Constructs Zbigniew Jędrzejewski-Szmek

What it is: A free, community-maintained online textbook covering the full Python scientific stack - NumPy, SciPy, matplotlib, and scikit-learn - updated continuously and readable directly in the browser with no signup.

What it gives you: The same practical data stack as the VanderPlas book. Load data. Clean it. Visualize it. Run basic ML on it. Every skill you need before you build anything with AI. The chapters are shorter and more modular, so you can move faster through the parts you already know.

Who it’s for: Anyone who knows Python basics but hasn’t worked with data yet. The bridge from “I can code” to “I can work with AI data.”

🔗 Advanced Python Constructs

Book 3: Machine Learning Yearning Andrew Ng

What it is: A short, dense strategy guide for building ML systems - written by one of the most respected figures in AI and distributed free by deeplearning.ai.

What it gives you: The strategic thinking layer most technical books skip. How to set up dev and test sets. How to diagnose why a model isn’t improving. How to prioritize what to fix first. This is the book that teaches you to think like a senior ML practitioner, not just a junior one.

Who it’s for: Anyone about to build their first ML-powered feature and wanting to avoid the most common six-month detours.

🔗 Machine Learning Yearning

LAYER 2 - CORE

This is where AI Engineers are actually built.

Book 4: Mathematics for Machine Learning Deisenroth, Faisal & Ong

What it is: The math textbook written specifically for ML practitioners - freely available from Cambridge University Press. Covers linear algebra, calculus, probability, and statistics through the lens of how they’re actually used in ML, not pure mathematics.

What it gives you: The mathematical foundation that makes reading every other book on this list twice as fast. You don’t need to go deep - you need enough to stop skipping the equations.

Who it’s for: Anyone who finished Layer 1 and wants to understand what’s actually happening inside the models they’re building on.

🔗 Mathematics for Machine Learning

Book 5: An Introduction to Statistical Learning James, Witten, Hastie & Tibshirani

What it is: The most widely used ML textbook in university courses worldwide - free PDF provided directly by the authors. Covers regression, classification, resampling, trees, SVMs, and more with R and Python labs.

What it gives you: A clean conceptual model of how supervised learning actually works before deep learning entered the picture. Understanding the classical methods makes the deep learning methods make more sense.

Who it’s for: Anyone who wants to understand ML at a level that survives the next five years of hype cycles.

🔗 An Introduction to Statistical Learning

Book 6: The Little Book of Deep Learning François Fleuret

What it is: A 200-page free PDF from a professor at the University of Geneva. Dense, precise, and fast. Covers tensors, gradient descent, backpropagation, transformers, and attention in a fraction of the time of any other deep learning book.

What it gives you: The fastest possible path to understanding how neural networks work at a mathematical level - without drowning in a 700-page textbook. Read this in a week and the next two books become significantly easier.

Who it’s for: Anyone who wants the core of deep learning without the padding.

🔗 The Little Book of Deep Learning

Book 7: Understanding Deep Learning Simon Prince

What it is: A 2024 textbook released free online by the author. One of the most visually clear deep learning books available. Covers supervised learning, neural networks, transformers, diffusion models, and reinforcement learning from first principles.

What it gives you: Visual intuition for deep learning that most technical books don’t bother to build. If Book 6 gave you the equations, this book gives you the pictures that make the equations stick.

Who it’s for: Anyone moving from “I know Python and basic math” to “I understand what deep learning actually does.”

🔗 Understanding Deep Learning

Book 8: Dive into Deep Learning Zhang, Lipton, Li & Smola

What it is: An interactive textbook from Amazon scientists - used at 300+ universities across 55 countries, entirely free online. Every concept comes with runnable code in PyTorch, TensorFlow, or JAX.

What it gives you: The combination most books don’t manage: theory and working code in the same place. Transformers, attention, BERT, GPT - all explained and implemented. Read it with a Colab notebook open, and you’ll build things as you learn.

Who it’s for: Engineers who learn by doing. If you’ve read Books 6 and 7, this is where you run the concepts.

🔗 Dive into Deep Learning

Book 9: Probabilistic Machine Learning: An Introduction, Kevin Murphy

What it is: A graduate-level textbook from a Google Brain researcher - the full PDF made freely available by the author. Covers probabilistic thinking, Bayesian methods, and uncertainty quantification across the full ML stack.

What it gives you: The statistical thinking layer that separates engineers who build systems that know what they don’t know from engineers who build systems that are confidently wrong. Uncertainty quantification is not optional in production AI.

Who it’s for: Engineers who have built models and want to understand why they fail in specific ways - and how to design systems that handle uncertainty instead of hiding it.

🔗 Probabilistic Machine Learning: An Introduction

LAYER 3 - ADVANCED

Production systems, real applications, and the questions that keep you from shipping something dangerous.

Book 10: Foundations of Large Language Models Tong Xiao & Jingbo Zhu

What it is: A 2025 book released free under a Creative Commons license by two NLP professors at Northeastern University. Covers exactly what AI Engineers building on LLMs need to understand - pre-training, generative models, prompting techniques, alignment methods, and inference. Click the link and the PDF downloads directly. No account, no paywall.

What it gives you: A clear, structured explanation of how LLMs actually work under the hood - from how they’re pre-trained to how prompting and alignment shape their behavior. After Layer 2, this is the book that connects “I understand deep learning” to “I understand what GPT and Claude are actually doing.”

Who it’s for: Anyone building products on top of LLMs who wants to stop treating the model as a black box and start understanding what’s happening beneath the API call.

🔗 Foundations of Large Language Models

Book 11: Speech and Language Processing Dan Jurafsky & James Martin

What it is: The standard NLP textbook from Stanford - free draft chapters updated continuously by the authors. Covers language models, transformers, BERT, parsing, and dialogue systems.

What it gives you: A deep understanding of how language models are actually built - from n-grams to GPT. If you’re building products on top of LLMs, this is the book that explains what’s happening beneath the API call.

Who it’s for: Anyone building LLM-powered products who wants to stop treating language models as black boxes.

🔗 Speech and Language Processing

Book 12: Machine Learning Systems Vijay Janapa Reddi et al.

What it is: A free open-access textbook on the engineering of intelligent systems at scale. Covers efficiency, deployment, hardware, and the gap between a model that works in a notebook and a model that serves millions of users.

What it gives you: Systems-level thinking for AI. The part most ML books skip entirely: how do you actually run this in production without it falling over? This book answers that in full.

Who it’s for: Engineers moving from “I built a model” to “I run a model in production.”

🔗 Machine Learning Systems

Book 13: Pattern Recognition and Machine Learning Christopher Bishop

What it is: The definitive Bayesian ML textbook - released permanently free as a PDF by Microsoft Research and the author. A classic that researchers and senior engineers still reference constantly.

What it gives you: The probabilistic foundations of modern machine learning in full. After reading Murphy’s book (Book 9) at an introductory level, this is the deep dive. Dense, rigorous, and worth it.

Who it’s for: Engineers who want to understand ML at the level that lets them read research papers without a dictionary.

🔗 Pattern Recognition and Machine Learning

Book 14: The Elements of Statistical Learning Hastie, Tibshirani & Friedman

What it is: A comprehensive graduate-level treatment of statistical learning - free PDF provided directly by the Stanford authors. More rigorous than Book 5 (An Introduction to Statistical Learning), which was explicitly written as a gentler companion to this one.

What it gives you: The mathematical depth behind the ML methods you use every day. This is the book senior ML engineers have read, and junior ones haven’t - and the difference shows up in production.

Who it’s for: Anyone who wants to move from applying ML methods to actually understanding them.

🔗 The Elements of Statistical Learning

Book 15: Reinforcement Learning: An Introduction Richard Sutton & Andrew Barto

What it is: The definitive textbook on reinforcement learning, free online from the authors. This is the book behind every RL system from AlphaGo to RLHF - the technique used to align modern LLMs like GPT and Claude.

What it gives you: A first-principles understanding of how AI systems learn from rewards - and why they so often learn the wrong thing. If you’ve ever wondered how ChatGPT was trained not to say harmful things, the answer is in this book.

Who it’s for: Engineers who want to understand how modern LLMs are fine-tuned and aligned - and why alignment is harder than it sounds.

🔗 Reinforcement Learning: An Introduction

Slow down here

I want to push back on something before you screenshot this list and close the tab.

You do not need to read all 15 books before you start building.

That’s the trap I fell into in 2024 - “I’ll start the real work once I’ve finished the reading.”

That’s procrastination wearing a productivity costume.

Read Layer 1 if you need it.

Read book 9 no matter what.

Then go build something badly, come back, and read the next book with a real project’s mistakes already in your head.

That’s when a technical book actually teaches you something - when you have a wound it can speak to.

Recap checklist

• [ ] Skip Layer 1 if you already code - start at book 4

• [ ] If you only read one book this year, make it AI Engineering by Chip Huyen

• [ ] Run the “before” prompt on the first chapter of whatever you start next

• [ ] Don’t close a book without running the 30-day action plan prompt

• [ ] Build something between books, not just after all 15

Read more

Every time I went looking for a real explanation, I found the same wall: a glossary of 20+ terms.

Agent loops.

Orchestration.

Guardrails.

Reflection.

Multi-agent systems.

Observability.

I almost gave up on understanding “agentic AI.”

Every explanation hit the same wall: 20+ terms - orchestration, guardrails, reflection - when all I needed was to ship one deliverable by Friday.

So I built three real agents in Claude Code this week and kept only the 15 ideas that actually changed how I prompt.

By the end of this issue, you’ll have the Build Your First Agent - Step-by-Step Guide: a full walkthrough with copy-paste templates for each of the 15 concepts below, so you’re not just reading definitions; you’re building something the moment you finish this email.

I’ll show you exactly where it lives.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

Introduction to Agentic AI Concepts

Here’s the shift: AI is moving from answering questions to doing the work behind them.

A chatbot replies once and waits.

An agent keeps going - checking its own work, deciding what’s next, remembering what happened last time, stopping only when the job’s done.

That shift is why the jargon exploded.

Underneath it, though, there are just 15 ideas worth knowing - most map to something you already do instinctively when managing a real employee.

After this issue, you’ll know all 15 concepts that actually matter in agentic AI - not as trivia, but as decisions you make before you build anything.

You’ll stop writing one giant prompt and hoping for the best.

You’ll sound like you know what “agentic AI” means in a client call, because you’ll be using it, not reciting it.

Old Way vs New Way

Old way: One prompt. One shot. Hope it’s right. Re-prompt when it isn’t.

New way: Break the task into a loop, give it tools, let it check its own work, and only step in when a guardrail says it should.

Old way: Memorize 21 pieces of AI jargon to sound credible in a pitch deck.

New way: Know the 15 ideas that actually change your prompts, and let the jargon take care of itself.

Step-by-Step Walkthrough

Here’s each concept, defined in one line, with where I actually used it this week.

1. Agent - a goal, not a task: A task ends. A goal persists. I gave Claude a standing goal: “Flag any newsletter issue under 40% open rate and explain the likely reason,” instead of a one-time ask.

2. Agent Loop - observe, decide, act, check.

You are reviewing newsletter performance data.

Step 1 (Observe): Pull open rates for the last 8 issues from the attached CSV.
Step 2 (Decide): Identify any issue with an open rate below 40%.
Step 3 (Act): For each flagged issue, write a one-sentence hypothesis 
for why it underperformed, using only evidence in the data.
Step 4 (Check): Confirm every hypothesis ties to a specific data point. 
If you can't point to the evidence, remove the claim.

Show your work for each step separately. Do not skip to the final answer.

3. Planning and Task Decomposition - only for real dependencies: My analytics task didn’t need a separate plan - four steps, no branching. My competitor research agent had to decide which competitors to check and what to pull from each one. Planning earns its place when steps depend on each other. Skip it otherwise.

4. Reflection - a measurable rule, not a vibe: The line that fixed everything: “If you can’t point to the evidence, remove the claim instead of guessing.” Claude can’t grade a vibe. It can grade a rule.

5. Tool Use - give it hands, not just an opinion: A model that can only talk back is a chatbot. An agent can read a file, search the web, or call an API. My research agent uses web search as a tool; my analytics agent reads a CSV as a tool. Name the exact tool in your prompt - don’t assume Claude knows what’s available.

6. Memory - decide what carries forward: For the analytics task, no memory is needed - it’s one-and-done weekly. For the competitor research agent, I told Claude to save confirmed pricing data to a file between sessions, so it stops re-researching the same competitor every week.

Before finishing, save the confirmed pricing for each competitor to 
competitor-pricing-log.md, with today's date. Next time you run this 
task, read that file first and only update what's changed.

7. Context Window Management - don’t drown it: Every agent has a limit on how much it can “see” at once. I stopped pasting my entire eight-issue archive into one prompt and instead pointed Claude to specific files only when needed. Less noise, fewer hallucinations.

8. State Management - track where the task actually is: For multi-step work, I now have Claude write a short status line after each step: “Step 2 complete, 3 competitors confirmed, 2 remaining.” That one line stops it from losing the thread mid-task.

9. Guardrails - the rules it can’t cross: For the analytics agent, the guardrail is simple: never invent a number that isn’t in the CSV. For the research agent: never publish a price without a source link. State the guardrail explicitly. Don’t assume it’s implied.

10. Permissions and Human-in-the-Loop - where you stay in control: My reviewer agent flags unsupported claims. It does not rewrite my draft. I kept the “decide what to publish” step for myself, on purpose. The riskier the output, the more this matters.

11. Orchestration - coordinating more than one agent: This only matters once you’re running multiple agents that hand work to each other. I’m not there yet for the newsletter - one agent, one job- still wins for most solo founders.

12. Multi-Agent Systems - different agents, different jobs: Same idea, bigger scale: a research agent feeding a writing agent feeding a review agent. Powerful, but overkill until a single agent is genuinely maxed out on one role.

13. Observability - being able to see what it actually did. Please show your work step by step, not just the final answer (see the loop prompt above). If you can’t see the steps, you can’t catch the mistake.

14. Stopping Conditions - when does it actually stop? Every agent needs an explicit finish line. Mine: “Stop once all flagged issues have a sourced hypothesis, or after 3 attempts per issue - whichever comes first.” Without this, agents either quit too early or loop forever.

15. Skills - reusable capabilities you don’t rebuild from scratch: Once a prompt structure works, I save it as a reusable skill instead of rewriting it every week. That’s the entire idea behind ClaudeKit, more on that below.

Best Practices / Use Cases

• Use the agent loop any time you’re tempted to write one giant prompt for a multi-part task.

• Add planning only when steps genuinely depend on each other.

• Write checkable reflection and guardrail rules, never vague ones.

• Decide memory task by task - repeating work needs it, one-off work doesn’t.

• Keep a human-in-the-loop step for anything that touches client-facing output or money.

• Skip orchestration and multi-agent systems until a single agent is genuinely maxed out.

• Always define a stopping condition - “keep going until X” or “stop after Y attempts.”

Slow down here, because this is the part people skip.

Jargon makes you feel behind. That’s its job.

Every new framework needs new words to justify itself, and the agentic AI space is throwing out new vocabulary every week.

But underneath almost all of it is the same loop your brain already runs every time you do real work: look at what’s in front of you, decide what matters, do the next right thing, check if it worked, know when to stop.

You already know how to think like an agent.

You’ve just never had names for the 15 pieces.

Don’t let the names intimidate you out of the thing you’re already good at.

Recap Checklist

• [ ] Give your next Claude task a goal, not just a one-time instruction

• [ ] Break multi-part work into the observe → decide → act → check loop

• [ ] Add planning only when steps genuinely depend on each other

• [ ] Write one checkable reflection rule and one guardrail, not vague instructions

• [ ] Decide if the task needs memory across sessions

• [ ] Keep a human-in-the-loop step for anything client-facing

• [ ] Define an explicit stopping condition before you hit run

• [ ] Grab the Step-by-Step Guide + templates below

Read more

You typed something in.

The answer came back... okay. Maybe even impressive.

So you kept going. You asked it to write something for you. Summarize something. Explain something.

And then, slowly, a quiet frustration started building.

Why does it keep getting things wrong?
Why does it sound so generic?
Why do I spend more time fixing the output than I saved creating it?

Nobody warned you about this part.

By the end of this issue, I’m giving away my Personal AI Context Template - the exact document I use to give Claude everything it needs to think like me before I type a single word. It solves most of what I’m about to describe.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

The Problem Most Beginners Face

Let me show you what’s actually happening.

When most people start using AI, they hit the same three walls. In order. Every time.

Wall 1: The Generic Output Problem

You ask AI to help you write something - a caption, an email, a bio.

It comes back with something technically correct. Grammatically fine. Completely hollow.

It doesn’t sound like you. It doesn’t know your audience. It’s the average of everything ever written on that topic, compressed into a paragraph.

You edit it heavily. Or delete it and start over. Either way, you wonder: what’s the point?

Here’s what’s actually wrong: AI doesn’t know you. You gave it a one-sentence request and expected it to fill in everything else. It can’t. So it guessed. And the guess was mediocre because it had nothing to go on.

Wall 2: The Inconsistency Problem

Some days, AI gives you something brilliant. You don’t know why. You can’t replicate it.

Other days, you get garbage. You don’t know why that happens either.

So you treat AI like a slot machine. Pull the lever and hope.

This isn’t an AI problem. It’s a system problem. You haven’t built anything consistent, so you can’t get consistent results. Every chat is a fresh start with a stranger who knows nothing about you or what good looks like.

Wall 3: The Starting-From-Scratch Problem

Three weeks in, you’ve written some genuinely good prompts.

You can’t remember what they were.

Because you never saved them. Every session starts blank. Every prompt is rebuilt from nothing. You’re not getting better at using AI - you’re just getting slightly faster at making the same mistakes.

The good news: all three walls have the same fix.

You don’t need better prompts.

You need a system.

What will you be after reading this

By the end of this issue, those three walls collapse.

You’ll know exactly how to give AI the context it needs to stop guessing.

You’ll have a prompt library, so you never have to start from scratch again.

And you’ll have a weekly habit that makes your system smarter over time.

Not theory. A system you can build today.

Old Way vs New Way

Old way: Open AI. Type a vague question. Get generic output. Spend 30 minutes fixing it. Feel like AI is overrated.

New way: Load your context. Call a saved prompt. Get a first draft that knows you. Refine once. Ship.

Old way: Build a great prompt by accident. Lose it. Never find it again.

New way: Save every prompt that works. Build a library. Compound it over months.

Old way: AI as a search engine you occasionally query.

New way: AI as a system layer you run your whole workflow through.

The outputs don’t change. The infrastructure does.

Step-by-Step Walkthrough

Here’s the three-part system. Set it up today. Compound it for years.

Step 1: Build Your Context Document

This is the highest-leverage move in AI - and almost nobody does it.

Your context document is a one-time file that tells AI everything about you before you ask it anything:

• Who you are and what you’re building

• Who your audience is and what they struggle with

• Your tone and communication style

• Your products or offers

• Your constraints - what you never say, topics you avoid

• Your current 90-day goal

You paste this at the start of any serious session. Or load it into a Claude Project so it’s always there automatically.

The AI stops guessing. It starts serving.

This single document fixes Wall 1 - the generic output problem - permanently.

Step 2: Build a Prompt Library

Here’s the move that fixes Wall 2 and Wall 3 at the same time.

Every time you get a great output, find out why. What did you say? What context was loaded? What structure did the prompt follow?

Write that down. Save it. That’s your first prompt.

A prompt library is just a collection of your best processes - bottled. Your newsletter structure. Your content ideation method. Your offer review checklist. Your email tone.

Each one is a reusable skill you can call on any time.

Build one prompt a week. In two months, you will have eight skills you will never have to rebuild. In six months, you have an AI system that compounds like a business asset.

Step 3: Build a Feedback Loop

A system without refinement is just a habit that never improves.

Once a week, spend 15 minutes on this: pick your three most-used prompts. Look at the outputs they produced. Note what was off. Make one edit to each.

That’s the whole practice.

Over time, your prompts get sharper. Your outputs get closer to what you actually want. Your system gets smarter - because you made it smarter.

This is the move 99% of people never make. They use AI. They don’t improve how they use AI.

Best Practices / Use Cases

Start here - not everywhere:

Don’t build the whole library on day one. Pick the one task you do most. Build the context document for that. Build one prompt. Use it five times. Refine it. Then add the next one.

Week 1: Context document
Week 2: First saved prompt
Week 3: First refinement session
Week 4: Second prompt

Four weeks. A functioning personal AI system. Built in 20-minute blocks.

This works especially well for:

• Founders creating content while running operations

• Creators who need to maintain their voice at speed

• Operators running repeatable client processes

• Beginners who feel like they’re constantly starting over

Real-World Examples

Here’s what this looks like in practice.

The content creator: Built a context document with her brand voice, audience pain points, and content pillars. Built one prompt for ideation. Now generates a week of content ideas in 12 minutes on Monday morning. Before: 2 hours of staring at a blank page.

The founder: Built a prompt for proposal writing that interviews him about the client before writing anything. Proposals went from 2 hours to 25 minutes. The quality went up because the AI now asks him the right questions before it writes a word.

The operator: Built a library of eight client-facing prompts - emails, status updates, scope summaries. Every client communication now starts from a strong base instead of a blank screen.

None of them found magic prompts. They built systems.

Pause here for a second.

You’re going to read this and think: “I’ll do this over the weekend.”

That’s where good intentions go.

The context document takes 20 minutes. Right now. Today. Not a project - a single conversation with AI.

Open Claude when you finish this issue. Paste Prompt 1. Answer the questions. Save what it gives you.

That’s it. That’s the whole first move.

The gap between someone who uses AI occasionally and someone who gets real leverage from it isn’t talent. It’s not the model they use. It’s that they did the 20-minute thing, and everyone else didn’t.

Recap Checklist

✅ Understand three walls: generic output, inconsistency, and starting from scratch
✅ Build your Personal Context Document (Prompt 1 - 20 minutes)
✅ Load it into a Claude Project as background knowledge
✅ Identify the one task you repeat most in your work
✅ Use Prompt 2 to bottle it into a saved prompt
✅ Run Prompt 3 on it after using it five times
✅ Add one new prompt per week

Read more

It doesn’t.

It means being the only human on the team.

The first version is 80-hour workweeks and a nervous breakdown disguised as a business.

The second version is what I run right now.

One person. Three products. Zero employees.

The rest? Delegated to an AI that knows my business better than most employees would.

By the end of this issue, I’m giving away my One-Person Company OS - my full AI delegation system, weekly planning template, and the exact Claude Projects structure I use to run AI in Public.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

Sam Altman said it out loud last year.

A one-person company will reach a billion-dollar valuation.

Not a lean startup. Not a small team. One person.

The reason it’s possible now: AI handles the execution layer. Research, writing, operations, client work, content - all of it.

You stay in the only seat AI can’t fill.

The decision seat.

That’s the company we’re building here.

If this is useful, forward it to one person who’s been struggling with Claude Code. It takes 10 seconds.

Share

By the end of this issue, you’ll have the exact structure I use to run a one-person company with AI as the operating layer.

You won’t just be faster at tasks.

You’ll stop doing tasks that never needed your brain.

You’ll stop being the bottleneck in your own business.

And you’ll have a system that runs while you sleep - not because that’s a good headline, but because I tested this and it actually does.

OLD WAY vs NEW WAY

Old way: You sit down to write. You start from scratch. You bounce between 4 tabs trying to remember what you decided last week. An hour passes. You have a paragraph. You feel behind before you’ve started.

New way: You open a Project that already knows your voice, your audience, your goals, and last week’s decisions. You give it a direction. It gives you a 90% draft in 4 minutes. You spend your hour editing - not producing.

Old way: Every new task = full context dump. “Here’s who I am, here’s my audience, here’s the tone, here’s what I did before...”

New way: The Project already has all of that. You say what you need.

The context lives in the system. Not in your head.

STEP-BY-STEP WALKTHROUGH

How I actually set this up

Step 1: Build your Claude Project as a business brain

Go to Claude. ai → Projects → New Project.

Name it after your business. Not “My Newsletter.” Your actual business name.

This Project is your operating system. Everything lives here.

Step 2: Load the four files that run everything

Every one-person company needs exactly four files in their Project:

who-i-am.md: Your voice. Your audience. Your standards. What good work looks like. What you will never publish.

what-i-do.md: Your offers. Your goals. Your current focus. What you’re saying yes and no to this quarter. Update this every 90 days.

style-rules.md: Every word you hate. Every sentence pattern that sounds like AI. Every rule about formatting, length, and tone. Start with 20 rules. Add 2 every week.

operating-context.md: Ongoing projects, deadlines, decisions you’ve made. The running log of your business. Update it at the start of every week.

Without these files, AI gives you generic output.

With them, you get your output.

Step 3: Write your weekly brief, not your weekly prompts

Most people treat AI like a vending machine. Put in a prompt. Get out a result.

That’s not a business system. That’s a one-off.

Instead, every Monday morning, write a 3-paragraph brief.

Weekly brief — [Date]

What's happening this week:
[1-3 sentences about what you're focused on]

What needs to get done:
[List of 3-5 deliverables]

Current context:
[Anything that's changed since last week — new info, changed goals, updated decisions]

Drop this into your Project at the start of every session.

Claude now has your week.

It doesn’t need to guess. It doesn’t fill gaps with assumptions. It works from what you actually need.

Step 4: Assign AI a role, not a task

The biggest mistake I made early on: I was assigning tasks.

“Write a LinkedIn post about Claude.” “Draft an email to subscribers.” “Summarize this article.”

Tasks produce output.

Roles produce systems.

When I gave Claude a role - “You are the content strategist for AI in Public. Your job is to help me show up consistently for 4,200 subscribers without me burning out.” - The quality of everything shifted.

It stopped just answering questions. It started thinking about the bigger picture.

Try this prompt to assign the role:

You are the operating partner for [your business name].

You have full access to my business files in this Project.
Your job is not to answer questions. It's to help me make better decisions, produce better work, and build systems that don't require me to be present for every task.

When I bring you a task, your first question should always be: 
"Is this something I should do once, or should we build a system for it?"

Start by reading all files in this Project.
Then ask me what I'm working on this week.

Step 5: Build one process per output type

For every repeating deliverable in your business, you need a process file.

Not a template. A process.

A template is a blank doc with headers. A process tells Claude exactly how to think through the work.

Mine for newsletter issues:

Newsletter Issue Process:

1. Read who-i-am.md and style-rules.md before writing a single word
2. Ask me for the topic and the one thing I want readers to do differently after reading
3. Suggest 3 angles — I'll pick one
4. Write the hook first. Do not proceed until I approve it.
5. Write section by section. Pause for input if the direction is unclear.
6. Run a final check against style-rules.md before calling it done
7. Flag any section that feels like it could've been written by anyone

The last line is the most important one.

“Could’ve been written by anyone” is the test.

If yes, rewrite until it cannot.

Step 6: Review, don’t produce

This is the shift most people never make.

They use AI to help them produce.

The one-person company model uses AI to handle production and keeps you in the reviewer seat.

Reviewer work:

• Is this on-brand?

• Is this accurate?

• Is this what I actually want to say?

• What would make this 10% sharper?

That’s your job.

The typing, the structuring, the drafting, the formatting - that’s the system’s job.

BEST PRACTICES / USE CASES

1. The weekly production sprint: Every Sunday night, I drop my weekly brief into Claude. By Monday morning, I will have first drafts of all content for the week. I spend Monday editing. Everything else gets approved or rejected in under 30 minutes.

2. The subscriber reply system: Every week, replies come in. Most are questions. Some is feedback. I batch them into a single paste. Claude categorizes them, drafts responses, and flags the ones that need my personal voice. I approve, customize, and send.

3. Competitive research without the headache: I have a standing instruction: “Every week, find 5 interesting things happening in the AI tools space that my readers don’t know yet.” I paste 3-4 articles I spotted. Claude synthesizes them into a clear briefing. I decide what’s worth covering.

4. The product page that updates itself: ClaudeKit’s documentation used to be a manual process. Now I have a process file that Claude follows every time I ship a new feature. Drop in the feature notes. Outcomes: an updated, on-brand product description. I read it. I approve it. It goes live.

MENTOR MOMENT

Here’s the thing nobody tells you about building a one-person company.

The hard part isn’t the work.

The hard part is letting go of the idea that the work has to come from you.

I spent three months using AI to help me write faster.

It helped. But I was still the one producing.

The day I handed Claude my style files and said, “Your job is to protect my voice, not copy it,” - everything changed.

Good AI use isn’t about typing less.

It’s about staying in the decisions that only you can make.

Everything else is infrastructure.

Recap Checklist

Before you close this issue, here’s your setup checklist:

• [ ] Claude Project created for your business

• [ ] who-i-am.md written and loaded

• [ ] what-i-do.md written with current quarter goals

• [ ] style-rules.md started (even 10 rules are enough to begin)

• [ ] operating-context.md set up for weekly updates

• [ ] First weekly brief written

• [ ] Role-assignment prompt run to give Claude its operating context

• [ ] One process file written for your most common output type

You don’t need all 8 today.

Start with the first 3. The rest builds naturally.

Read more

Same question, again and again:

“Okay, I have the vault. I have the notes. Now what?”

Fair question.

A vault with no plugins is just a filing cabinet that links to itself. The real second brain starts when plugins do the boring work: finding old notes, surfacing tasks, making your graph useful instead of just pretty.

So I installed 30 plugins. All at once.

I deleted 23 of them within 48 hours. They slowed down the app, broke my templates, or just sat there doing nothing.

Seven changed how I work.

This issue is those seven. Real settings. Real screenshots. What broke, what worked, what I’m still using today.

By the end, you’ll get the Plugin Stack Cheat Sheet - one page, all 7 plugins, every setting, so you skip my mistakes.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

By the end of this issue, you won’t just have a list of plugins.

You’ll have a vault that finds your notes for you, surfaces your tasks without hunting, and stays fast because you never added the wrong things in the first place.

That’s the difference between a vault you check and a vault you actually use.

Why Core Plugins Aren’t Enough

In the last issue, I told you to learn the core plugins first. Still true. Don’t skip that step.

But core plugins only store notes and link them. They don’t do the work for you.

Old way: you search for old notes by hand. You build your own task list by hand. You check which notes you forgot about by hand.

New way: plugins do all of that for you, every time you open the vault.

The 7 Plugins I Still Use

1. Dataview

What it does: shows you a live list of notes, built from a simple query.

I use this every day. Here’s the exact one sitting on my Home note right now:

This shows every note I touched in the last 7 days. No more “did I already write about this” moments.

2. Tasks

What it does: pulls every checkbox from your whole vault into one list.

Old way: open 20 notes, hunt for open tasks, new way: one list, every task, sorted by date.

Add a due date to any task like this: 📅 2026-06-30. Now it’s a real task manager, inside your notes.

3. Templater

The core Templates plugin only inserts plain text. Templater adds today’s date, your name, and even small auto-fill rules.

Here’s my real daily note template, the one that fills in every morning:

That one date line does something the core plugin can’t: it writes the date the way I want to read it, not just a plain number.

Didn’t work: I tried to have Templater automatically build my meeting notes from my calendar. Three hours in, I gave up. Too many things broke. Sometimes the simple template wins.

4. Excalidraw

What it does: a drawing canvas inside any note.

I use it for one thing: sketching out newsletter ideas before I write them. The Part 1 outline for the Obsidian issue started here.

5. Periodic Notes

The core Daily Notes plugin only makes daily notes. This one adds weekly and monthly notes too, and links them to your daily notes automatically.

My weekly note pulls in every daily note from that week on its own. I open it on Friday, and everything’s already there.

6. QuickAdd

What it does: one shortcut, and a new note is created, filed, and tagged. No clicks needed.

My setup: I press Cmd+Shift+N, type my idea, and it lands in my Inbox folder, already tagged.

This is the plugin that finally made the “2-minute note rule” from Part 1 actually take 2 minutes. Before this, filing the note took longer than writing it.

7. Graph Analysis

What it does: shows you a simple list of which notes connect to the most other notes, and which notes connect to nothing at all.

Once a month, I run this and clean up. Last month: 14 notes with no links. Two became real notes. Twelve got deleted.

The 23 That Didn’t Make It

I won’t list all 23. Here’s what they had in common:

Plugins that tried to replace something Obsidian already does well (a second graph, a second task list, a second template tool) caused problems. Two plugins doing the same job will slow your vault down, and sometimes break your notes. I lost the formatting on four notes this way. Lesson learned.

Plugins that copied something a simple Dataview query already does were just extra weight. If five lines of Dataview can do it, you don’t need a separate plugin.

The point: more plugins don’t mean a better vault. Fewer plugins, each doing one clear job, actually work.

Mentor Moment

Quick pause here.

If you want to install all 7 tonight, don’t.

Add one. Use it for a week. Then add the next.

I added 30 in three days, and spent the next two weeks fixing problems instead of writing notes. A good plugin should disappear into your day. If you’re thinking about the plugin more than your idea, it’s slowing you down, not helping you.

Your Setup Checklist

• [ ] Dataview installed, one query on your Home note

• [ ] Tasks plugin installed, due dates on at least 3 tasks

• [ ] Templater set up for your daily note

• [ ] QuickAdd shortcut set up and tested

• [ ] Graph Analysis run once, unlinked notes found

• [ ] Excalidraw only if you think in pictures

• [ ] Periodic Notes only if you do a weekly review

Quick Poll

Reply and tell me. I read everyone.

Your Gift

The Plugin Stack Cheat Sheet - all 7 plugins, exact settings, the 3 queries from this issue, ready to paste into your vault. Grab it here:

The Obsidian Plugin Stack Cheat Sheet

Here are a few issues that you might have missed (go check them out):

• How to Build Claude Skills

• How to build an app with Claude Artifacts

• Claude for Chrome

• 20 Resources to master Claude in 7 Days

• Vibe Coding: The Complete Claude’s Beginner Guide 2026

• 15 Claude Prompts that save me 30 hours a week

• 25 Ways to Use Claude (90% of People Know Only 3)

• How to Set Up Hermes Agent (Step-by-Step Guide)

We tested it in public. Now go use it in private.

If this issue gave you something real, a framework, a starting point, a moment where something clicked, share it.

Share

And for shorter takes between issues, follow me on X → Hamza Khalid

P.S. Which of these 7 plugins are you adding first?

Reply and tell me. I read everyone.

See you in the next newsletter.

- Hamza 💙

Have you ever opened Claude Code, typed something in, got a great answer, and then watched it completely forget everything you just told it 10 minutes later?

You’re not imagining it. It’s not a bug. It’s a setup problem.

And the fix takes 5 minutes.

By the end of this issue, you’re getting a complete, copy-paste starter kit, a ready-to-use folder setup you can drop into any project and start using immediately. No technical background needed.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

Last month, I rebuilt a project from scratch after losing 4 hours to this exact problem.

I had Claude Code running. It was doing great work. Then the session got long, context got messy, and it started making decisions that contradicted everything I’d told it earlier.

I’d given Claude no memory. No rules. No guardrails.

It was like hiring a brilliant assistant and forgetting to tell them who they work for.

Here’s the setup I use now. It’s the difference between Claude Code that forgets and Claude Code that actually works.

If this is useful, forward it to one person who’s been struggling with Claude Code. It takes 10 seconds.

Share

What changes when you actually set this up?

Right now: You open Claude Code, type a request, get a good answer, and watch it forget everything 10 minutes later. Every session starts from zero. You repeat yourself constantly. You’re not building anything - you’re just prompting.

After one week with AI In Public: You have a working CLAUDE.md, a folder structure, and at least one Skill running. Claude stops forgetting. Your sessions have rules. You feel the difference immediately.

After one month with AI In Public: You have a personal system. Hooks that protect your work. Specialists that run automatically. A second-opinion checker that catches mistakes before they cost you. You’re not prompting Claude anymore - you’re managing it.

After one year with AI In Public: Claude Code is part of how you work. Not a tool you open occasionally. A system running in the background of everything you build, write, and ship. You’ve automated the repetitive parts. You’re ahead of 95% of people who still treat it like a chat box.

That’s the gap this issue closes.

What’s Actually Going On

Most people think Claude Code is just a smarter ChatGPT for coding.

It’s not. It’s closer to a full employee.

The problem is: most people give it zero onboarding. No instructions. No rules. No context about what you’re building or how you work.

The fix is what I call the 5-layer setup. Think of it like building your AI assistant a proper workspace instead of just handing them a keyboard and walking away.

Here’s what each layer does:

Layer 1 - The Instruction Manual (CLAUDE.md): A document Claude reads at the start of every single session. It’s where you write your rules, your preferences, and your project details. Think of it like the onboarding doc you’d give a new team member on their first day.

Layer 2 - The Specialists (Skills): Pre-trained mini-experts you can summon for specific jobs. One for reviewing your work. One for writing descriptions. One for running tests. Claude calls them automatically when it recognises the right moment.

Layer 3 - The Security Guard (Hooks): Non-negotiable rules that can never be skipped. Things like: never delete these files. Never send anything without checking first. Always run a check before finishing. Unlike regular instructions, hooks cannot be ignored.

Layer 4 - The Second Opinion (Subagents): A fresh copy of Claude that reviews the work with zero bias. It doesn’t know what your main session is doing. So it catches mistakes that the main session might miss.

Layer 5 - The Team (Agent Teams): Multiple Claude sessions working together, sharing tasks, and messaging each other. This is the most powerful setup and the newest. You probably won’t need it on day one. But it exists.

Step 1: Build the Folder

Before you do anything else, your project needs a home.

Think of this like setting up a new office. You need a place for instructions, your specialists, your security rules, and your tools.

Here’s the folder setup that works:

your-project/
├── CLAUDE.md                    ← The instruction manual
├── .claude/
│   ├── settings.json            ← Shared rules (everyone on your team sees these)
│   ├── settings.local.json      ← Your personal rules (private, not shared)
│   ├── skills/
│   │   ├── review/SKILL.md      ← Your "quality checker" specialist
│   │   ├── testing/SKILL.md     ← Your "bug finder" specialist
│   │   └── writing/SKILL.md     ← Your "description writer" specialist
│   └── agents/
│       └── reviewer.md          ← Your "second opinion" checker
├── hooks/
│   └── safety-rules.sh          ← The security guard rules
└── src/                         ← Your actual work goes here

How to set it up:

1. Create a new folder for your project

2. Copy this structure into it (we’ll fill in the details in the next steps)

3. The .claude/ folder is where all the Claude-specific stuff lives

Note: You can do the same step with Claude's code.

Step 2: Write Your Instruction Manual (CLAUDE.md)

This is the most important step.

CLAUDE.md is the document Claude reads before it does anything. Every single session. It’s your chance to tell Claude who you are, what you’re building, how you like to work, and what lines it should never cross.

Here’s a real, copy-paste template you can use right now:

# What This Project Is
[Write one sentence about what you're building]
Example: "This is a newsletter system that turns my notes into Substack posts."

# My Tools
- I write in [your writing tool]
- I publish on [your platform]  
- I store files in [where your files live]

# My Rules — Read These Every Session
1. Never delete any file without asking me first — because I don't have backups
2. Always show me what you're going to do before you do it — because I need to approve changes
3. Keep responses short and clear — because I'm not technical and long answers confuse me
4. If you're not sure about something, ask — because guessing is worse than asking
5. Never change the design or layout without my permission — because branding matters

# What I'm Currently Working On
[Write a quick note about your current project or task]

# Things That Have Gone Wrong Before
[Optional: list anything Claude has messed up in past sessions so it doesn't repeat it]

How to fill it in:

1. Run /init Inside Claude Code, it creates a starter version of your project automatically

2. Open the file, it creates, and replace the generic text with your real info

3. Keep it under 200 lines; the shorter and clearer, the better. Claude follows it

Step 3: Set Up Your Security Guard (Hooks)

Regular instructions are great. But some rules need to be absolute.

That’s what Hooks are. Think of them as a security guard who stands at the door of every action Claude takes. Before Claude does anything, the guard checks the rule. If the rule says no, it stops.

Here’s what hooks look like in plain English:

Rule 1 - The Before Check (PreToolUse): Before Claude makes any changes, check if it’s about to touch something important. If yes, stop and ask me first.

Rule 2 - The After Check (PostToolUse): After Claude makes a change, automatically run a quality check and flag anything that looks off.

Rule 3 - The Notification (Notification): When something important happens, send me a heads-up so I know what’s going on.

Here’s what your safety rules file actually looks like inside:

{
  "PreToolUse": [{
    "matcher": "any file change",
    "hooks": [{
      "type": "command",
      "command": "./hooks/check-before-changing.sh"
    }]
  }],
  "PostToolUse": [{
    "matcher": "any write",
    "hooks": [{
      "type": "command", 
      "command": "./hooks/check-after-changing.sh"
    }]
  }]
}

Translation: Before touching anything, run a check. After touching anything, run another check.

The exit codes work like a traffic light. Code 0 = green, go ahead. Code 2 = red, stop completely.

Step 4: Create Your Specialists (Skills)

Here’s where things get genuinely exciting for non-technical people.

A Skill is a pre-written specialist that Claude summons automatically when it recognises the right moment. You’re not training a model. You’re just writing a plain-English description of an expert you’d like to have on call.

Here’s a real example. This is a “quality reviewer” Skill:

Name: quality-reviewer

What this specialist does:
Reviews any work I've created and checks for:
- Spelling and grammar mistakes
- Anything that sounds confusing or unclear  
- Missing information
- Anything that doesn't match my usual style

How to use this: Call it after any major piece of work is finished.

What to look for: Read the work carefully. List any problems. Don't fix them — just flag them.

What to return: A short list of issues found. Rate each one as minor, medium, or major.

That’s it. Claude reads this and knows exactly what kind of specialist it’s talking to.

The magic part: you can have a specialist for anything. A “tone checker” that makes sure everything sounds like you. A “headline writer” who rewrites your titles to be more engaging. A “simplifier” that turns complex text into readable text. You write the job description once. Claude automatically calls the specialist whenever needed.

Share this and get rewarded

Go to AI In Public → scroll to the Leaderboard section → copy your referral link → share it with anyone.

Every signup through your link moves you up the board and unlocks real rewards.

At the end of every month, we check the leaderboard.

The top 3 get our best guide - DMed directly, no opt-in required.

Step 5: Set Up Your Second Opinion (Subagents)

This is the quality gate most people never use. And it’s the one that catches the most mistakes.

A Subagent is a completely fresh copy of Claude that looks at the finished work with zero context from your main session.

Think of it like asking a colleague to review your work before you send it. Except the colleague is fast, never gets tired, and has no reason to tell you what you want to hear.

Here’s what a simple subagent setup looks like:

Name: second-opinion-checker

What this reviewer does:
Looks at finished work and checks if it's actually good.
Has no knowledge of how the work was created.

What to check:
- Does this actually answer what was asked?
- Is there anything missing?
- Does this look like quality work to someone seeing it for the first time?

Important rule: This reviewer can only read. It cannot make changes.
Report findings only.

The rule that matters: Your second-opinion checker should never be allowed to make changes. It reads and reports. That’s it. If it can edit, it becomes part of the problem instead of the solution.

Step 6: Run the Daily Workflow

With your setup in place, every Claude Code session follows the same simple pattern.

Morning startup:

Open your project folder → type "claude" → press Enter

Before Claude writes anything: Press Shift + Tab to enter Plan Mode. This makes Claude tell you exactly what it’s going to do before it does it. Review the plan. Approve it. Then let it work.

During the session: Type /compact every 10-15 minutes. This compresses the conversation so Claude doesn’t get confused by too much history.

When you finish a task: Save your work and start a fresh session for the next task. Don’t let one session run forever. Fresh sessions mean fresh thinking.

The two keyboard shortcuts worth memorising:

• Shift + Tab → Plan Mode (Claude shows you the plan first)

• Esc Esc → Rewind (undo the last thing Claude did)

That’s the whole daily pattern. Plan. Approve. Execute. Check. Save. New session.

Real Use Cases (For Non-Technical People)

Content creators: Use the quality-reviewer Skill after every piece of content. Use the tone-checker Skill to make sure everything sounds like you, not like AI. Use the headline-writer Skill to get 5 title options for every post.

Business owners: Use CLAUDE.md to store your brand rules, your customer persona, and your product details. Claude will reference these automatically in every session without you having to repeat them.

Newsletter writers: Use Hooks to make sure Claude never publishes anything without your review. Use a Subagent to check every issue for clarity before it goes live.

Freelancers: Create a separate CLAUDE.md for each client. Switch between them when switching projects. Claude will automatically adapt to each client’s rules and preferences.

These are the use cases that matter. Start with one that fits your work. Add more as you go.

In 20 Seconds

→ Create the folder structure before you do anything else.

→ Write your CLAUDE.md instruction manual with real rules

→ Set up Hooks for the rules that can never be broken.

→ Add Skills for any task you repeat more than three times.

→ Use a Subagent to check finished work before it leaves

Save this. Screenshot it. Come back to it.

Read more

Three days later - gone.

Not because you’re not smart.

Because the way most people consume information is broken.

It’s passive. It’s slow. And it was designed for a world before AI.

By the end of this issue, you’ll get my Claude Learning Accelerator Kit - 5 copy-paste prompts that turn anything you read into something you actually retain and use. Free. No opt-in.

Let me show you exactly how I fixed this - and why it took me embarrassingly long to figure out.

My honest story

Two months ago, I was trying to learn how to run paid ads.

I’d never done it before.

I had a course, a YouTube playlist, and a folder full of bookmarks I’d never opened.

I sat down for 3 hours. Read everything. Took notes. Felt productive.

A week later, I couldn’t explain the difference between a campaign objective and an ad set without Googling it.

That’s when I stopped reading about things and started learning with Claude.

I rebuilt my entire learning system from scratch.

What you’re about to get is that system.

I used this exact system to go from zero knowledge of Claude to setting it up live - in one afternoon.

That’s roughly 6 hours of tutorial videos compressed into 90 minutes of focused work.

What you’ll become

After 1 week: You stop re-reading things three times. First pass sticks.

After 1 month: You’re picking up new tools and skills in hours, not days. The people around you notice.

After 1 year: You’re the person who always knows what’s coming - because you absorb knowledge faster than anyone in the room. That has a career value that compounds.

The old way vs. the way that actually works

The old way: Read → Highlight → Forget → Re-read → Still forget → Give up or fake it

The new way: Feed → Extract → Quiz → Connect → Compress → Verify

Six steps.

Each one has a specific Claude prompt.

Let’s go.

If this is useful, share it with one person who’s been meaning to learn something new but keeps putting it off. Takes 10 seconds.

Share

Step 1: Feed Claude the source material

Before anything else, get your source material into Claude.

Paste an article. Drop a transcript. Upload a PDF. Give it a URL. Whatever you’re trying to learn - Claude needs to read it first.

Quick setup:

1. Open Claude at claude.ai

2. Paste your content directly into the chat - or use a URL if it’s a public page

3. Don’t ask it anything yet. Just say: “Read this. I’ll ask you questions in a moment.”

This one pause matters.

You’re telling Claude this is a study session, not a quick-answer session.

It changes how it responds to everything after.

This one line does all the work.

Without the setup message, Claude treats each question in isolation.

With it, the session is treated as a continuous learning conversation.

Step 2: Ask Claude to teach it back like a tutor

This is the Feynman method - but instant.

Richard Feynman believed you only understand something if you can explain it simply.

Now you don’t have to do the explaining yourself.

Claude does. Your job is to read it and flag what doesn’t land.

Quick setup:

1. After feeding the material, send this exact prompt (copy it exactly):

You are my personal tutor. I just shared a piece of content with you.

Teach me the 5 most important concepts from it — as if I'm smart but new to this topic.

For each concept:
- Give it a name
- Explain it in 2 sentences max
- Give me one real-world example I'd actually encounter

After you've taught me all 5, ask me: "Which one do you want to go deeper on?"

2. Read each concept out loud - this sounds weird, but it forces your brain to actually process it

3. Pick the fuzziest one. Go deeper on that one first.

The ‘ask me which one’ instruction at the end is what most people skip.

It turns a monologue into a dialogue.

That’s where the real retention happens.

Step 3: Run an active recall quiz

Reading feels like learning.

It isn’t. Retrieval is learning.

Every study on memory says the same thing: if you want something to stick, you have to pull it out of your brain - not push it back in.

A quiz forces retrieval. Claude builds the quiz for you in 10 seconds.

Quick setup:

1. After Step 2, send this:

Now quiz me on what I just learned.

Give me 5 questions - mix of multiple choice and short answer.
Don't make them easy. Make them test whether I actually understood — not whether I memorised words.

After I answer each one, tell me if I'm right, what I missed, and why it matters.

2. Answer each question without scrolling back up - the struggle is the point

3. When Claude corrects you, read the explanation twice

I’m going to be honest - this step feels uncomfortable.

That’s good.

Discomfort in learning means the material is moving from short-term to long-term memory.

Push through it.

Step 4: Build an analogy map

New knowledge needs a hook. Without one, it floats.

The hook is something you already know.

Claude can find one for you in 5 seconds - and once it does, the concept never leaves you.

Quick setup:

1. Tell Claude what you already know well - a hobby, a job skill, a subject you’re confident in

2. Send this prompt:

I already understand [marketing funnels / cooking / football tactics / project management — use whatever fits you].

Take the 3 hardest concepts from what I just learned and connect each one to something from my existing knowledge.

Be specific. I want to be able to say "ohh — it's like when..." and have it click.

Once you have the analogy, write it down in your own words.

That 30 seconds of writing encodes it faster than reading it five more times would.

Pause here. Read this before moving on.

I know the instinct is to race through and grab all 6 steps as fast as possible.

Resist that.

Steps 1 through 4 already give you more retention than 90% of the content people consume in a month.

If you stop here and actually do these four things the next time you’re trying to learn something, you’ll feel the difference today.

The last two steps are the ones that turn you from a learner into a practitioner.

Take a breath first.

Step 5: Compress it into a cheat sheet you’ll actually use

Long notes don’t get read. One-page cheat sheets do.

After you’ve learned the material, make Claude distill it for you into something you can scan in 60 seconds - something you’d actually open the next time you need it.

Quick setup:

1. Send this prompt:

This looks long. It isn’t work - it’s copy-paste. Claude writes this for you in 10 seconds. Your only job is to paste it into Gemini.

You are a visual prompt engineer for Gemini image generation.

I just learned about Google Ads in this session. Write me a Gemini image generation prompt for a flat educational cheat sheet infographic based on what we covered.

The prompt you write must produce this exact output when pasted into Gemini:

CANVAS SPECS:
- 1080x1350px portrait
- Flat design only — no illustrations, no icons, no 3D, no photography
- Background: off-white #FAF9F7

CONTENT TO INCLUDE (hardcode all text exactly as written below — no placeholders):

Header (dark bar #0A0A0F, full width):
- Title: "5 Google Ads Concepts That Save You Money"
- Subtitle: "What beginners get wrong — and how to fix it"
- Tag bar: Search · Display · Bidding · Metrics · Mistakes

5 Content Rows (alternating white and #F2F2F2 backgrounds):
Row 01 — Campaign Types
- Search captures existing demand. Performance Max lets Google's AI do the work.
- BEST FOR: Founders running their first ad campaign

Row 02 — Keyword Match Types
- Exact Match = full control. Broad Match = Google decides. Never use Broad without negative keywords.
- BEST FOR: Anyone tired of paying for clicks that never convert

Row 03 — Bidding Strategies
- Target CPA tells Google your max cost per lead. Manual CPC gives you full control.
- BEST FOR: Advertisers with at least 30 conversions already tracked

Row 04 — Key Metrics
- Quality Score (1–10): higher score = cheaper clicks. ROAS of 4x = $4 back per $1 spent.
- BEST FOR: Anyone trying to read their dashboard without guessing

Row 05 — Beginner Mistakes
- Never send traffic to your homepage. Always use a dedicated landing page.
- BEST FOR: Anyone who ran ads and wondered where the money went

Callout Box (blue left border, background #EFF6FF):
PRO TIP: Set a $10/day budget. Run 7 days. Look at data before touching anything.
COMMON MISTAKE: Auto-applying Google's recommendations without reviewing them. Turn it off day one.

Footer (bottom strip, two sides):
Left: "To get more free AI cheatsheets, join: humzakhalid.substack.com"
Right: "Hamza Khalid"

TYPOGRAPHY RULES TO INCLUDE IN THE PROMPT:
- Headlines and section labels: Clash Display 700
- All body text and bullets: Darker Grotesque
- Section numbers: white text on #2979FF rounded pill shapes
- Accent color: #2979FF
- Body text: #1A1A1A
- Muted text: #666666

STYLE RULES TO INCLUDE IN THE PROMPT:
- Flat design only
- No icons, no logos, no illustrations, no decorative elements
- No shadows, no gradients
- Every word above must appear exactly as written
- Typography is the only visual element

Output only the Gemini prompt — clean, copy-paste ready, nothing else before or after it.

2. Copy the output into Notion, Obsidian, or Apple Notes, or simply download it

3. Title it with the date so you can find it later

This is the artifact from every learning session.

Over 3 months, you build a personal knowledge library in your own words - indexed by topic, ready when you need it.

Step 6: Run the blind spot check

What you don’t know will hurt you.

This is the step most people skip - and the reason they still sound shaky when someone asks them a question about what they “learned.”

Claude will find the gaps you didn’t know you had.

Quick setup:

1. Send this final prompt:

Based on our full conversation today, tell me:

1. What did I seem to misunderstand or only partially grasp?
2. What important things from the original material did we NOT cover?
3. What would an expert on this topic say I still need to learn?

Be direct. I'd rather know the gaps now than discover them at the wrong moment.

2. Don’t get defensive when Claude points out gaps - this is the most valuable output of the whole session

3. Add the gaps to your next learning session as starting questions

The phrase ‘be direct, I’d rather know the gaps now’ is the unlock.

Without it, Claude softens the feedback.

With it, you get the honest version.

This newsletter grows from your shares. If you got value from this, forward it to one person who consumes a lot of content but retains very little.

Share

Real-world use cases

1. Learning a new software tool before paying for a course: Paste the tool’s documentation or a “getting started” article. Run Steps 1–3. You’ll know in 20 minutes whether the tool is worth your time and money - before spending either.

2. Absorbing a dense research paper or report: Paste the abstract, intro, and conclusion. Ask Claude to teach you the 5 findings that matter. Then quiz yourself on only those. Skip the middle 40 pages unless Step 6 tells you that you need them.

3. Prepping for a job interview or client call in under 2 hours: Feed Claude the company’s About page, a recent article they published, and the job description. Run the full 6-step system. You’ll walk in knowing more about their world than most candidates who spent a week preparing.

4. Getting up to speed on an industry you know nothing about: Find one good overview article. Run Steps 1, 2, and 4. The analogy map in Step 4 is especially powerful here - it connects an unfamiliar industry to your existing mental models in minutes.

These are the use cases that matter.

Nail these before you try to optimize anything else.

Before you close this, there are two things left. One is free. One could be the most valuable thing in this issue.

In 60 seconds

→ Feed Claude your source material and set the session context

→ Ask Claude to teach you the 5 key concepts as a tutor

→ Run the active recall quiz - answer without looking back

→ Build an analogy map from what you already know

→ Compress everything into a scannable cheat sheet

→ Run the blind spot check - find what you still don’t know

Save this. Screenshot it. Come back to it.

A word before your gift

Paid members of AI In Public aren’t just readers.

They’re the ones who come back and say, “I used that prompt and here’s what happened.”

That’s the gap. Between reading and doing.

Paid membership is where we close it - with deeper walkthroughs, prompt teardowns, and a community of practitioners who share what’s actually working.

If you’ve been thinking about it, this is the issue to do it. You’re already doing the work.

Read more

Type a big task.

It does one thing. Stops.

You type “continue.”

One more thing. Stops.

“Ok, now do step 3.” Stops.

You’re not using AI.

You’re parenting it.

That’s not a workflow.

That’s a second job you didn’t sign up for.

I spent months doing it.

40 minutes of supervision for tasks that should have run themselves.

Frustrated at AI - when really I just didn’t know this existed.

Anthropic just shipped the way out. It’s called /goal.

One command. You type what “done” looks like.

A separate model - not Claude - checks after every step. A neutral judge.

You come back to finish work. Done.

I’ve been testing it for two weeks. This issue is everything I found.

And by the end, if you’re a paid subscriber, you get the full /goal Condition Kit - 10 copy-paste goal conditions built for 5 different reader types. Paste and go. Under 2 minutes. No setup. No editing.

Keep reading. This one changes how you work.

The moment everything shifted for me

Last Tuesday. Content research pipeline. Seven steps.

I’d done it a dozen times - 40 minutes of “ok now step 3” every single time.

That Tuesday I typed /goal instead.

Set the condition. Made tea. Came back 11 minutes later.

Done. All seven steps.

My first reaction wasn’t excitement.

It was suspicion. “Did it actually finish or just stop and call it done?”

I checked. It finished.

That 40-minute babysitting session had just become 11 minutes of nothing.

Not just faster. A different relationship with the work entirely.

Yesterday, AI In Public crossed 2,000+ subscribers.

2,000+ people who showed up every issue to actually build - not just read about AI.

This issue is for all of you. Let’s get into it.

The proof

Anthropic released /goal in Claude Code version 2.1.139 on May 12, 2026.

Not experimental. Not a beta. Live right now - across Claude Code CLI, VS Code, JetBrains, the Desktop App, and Claude Code Mobile.

→ Official /goal documentation - code.claude.com/docs/en/goal

I read the full documentation so you don’t have to. This issue skips the technical language and shows you what actually matters - starting with wherever you are right now.

Think of someone on your team who sends you “Are you done yet?” messages every hour. This is the issue for them. Forward it. It takes 5 seconds.

Where are you now? Where you’ll be by the end of this.

Let me be direct about what this issue does.

Right now, your AI workflow looks like this:

You think of task → Prompt Claude → Claude does part of it
→ Claude stops → You check → You push → Claude does part of it
→ Claude stops → You check → You push → Claude does part of it
→ You lose track → You start over → You give up or settle

You are the engine. Claude is a wheel that needs pushing every 30 seconds.

By the time you finish reading this, your workflow will look like this:

You define "done" → Set /goal → Step away
→ Claude works → Judge checks → Not done → Claude works again
→ Judge checks → Done → You come back to finished work

You become the person who sets the destination. Claude is the driver.

That shift - from supervisor to director - is what this command makes possible.

And it’s available to you today, whether you’re a developer, a content creator, a newsletter writer, or someone who has never typed a command in their life.

I’ll show you exactly how to get there. Step by step. Starting now.

Step 1: Where /goal does it actually live - and it is not just the terminal

Most people see “Claude Code” and think: terminal. Black screen. Command line. Not for me.

Stop right there.

/goal Works on every Claude Code surface. Including the ones that look nothing like a terminal.

VS Code Extension      → Open Claude panel → type /goal [condition]
JetBrains Plugin       → Open Claude panel → type /goal [condition]
Claude Code Desktop    → Chat input → type /goal [condition]
CLI (Terminal)         → Run claude → type /goal [condition]
Claude Code Mobile     → Chat input → type /goal [condition]
Regular Claude Chat    → Does NOT work → use Manual Goal Block (Step 6)

If you use VS Code, you do not need to touch a terminal. Open the Claude Code extension panel on the right side of your editor, type /goal followed by your condition, and hit enter. It looks exactly like a chat window.

If you’re on JetBrains - IntelliJ, PyCharm, WebStorm - same panel. Same command. Same behavior.

The only place /goal does not work with the regular Claude chat at claude.ai. For that, I’ll give you the Manual Goal Block workaround in Step 6. It’s not the same thing - but it’s a version you can use today without installing anything.

Step 2: What /goal actually does

When you set a /goal, something different happens under the hood.

The system splits into two completely separate models.

Model 1 - The Worker: The main Claude. Reads files. Writes code. Drafts content. Executes commands. Does the actual work.

Model 2 - The Judge: A smaller, faster model. After every turn the Worker takes, the Judge steps in. It reads the conversation and asks one question: Does the condition hold? Yes or no. If yes, the goal is cleared, and Claude stops. If not, Claude starts another turn automatically.

The Judge is neutral. It doesn’t care how hard Claude worked - only whether the condition is actually met.

This is the key shift that changes everything.

In a normal session, Claude decides when it’s done. Claude is grading its own work. That’s how you get confident-sounding output that’s missing half the deliverables. Claude judged it complete.

In a /goal session, a separate model makes that call. The Worker and the Judge are never the same model at the same time.

The result: Claude stops lying to you about being finished.

Step 3: How to write a goal condition that actually works

I’ll be honest with you here, because this is where most people fail and blame the feature.

A vague condition gets vague results. If you type “improve my project” as your goal, Claude will wander and eventually tell you it’s done because the Judge has nothing specific to check.

The command is only as powerful as what you write into it.

A goal condition that actually works has three parts:

1. One measurable end state: Not “write the report.” Not “make it better.” Something with a clear pass or fail.

→ All five sections of the report are written, and each is over 200 words.

→ The content calendar has 7 days with a title and hook for each.

→ npm test exits 0 with no errors in the output.

2. How Claude proves it’s done: The Judge can only read what Claude has surfaced in the conversation. It cannot check files independently. So you have to tell Claude how to show proof.

→ Run npm test and paste the full output.

→ List all 7 days with their titles in a numbered format.

→ Count the words in each section and confirm all are over 200.

3. What must not change: This protects you from Claude solving the goal the wrong way - technically meeting the condition while breaking something else.

→ Do not modify the existing test files.

→ Do not change the tone guidelines.

→ Keep all headings in the format I specified.

Here’s what the difference looks like in practice:

Vague - Claude wanders:

/goal improve the dashboard

Specific - Claude drives:

/goal Refactor the dashboard component in /src/dashboard.jsx 
so that it loads in under 2 seconds on a slow 3G connection. 
Run the Lighthouse test and confirm the performance score 
is above 85. Do not change any existing API calls or 
remove any current features. Stop after 20 turns.

The turn limit at the end is not optional for any unattended run. It’s the safety net. Without it, a stuck goal can run longer and spend more tokens than you expect.

You now know more about writing a goal condition than 90% of people who’ve tried this feature.

Keep going.

The next step is where the actual shift happens.

Step 4: Set it. Step away. Here’s exactly what happens.

The moment you hit enter, Claude starts immediately. No confirmation message. No, “I’ll get started on that now.” It just goes.

Turns start ticking in the panel or terminal. Each turn is one complete cycle - the Worker executes, the Judge evaluates, and if the condition isn’t met, the Worker starts again.

To check the status without stopping the goal:

/goal

Type /goal With no condition. You see:

• The active condition

• How many turns have you run

• Tokens spent so far

• The last evaluator's reason - why the Judge said “not done yet”

That last one is the most useful signal you have.

If Claude is stuck, the evaluator's reasoning tells you exactly what it’s looking for and what it's not finding.

Most of the time, it’s because the proof requirement wasn’t specific enough.

This is the part where you feel the shift for the first time. You set the condition. You check the status. You see turns running. And you realize you have nothing to do right now. Claude is working. Without you.

That feeling is new. Let it land.

Step 5: What to do when it goes wrong

I won’t pretend this feature is perfect.

Here are the three things that go wrong and exactly what to do.

Scenario A - Goal is stuck in a loop: Claude keeps running turns. The Judge keeps saying no. Usually means the condition is asking Claude to prove something that can’t surface in the conversation.

→ Type /goal clear to stop it.

→ Rewrite the condition - be more specific about what proof looks like.

→ Set the goal again.

Scenario B - Goal has been running too long: You didn’t set a turn limit. It’s 30 minutes later, and it’s still going.

→ Ctrl+C Stops it immediately.

→ For every future unattended goal, add “or stop after [N] turns” at the end of your condition. 20 is a safe default.

Scenario C - Goal completed, but the output is wrong: The Judge said yes. But you look at the result, and it misses the point.

→ Your condition was too loose. The Judge can only check what you told it to check.

→ Add a more specific end state. Add a constraint. Add a stricter proof requirement.

These are the only three failure modes. That’s not a long list. And every one of them is fixable in under 2 minutes.

Step 6: Resume after interruption - the part nobody talks about

You set a goal. Your phone rings. You close the laptop. An hour later, you’re back.

In a normal Claude session, that’s a reset. Start over. Re-explain everything. Lose the progress.

With /goal Type this when you reopen Claude Code:

claude --resume

or

claude --continue

The goal comes back. The condition is restored exactly as you wrote it. Claude picks up and keeps working. You don’t re-explain. You don’t re-brief. You just resume.

I tested this on a Friday afternoon deliberately. Set a goal for a content plan. Closed the laptop. Opened it Monday morning. Typed --resume. Claude continued from the last completed section.

The turn count resets on resume - that’s expected. The condition itself doesn’t. Your goal survives the weekend.

This one feature alone is worth knowing for anyone who works in interrupted bursts. Which is everyone.

If you’ve made it this far and this is shifting something for you - forward this to one person who needs it. The people who share AI In Public are the ones who actually want to build, not just scroll. Be that person.

Share

The 5 people this was built for - find yourself here

This is where I want you to stop and find your use case. Not skim. Find yours.

If you create content for a living

You need 7 Instagram captions for the week. Normally, that’s 7 prompts, 7 checks, and an hour of supervision.

/goal Write 7 Instagram captions for an AI tips page for 
beginners, one per day Monday to Sunday. Each caption must 
be 3-4 lines, include one call to action, and be under 
100 words. Label each by day. Paste all 7 in order and 
confirm each one meets the format. Do not stop between 
days to ask for approval.

One condition. Come back to all seven.

The /goal Condition Kit - today’s paid gift - has two ready-to-paste content creator conditions: one for caption weeks, one for X thread series.

If you write a newsletter

You need research plus a structured outline. Normally, that’s two separate sessions, four prompts, and 45 minutes of active work.

/goal Research the top 5 reasons beginners fail with AI tools 
in 2026. For each reason, write a section title, a 2-sentence 
explanation, and one practical fix. Confirm all 5 are complete 
and each has all three elements before stopping.

Research and outline. One run. This is the exact version of the condition I use for my own newsletter research. The Kit has two newsletter writer versions - one for research, one for full drafts.

If you’re learning AI every day

You want a real study plan. Not a list of links. A week-by-week structure with actual daily tasks.

/goal Build a 4-week Claude learning plan for a complete 
beginner. Week 1: basics. Week 2: prompting. Week 3: workflows. 
Week 4: automation. Each week must have 5 daily tasks, 
each under 30 minutes. Output the full plan as a structured 
table. Confirm all 4 weeks and all 20 tasks are present.

A complete learning path. Confirmed before Claude closes the goal.

If you build things without code

You’re building a tool. Claude builds something. It half-works. You test it. It breaks. You re-prompt. The loop never closes.

/goal keeps Claude iterating on the same output until it actually runs. You define working. Claude doesn’t stop until it gets there. No more half-built tools you abandon out of frustration.

If you’re an engineer

You already know the pain. API migrations. Test suite fixes. Issue backlog that never gets triaged. Documentation that’s always 3 versions behind.

Set the condition once. Step away. Come back to a green build.

These are the five people this was built for. If you recognised yourself in one of them, you’re exactly where this newsletter is meant to land. And the gift at the end was built specifically for you.

The Manual Goal Block - if you’re not on Claude Code yet

You don’t have Claude Code installed. You use Claude Chat at claude.ai. You’re not a developer.

This is yours.

Copy this block. Paste it at the top of your next Claude session. Fill in the brackets. Hit enter.

SESSION GOAL — hold this for the entire conversation:

[Write exactly what done looks like in one sentence.]

DONE means:
- [Condition 1 — specific and measurable]
- [Condition 2 — how Claude proves it's complete]
- [Condition 3 — what must not change]

Do NOT stop mid-task to ask me for approval. 
Do NOT summarise what you're about to do.
Run straight through. Show me the full output at the end.
If you reach the end, check each condition above 
before telling me you're done.

This is not /goal. There’s no separate Judge. Claude still grades its own work. But it removes the babysitting loop for most tasks and gives you the same mental model - define done first, run toward it.

It works. I use this in regular Claude chat for tasks where I don’t need the full setup.

The paid gift at the end of this issue includes 5 pre-filled versions of this block - one for each reader type above. No brackets to fill. Paste directly and go. That’s in today’s Kit.

Stop here. Read this slowly.

You’ve just covered something most AI users will never take the time to understand.

They’ll keep typing “continue.” They’ll keep losing sessions when life interrupts. They’ll keep accepting whatever Claude gives them at turn one because nobody told them there was a way to define done and make Claude run toward it.

You’re not doing that anymore.

You now know where /goal lives - across every surface, not just the terminal. You know how the two-model system works. You know how to write a condition that the Judge can actually evaluate. You know the three failure modes and how to fix them. And you know that your goal survives the weekend.

The only gap between you and using this today is writing that first condition. One clear end state. One proof requirement. One constraint.

Three lines. And then you step away.

The Kit at the end of this issue has already written those three lines for your specific use case. Ten times over.

That’s what paid subscribers get. And if you’ve read this far, you already know this is worth it.

Read more

If you're reading this, you probably already use Claude.

You've saved yourself hours.

Maybe you've built something small.

But you haven't earned anything from it yet - not real money, not consistently.

By the time you finish this issue, that stops being about capability and starts being about decision.

I’ve been studying how people hit this number with AI - and the ones who get there aren’t building apps.

They’re following a sequence so simple it almost sounds wrong.

service → system → software

I didn't start here.

My first AI project was a Chrome extension I spent six weeks building.

I launched it to 47 downloads.

Zero dollars.

Then I did one consulting call for a local business - used Claude to build their lead response system - and charged $1,200.

That was in a single afternoon.

I haven't launched a free tool since.

The sequence most people skip

Here’s how most people approach AI income:

Old way: Build tool → Launch → Hope someone buys → Pivot → Repeat → Burn out.

New way: Find expensive work → Deliver it with AI → Systematize the delivery → Sell the system.

The math is simple. You need $10,000/month. That’s:

• 10 businesses paying $1,000/month

• 20 clients paying $500/month

• Or 1 retainer at $5K + a subscription product doing the rest

None of those numbers require viral reach.

They require a result that someone already pays for.

I used to think I needed 200 customers to make real money with AI.

Then I realized: I just needed 10 businesses who had a $1,000 problem I could solve with a $200 tool.

The math isn't complicated.

The discipline to stay in math is.

If this is useful, share it with one person building on AI right now. It takes 10 seconds.

Share

Step 1: Find the expensive problem

Don’t start with an app idea.

Start with work that a business already pays someone else to do.

Accounting. Lead follow-up. Compliance reporting. Customer support triage. Proposal writing. Social content for local businesses. Invoice chasing. Research briefs for law firms.

The test is simple: if a business currently has a human doing this job and that human costs $3,000–$15,000/month, you have a candidate.

Quick setup:

1. List 10 industries where you've ever been paid - jobs, freelance, family business. You're not picking a niche. You're mining for a problem you already understand.

2. For each industry, name one task an employee spends 10+ hours/week on

3. Cross off anything that requires physical presence or licensed professional judgment

4. You now have your shortlist

Use this Claude prompt to pressure-test your idea before you build anything:

You are a skeptical B2B consultant with 15 years of experience in service businesses.

I'm considering offering this service using AI automation:

"[Paste your service idea in one sentence]"

Target customer: [describe the business type and size]

Do the following:
1. Name 3 reasons this customer would pay for this result today
2. Name 3 reasons they might hesitate or say no
3. Estimate a realistic monthly price range for this service (low / mid / high)
4. Tell me the one biggest risk of delivering this at scale

Be direct. Don't sugarcoat.

Be direct. Don’t sugarcoat. This line matters. Without it, Claude gives you an optimistic pitch deck. With it, you get the honest version you need.

Step 2: Sell the result before you build

Here’s where most people get it wrong.

They spend 6 weeks building. Then they try to sell.

Flip it.

You sell a paid pilot first.

Three clients at $500–$2,000 each. You manually deliver the result using Claude and whatever tools you already have.

You don’t automate yet. You just do the work and get paid.

This does two things:

• Proves someone will pay before you invest months building

• Shows you exactly where the bottlenecks are before you systematize

A home service company example: you offer to manage their after-hours lead responses for 30 days. $1,500 flat. You use Claude to draft responses, and you review and send. You log every edge case.

After 30 days, you have the data to build a real system.

Quick setup:

1. Write a one-sentence offer that names the result

2. Contact 5–10 businesses via LinkedIn DM or email - ask for 15 minutes

3. Present the pilot in the call: I’ll handle [X] for 30 days. If you don’t see a result, you don’t pay.

4. Deliver it manually with Claude. Document every step.

Use this prompt to write your outreach:

Write a cold outreach message for this offer:

Service: I help [home service companies] recover leads that come in after hours by responding within 5 minutes, collecting their details, and booking a visit — all managed through your existing channels.

Pilot: 30 days, $1,500 flat. If you don't book at least 10 extra appointments, I'll refund the difference.

Target: Owner of a [plumbing/HVAC/electrical] business with 3–15 employees.

Rules:
- Under 100 words
- No jargon
- Lead with the result, not the process
- End with a clear single ask (15-minute call)

This prompt works because it forces Claude to lead with the result - 10 extra appointments - not with the technology. Buyers don’t care that you’re using AI. They care about the outcome.

Read more

Ask if the idea is good, get told it has potential, ship it anyway.

They are skipping the one system that could have saved them months of cleanup.

Save this before you lose it in your feed!

NASA does not let a rocket leave the pad on optimism.

Before every launch, every mission, every major call, they run a real, documented process to find the failure before the failure finds them.

It has a name. It has saved missions.

And almost nobody outside aerospace and high-stakes consulting knows you can run the same process inside Claude with 4 prompts.

No software. No clearance. No setup. Just paste.

5 minutes from now, you will know exactly how your plan dies, and how to stop it, before you spend a single dollar building it.

Claude is only as good as the system behind it. ClaudeKit gives Claude Code 121 slash commands, 25 skills, and 16 subagents across 6 specialized kits. One command installs a full working team.
→ Try it: theclaudekit.com

I learned this the hard way.

Eight months ago, I launched a paid product.

I had run it by three people I trust. Everyone said it looked strong. I shipped it.

It flopped in the first 48 hours.

Not because the product was bad.

Because I had assumed the wrong buyer. The exact assumption a premortem would have caught in 5 minutes.

I spent 6 weeks rebuilding what one structured question could have prevented.

That is what this issue is about.

Before I show you the 4 prompts, you need to understand why they work. This part is 60 seconds. It changes how you use everything below it.

What the ABORT Method Actually Is

NASA runs two things before anything important happens.

A Failure Review Board, which exists specifically to hunt for the reasons a mission could fail before it flies.

And a Go/No-Go poll, where every station has to give a binary answer, out loud, on the record.

No hedging. No “should be fine.“ Go or no-go.

What is the ABORT Method?

That same instinct exists in psychology under a different name.

In 2007, cognitive psychologist Gary Klein published a method in the Harvard Business Review called the premortem.

The idea: tell a team the project has already failed, one year from now, and ask them to explain why.

Not “what could go wrong.” What did go wrong? That single grammar shift, from maybe to already happened, is the whole trick.

It is not just a good idea. It is measured.

A 1989 study out of Wharton, the University of Colorado, and Cornell found that imagining a future event has already occurred increases people’s ability to correctly identify the real causes by about 30 percent compared to standard risk assessment.

Klein’s own follow-up research confirmed it again in 2010.

This is one of the most replicated findings in decision science, and most people have never used it on their own plans.

Here is the real prize.

You do not need a Wharton degree or a NASA badge.

The whole method is just a sequence of forcing functions.

You can run it inside Claude with 4 copy-paste prompts.

That is what the rest of this article is.

Why “What’s Wrong With This?” Will Always Fail

When you ask Claude, “Is this a good idea?” or “What should I watch out for?” you get the hedge. The “could go either way.” The “just make sure you.”

That is not analysis. That is politeness wearing a lab coat.

The reason a single prompt fails is the same reason a single risk assessment fails inside a real company.

Nobody wants to be the one who killed the room’s energy.

Devil’s advocate roles do not work either; researchers have found teams quietly dismiss them because everyone knows the criticism is assigned, not real.

The dissent gets outsourced to one voice, and everyone else relaxes.

NASA solved this with structure, not politeness.

Assume the failure already happened.

Assign people to attack the plan from specific angles.

Force every station to give a yes or no, on record.

The structure does the uncomfortable work, so no single person has to.

The four prompts below rebuild that exact structure inside Claude.

Prompt 1: The Premortem

This is the grammar shift that does 80 percent of the work.

Paste this into Claude.

Replace the plan in line 1.

My plan is: [YOUR PLAN, PROJECT, OR DECISION].
It is one year from now. This plan failed completely.
Not "could fail." It already happened.

Write the internal post-incident report as if you are
the project lead explaining the failure to leadership:

1. What was the ACTUAL cause of failure? Not the symptom,
the root cause underneath it.
2. What were the three early warning signs that were
visible at the time but got ignored or rationalized?
3. What assumption did the team treat as fact that turned
out to be false?
4. Who or what got blamed publicly, and what was the
REAL cause that the public blame was covering for?
5. What is the one sentence that, if someone had said it
out loud in the planning meeting, would have stopped
this entire failure?

What comes back: a forced confession your brain would never volunteer if you asked it to brainstorm “risks.” Asking for risks produces a polite list.

Asking for the autopsy of a failure that already happened produces the thing you were actually avoiding looking at.

A quick note from me:
The prompts in this issue are powerful.

But if you are using Claude Code for real work - content, engineering, SEO, ecom- you need more than prompts. You need a system.

ClaudeKit is 6 kits I built to give Claude Code a full team.

Type /mkt humanize and it strips every AI tell from your copy.

Type /eng debug and it roots the issue with evidence.

121 commands. Installed in under 5 minutes.

→ theclaudekit.com

Read more

Put in a prompt.

Get out an answer. Walk away.

That’s not a system.

That’s a habit. And habits don’t scale.

By the end of this issue, you'll get a free Claude Code Loop Template - 5 blocks, pre-built, variables ready to fill in and run in under 3 minutes.

Last month I hit a wall.

I had 6 recurring workflows - content briefs, inbox triage, research summaries, client reports. All of them ran on Claude. All of them ran on me.

Open Claude. Paste. Copy. Paste somewhere else. Close. Repeat.

I was spending 40 minutes every morning doing mechanical work that felt productive but wasn’t. The problem wasn’t Claude. The problem was me treating Claude like a calculator instead of an engine.

Then I built my first proper loop. Goal block. Instructions block. Start state. Result. Loop guard.

I hit enter and walked away.

When I came back - 6 content briefs. Named. Saved. Formatted. Done.

40 minutes → 4. Every morning. Without me.

I’ve rebuilt 6 workflows this way since.

What’s a Claude loop

A single prompt asks Claude to do one thing.

Then it stops. And waits. For you.

A loop doesn’t wait. It reads the next file, writes the next output, checks its own progress, handles its own errors - and keeps going until the work is done.

Think of it this way:

Prompting: You’re the engine. Claude is the tool.
Looping: Claude is the engine. You’re the one who built it.

Old way: Open Claude → Paste prompt → Copy output → Rebuild somewhere else → Repeat tomorrow.

New way: Build the loop once → Walk away → Come back to finished work.

The difference isn’t the prompt. It’s who’s doing the repeating.

If this is useful, share it with one person who needs it. Takes 10 seconds.

Share

There are two types of Claude users right now.

Type 1 opens Claude every morning. Types a prompt. Gets an output. Closes the tab. Does it again tomorrow? They’re users.

Type 2 builds a loop once. Comes back to finished work. Runs the same system on Monday that they ran last Monday - without touching it. They’re builders.

This issue is the line between the two.

By Step 5, you’ll be a builder.

Step 1: Define the Goal (not the task)

Most people write tasks. Claude needs a goal.

A task is: Summarize this article.

A goal is: I want a 5-bullet brief on every new article in this folder, saved as a separate .md file, until the folder is empty.

The goal has three parts:

1. What Claude is producing: the output format

2. What the condition is: what triggers each loop cycle

3. What is done looks like: when to stop

Quick setup:

1. Open Claude Code (terminal or VS Code extension)

2. Start a new session

3. Before any instructions, type your goal in this format:

GOAL: [What you want produced] for every [unit of input], saved as [output format], until [end condition].

Example goal:

GOAL: Write a 5-bullet content brief for every .txt file in /inbox, 
save each brief as a matching .md file in /output, 
until /inbox is empty.

Until /inbox is empty: this line is the entire loop. Without it, Claude does one file and stops.

Read more

You also know you’re not paying McKinsey $50,000 to produce one.

So right now, you’re making your biggest decisions with gut feel and a half-finished Notion doc.

That ends today.

Same frameworks.

Same output quality.

Same structure a senior partner would use - causal logic, decision-ready conclusions, explicit kill criteria for every strategy.

The difference between a $5,000 strategy session and a 47-minute Claude session isn't the frameworks. It's knowing how to ask for them.

This newsletter grows from your shares. If you got value from this, send it to one person who needs it.

Share

Eight months ago, I spent two days trying to decide whether to go paid on this newsletter.

I had opinions, gut instincts, and four half-finished Notion docs.

What I didn’t have: a competitive analysis, a pricing model, or a single risk scenario.

I ran Prompt 1, Prompt 6, and Prompt 9 on my own newsletter.

Ninety minutes later, I had all three.

Launched two weeks later.

The conversion rate landed between my base case and optimistic scenario.

Within 60 days, paid subscriptions covered my full production costs.

These prompts don’t give you answers.

They force you to ask the right questions - then make them impossible to ignore.

Why most AI strategy output is useless

Most people ask Claude for a SWOT.

They get a 2x2 grid of obvious observations with zero recommendations.

Real consulting output starts with a diagnosis and ends with decisions - not observations.

The difference is the kill criteria.

A strategy without explicit stopping conditions isn’t a strategy - it’s hope.

Every prompt here has it baked in.

I didn’t find these online.

I built them by reverse-engineering how McKinsey actually structures its deliverables - the role, the methodology, the output format.

Most people skip the kill criteria. That’s the part that does the work.

This newsletter grows from your shares. If you got value from this, send it to one person who needs it.

Share

The 10 Prompts

Prompt 1: SWOT That Actually Means Something

Most SWOT outputs are a list of facts.

This prompt forces Claude to make each point an insight with a “so what” attached.

You are a McKinsey Senior Partner with 20 years of experience in [your industry].

Conduct a full strategic SWOT analysis for [your business].

OUTPUT STRUCTURE:

CONTEXT AND STAKES
What are the key assumptions about the industry and our current position?
What changes if no action is taken in the next 90 days?

SWOT MATRIX
Each point must be an insight, not a fact.
- Strengths (4 points): include how to monetise each one
- Weaknesses (4 points): include the root cause, not just the symptom
- Opportunities (4 points): include the time window to capture each
- Threats (4 points): include probability and magnitude of damage

STRATEGIC INTERSECTIONS (TOWS Matrix)
SO: how to use strengths to seize opportunities
ST: how strengths defend against threats
WO: how opportunities can offset weaknesses
WT: risk minimisation when weaknesses meet threats

TOP 5 PRIORITIES FOR THE NEXT 30 DAYS
For each: specific action, owner, success metric, cost of inaction

EXECUTIVE SUMMARY (3 sentences only)
What is happening. What is critical. What to do immediately.

Each point must be an insight, not a fact - that single line is what prevents Claude from generating the generic 2x2 you’ve seen a hundred times.

Without it, you get observations.

With it, you get decisions.

The SWOT tells you where you stand.

The next prompt tells you where the fight actually is.

Read more

Tuesday - it forgot.

You explain again.

Wednesday - same thing.

You’re re-teaching a brilliant assistant that resets every single time you close the tab.

That’s not a bug.

That’s how every browser-based AI was built.

Hermes Agent by Nous Research was built to fix exactly that.

By the end of this issue, you’ll get a copy-paste Hermes First Week Setup Checklist - Obsidian-ready; grab it at the end.

I came across Hermes three weeks ago when it started showing up everywhere in my feeds.

180,000 GitHub stars in under 4 months.

Dealroom called it the fastest-growing open-source agent of 2026.

I wanted to see what the actual setup looked like - not the launch post version.

So I tested it.

Hermes just shipped v0.16.0 - their biggest release yet.
→ Official Hermes docs at hermes-agent.nousresearch.com

Don’t read the whole GitHub repo. I did it for you.

Here’s what I found.

What Hermes actually is

Hermes is a self-hosted AI agent.

It runs on your machine, a $5 VPS, or a cloud server.

Unlike Claude or ChatGPT in a browser, Hermes stays running between sessions.

It remembers what you told it last week.

After every task it completes, it writes a plain Markdown skill file that captures what worked - and automatically pulls it into future runs.

You talk to it through Telegram, Discord, Slack, WhatsApp, Signal, Email, or directly in the terminal.

200+ models supported.

MIT licensed.

Free.

Your data never leaves your machine.

The Old Way vs New Way

• The old way: Open Claude → Explain your project → Get output → Close the tab → Start over tomorrow.

• The new way: Open Hermes → It already knows your project → Output gets better every week automatically.

That’s the shift. Let’s set it up.

If this is useful, share it with one person who’s tired of re-explaining themselves to AI every single day. Takes 10 seconds.

Share

Step-by-Step Guide to Setting Up Hermes

Step 1: Install Hermes

Two options. Pick one based on your comfort level.

Option A: Desktop App (recommended for beginners)

1. Go to hermes-agent.nousresearch.com

2. Download the installer for your OS (macOS, Windows, Linux)

3. Open it, pick a model, done

No terminal. No config files. No prerequisites.

Honest note: On Windows, the installer isn’t code-signed yet. SmartScreen will flag it on first launch. Click “More info” → “Run anyway.” Nous Research acknowledges this in their own docs. It’s a known limitation of v0.16.0, not a security issue.

Option B: CLI Install (recommended if you’re comfortable with a terminal)

The only prerequisite is Git. The installer handles Python, Node.js, ripgrep, and ffmpeg automatically.

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

Confirm it worked:

hermes --version

Step 2: Run the setup wizard

One command walks you through everything:

hermes setup

This covers the model provider, API key, messaging channel, and memory settings, all in a single flow.

Then run a health check before anything else:

hermes doctor

This checks your Python version, dependencies, model context, and API connectivity.

Fix anything it flags before moving to Step 3.

Skipping this step is how people end up stuck 20 minutes later, wondering why nothing works.

Try these two starter messages:

• “What can you help me with?” confirms the LLM connection works

• “Search for the latest news about Nous Research & summarize in 3 bullets” - confirms tool calling works

Step 3: Enable Memory and Skills

This is the step that separates Hermes from every other chatbot you’ve used.

hermes setup

Look for two settings: persistent_memory and skill_generation. Set both to enabled.

What each one does:

persistent_memory: Stores conversation context in ~/.hermes. Searchable across sessions. Hermes pulls relevant context automatically when you start a new conversation.

skill_generation: After any task involving 5+ tool calls, Hermes writes a plain Markdown skill file to ~/.hermes/skills/. Next time you ask for something similar, it starts from a better place.

Without both of these on, Hermes is just another chatbot that resets. With both on, every session compounds.

Every complex task writes a skill file; this line does all the work. Without it, you have a capable agent. With it, you have one that gets measurably better every week.

Pause here

I know this looks like two simple toggles.

It’s not.

Every person I’ve seen give up on Hermes in the first week skipped this step.

They used it for 3 days, thought “it’s fine but not that different,” and moved on.

The memory and skill accumulation is what makes this tool different from everything else.

Enable both.

Give it 2 weeks.

Then tell me it’s not different.

Step 4: Pick your model

Hermes supports 200+ models. Here’s the honest breakdown of what actually works for most people:

• Kimi K2.5 from Moonshot: Community consensus for beginners. Fast. Roughly $3/day for heavy use. Excellent at agentic tasks. Start here if you’re unsure.

• DeepSeek V4: Cheapest option at around $2/month. Good output for the price. Best for getting comfortable with the system before spending more.

• Nous Portal: One subscription, 300+ models plus web search, image generation, TTS, and cloud browser. Best option if you don’t want to manage API keys across providers.

• Local Ollama: Free. Fully private. No API costs. Needs real RAM, though; 70B parameter models need 40GB+ quantized. Start with smaller models on a regular laptop, or it will crawl.

One honest caveat: avoid using Claude or GPT as your daily Hermes driver until you understand token costs. They work. They just cost significantly more at scale, and that surprise bill is unpleasant.

This newsletter grows from your shares. If you got value from this, pass it on.

Share

Step 5: Connect Telegram

Telegram is the most common starting point. Your agent on your phone, anywhere.

hermes gateway setup

1. Select Telegram

2. Create a bot via BotFather (it walks you through this)

3. Paste your token

4. Done

Message your bot from your phone. It responds. You can now kick off tasks, check on progress, or run automations from anywhere- no laptop required.

Step 6: Set your first automation

Don’t start with something complex. Start with one thing that costs you real time every day.

The highest-value first automation for most people:

Daily standup summary

Tell Hermes:

Every morning at 8am, pull my git log from the last 24 hours, 
check my open GitHub issues, and send me a Telegram summary 
of what I shipped and what's still open.

Hermes supports natural language scheduling. No cron syntax. It handles the job, sends the output to Telegram, and writes a skill file so it runs cleaner next time

That one automation alone is worth the 30-minute setup time.

Key Commands You’ll Use Daily

hermes: Start interactive session

hermes model: Switch model or provider

hermes tools: Configure tools

hermes gateway: Set up messaging channels

hermes doctor: Diagnose issues

hermes update: Update to the latest version

hermes claw migrate: Migrate from OpenClaw

Slash commands inside a session:

/new: Fresh conversation when context gets messy

/model: Swap LLM mid-conversation without restarting

/goal: Run an autonomous task loop

/undo: Undo last action

/reset: Clear current context

What to expect in the first month

• Day 1–2: Basic tasks work. The agent is still learning your context.

• Day 3–7: Skill files start accumulating. Output becomes more specific to your projects without you having to re-explain.

• Week 2–3: Same tasks produce measurably better results. Less correction needed.

• Month 1: You have an agent who understands your workflow without being reminded. The gap between this and every other AI tool you use becomes obvious.

Day one is the worst it will ever be. Every session after that, it’s building a deeper model of who you are and what you need.

In 60 seconds:

→ Install via desktop app or CLI with pip install hermes-agent

→ Run hermes setup then hermes doctor before anything else

→ Enable persistent_memory and skill_generation - don’t skip this

→ Start with Kimi K2.5 or DeepSeek V4 if you’re unsure on models

→ Connect Telegram, set one daily automation, let the skill files accumulate

Save this. Screenshot it. Come back to it.

Your gift - as promised:

Hermes First Week Setup Checklist copy-paste file with every step from this issue, the key commands, model recommendations, and a 7-day progress log template.

---
title: Hermes First Week Setup Checklist
tags: [hermes, AI-tools, setup, agent]
---

## Pre-Launch
- [ ] Install Hermes (desktop or CLI)
- [ ] Run `hermes setup`
- [ ] Run `hermes doctor` — fix all flags before proceeding
- [ ] Enable `persistent_memory` in setup
- [ ] Enable `skill_generation` in setup

## Model Setup
- [ ] Chosen model: ________________
- [ ] API key connected and verified
- [ ] Test message sent: "What can you help me with?"
- [ ] Tool call test: "Search for the latest Nous Research news and summarize in 3 bullets"

## First Integrations
- [ ] Telegram connected via `hermes gateway setup`
- [ ] First automation set (daily standup or similar)

## 7-Day Progress Log
Day 1: ______________________________
Day 2: ______________________________
Day 3: ______________________________
Day 4: ______________________________
Day 5: ______________________________
Day 6: ______________________________
Day 7: ______________________________

## Key Commands
| Command | What it does |
|---|---|
| `hermes` | Start interactive session |
| `hermes model` | Switch model or provider |
| `hermes tools` | Configure tools |
| `hermes gateway` | Set up messaging channels |
| `hermes doctor` | Diagnose issues |
| `hermes update` | Update to latest version |
| `/new` | Fresh conversation |
| `/model` | Swap LLM mid-conversation |
| `/goal` | Run an autonomous task loop |
| `/undo` | Undo last action |

## Week 1 Reflection
What tasks produced skill files this week?
______________________________

What automations are running?
______________________________

What surprised me most?
______________________________

Copy this into Obsidian and start filling it in on Day 1.

Here are a few issues that you might have missed (go check them out):

• How to master Claude Inside Excel

• How to use Claude’s whole week without hitting limits

• How to Build Claude Skills

• How to Create Videos Using Claude

• How to Use Claude as a Financial Analyst

• Claude Just Became a Video Studio

• Stop using 7 apps to do just 1 thing

• How to build an app with Claude Artifacts

• Claude for Chrome

• Stop building Claude Skills like this

• I set up my second brain in under an hour

• How to use Claude Design like an Anthropic Engineer

• Your AI Memory Is Broken if you are missing this one hack

• Clone Any Faceless YouTube Channel with Claude (Step-by-Step)

• How to fix your Obsidian graveyard with Claude under 20 mins

• Which AI model should you use in 2026

• I gave Claude Fable 5 a Month-Long Project - Here is what happened

• 15 Insane Things People Built With Claude Mythos in 48 Hours

• Stop Prompting Claude. Build Loops Instead

• US Just Disabled Mythos and Fable 5. Here’s What’s Gonna Happen Next

• 7 advanced Claude Loops that run your work autonomously

• 20 Resources to master Claude in 7 Days

• Vibe Coding: The Complete Claude’s Beginner Guide 2026

• 15 Claude Prompts that save me 30 hours a week

• 25 Ways to Use Claude (90% of People Know Only 3)

We tested it in public. Now go use it in private.

If this issue gave you something real, a framework, a starting point, a moment where something clicked, share it.

Share

Not for me. For the person in your life who’s been using Claude for six months and still asking, “How do I get better at this?

And for shorter takes between issues, follow me on X → Hamza Khalid

PS: Are you already running a self-hosted agent - or is Hermes the first one you’re seriously considering?

Hit reply -I read every response.

- Hamza 💙

They get an answer.

They copied it somewhere.

They close the tab.

That’s not using Claude.

That’s using 5% of it.

I spent the last month mapping every mode, feature, and workflow Claude actually supports - and there are 25 of them.

Eight months ago, I was paying $20/month for Claude Pro.

I used it to rewrite LinkedIn posts and fix grammar. That’s it.

Then one afternoon, I got frustrated with a newsletter draft that wasn’t working. I’d rewritten the opening four times. It still felt flat.

I didn’t ask Claude to fix it. I asked Claude to tell me why it wasn’t working.

It diagnosed the problem in 11 seconds. Weak hook. No gift promise.

The reader had no reason to keep reading past paragraph two.

Sound familiar?

That conversation changed how I use Claude. Not as a writing tool.

As a thinking partner. I started testing every feature I’d ignored.

Extended Thinking. Projects. Memory. Skills. Higgsfield. Obsidian MCP.

What I found: most people are using Claude like a calculator when it’s actually a studio.

This issue is everything I found. All 25 modes. Honest about what works.

Honest about what doesn’t. Let’s go.

Here’s what changes after you read this:

Before: You open Claude, type a question, get an answer, and close the tab. You’re a user.

After: You know which of the 25 modes fits which problem. You stop starting from scratch. You stop re-explaining yourself every session. You stop leaving 80% of what you’re paying for unused. You become an operator. User → Operator.

That’s the shift this issue makes.

The 25 Ways - Grouped by What They Do For You

I’ve grouped these into 5 categories:

• Think

• Create

• Build

• Connect

• Automate.

That’s how your brain should file them.

The gap isn’t intelligence. It’s not knowing what to ask for.

Claude can do 25 things. You’ve been asking for 3.

THINK - Claude as Your Reasoning Partner

1. THINK: Extended Thinking

Turn this on when the problem is hard.

Claude actually reasons step by step before answering - not just generating a confident-sounding response.

I use this for contract analysis, strategic decisions, and anything where being wrong costs me time.

Quick setup:

1. Start a new conversation

2. Click on the Model Selection button.

3. Then, click on Efforts.

4. Turn on the extended thinking toggle before sending.

5. Give it a complex problem - not “write me an email”

The output looks the same. The reasoning underneath it isn’t.

2. RESEARCH: Deep Research

Claude builds a research brief on any topic - with sources, structured sections, and a clear conclusion. I used this to map the AI newsletter landscape before I started posting. Saved me 4 hours.

Quick setup:

1. Ask: “Do deep research on [topic] and give me a structured report with sources”

2. Turn on web search in settings first (Click on “+” icon and then select Web Search)

3. Let it run - this takes 2–3 minutes

This newsletter grows from your shares. If you got value from this, pass it on.

Share

3. ANALYSE: Document Upload

Upload a PDF, a contract, a report - anything. Ask Claude questions about it. I do this with every tool pricing page I’m comparing. Paste the PDF, ask “what am I paying for and what’s missing.”

Quick setup:

1. Click the “+” icon

2. Upload any PDF or document

3. Ask specific questions - not “summarise this”

Quick check - how many of those first 3 have you actually used?

If the answer is zero, you’re already

3x more capable than you were 5 minutes ago.

Keep going. It gets better.

CREATE - Claude as Your Content Engine

4. WRITE: Long Form Drafts

Full newsletter issues. Blog posts. Case studies. Give Claude a detailed brief - not a vague topic - and it drafts the whole thing. I use Projects for this, so it remembers my voice and past issues.

Quick setup:

1. Open or create a Project

2. Add your style guide as a document in the Project

3. Brief with: angle, audience, goal, key points, word count

The brief is the product. A weak brief gives you a weak draft - every time.

5. PROMPT: Prompt Builder

Ask Claude to write their own prompt for a task. Tell it the outcome you want and ask it to generate the best prompt to get there. Meta - but it works. I built 12 newsletter prompts this way in an afternoon.

Quick setup:

1. Say: “I need a prompt that does [X]. Write the best prompt for this.”

2. Ask it to explain why each line matters

3. Test the prompt immediately in a new chat

6. DESIGN: Claude Design

Generate images directly inside Claude. I use this for quick visual concepts - not final assets. It’s not Midjourney. But for wireframes, mood boards, and “roughly like this” visuals, it’s fast.

Quick setup:

1. Describe what you need - style, content, purpose

2. Iterate with “make it more [X]” follow-ups

Read full step-by-step guide here👇

7. PRESENT: Slides in Claude

Ask Claude to build a slide deck outline - or a full HTML presentation. I haven’t replaced Canva with this, but for internal decks and first drafts, it gets me 80% of the way in 5 minutes.

Quick setup:

1. Go to claude.ai → Claude Design (separate from regular chat)

2. Click “Create new presentation”

3. Paste your prompt - Claude will ask a few clarifying questions first, then build

8. TRANSLATE: Document Digest

Upload a document in any language and ask Claude to translate and summarise it. I used this on a Spanish AI report last month. Full English summary in 90 seconds. Accurate. Readable.

Quick setup:

1. Upload the document by clicking on the “+” icon.

2. Say: “Translate this and give me a 5-bullet summary of the key points”

3. Follow up with specific questions in English

If this is useful, share it with one person who needs it. It takes 10 seconds and costs nothing.

Share

Quick note before Next section:

You don’t need to be a developer to get value from the next 4 items.

Item 10 needs zero code.

Item 11 needs zero code.

Item 12 needs zero code.

Item 9 needs one command.

I’ll show you exactly what to type.

Stay with me.

BUILD - Claude as Your Developer

9. CODE: Claude Code

This is the terminal-based Claude that writes, runs, and fixes code in your actual project. Not a chat assistant that generates code snippets. It operates in your codebase. I used it to build a full content tracking dashboard - no developer needed.

Quick setup:

1. Install Claude Code via npm: curl -fsSL https://claude.ai/install.sh | bash

2. Open your project folder in the terminal

3. Type claude and give it a task

Read the full guide here👇

In your actual codebase - that’s the phrase that matters. This isn’t a code suggestion tool. It’s an autonomous developer.

10. REVIEW: Code Review

Paste any code and ask Claude to review it for bugs, security issues, or performance problems. I do this before deploying anything. It catches things I miss - especially edge cases.

Quick setup:

1. Paste your code in Claude's new chat.

2. Say: “Review this for bugs, security issues, and performance problems. Flag anything critical.”

3. Ask it to fix what it finds

This newsletter grows from your shares. If you got value from this, pass it on.

Share

11. FILM: Claude as a Video Studio

I used to think video required a camera, an editor, and half a day. Then I connected Claude to Higgsfield. Now I script, generate, and publish short-form AI videos without recording a single second of footage.

This isn’t a screen recording. This is Claude writing the script, Higgsfield generating the cinematic footage, and me publishing the result - start to finish in under 30 minutes.

Quick setup:

1. Connect Higgsfield to Claude via MCP in settings

2. Describe your video concept to Claude - it writes the script and the generation prompt

3. Claude sends the prompt to Higgsfield and returns your video

Read the full guide here👇

I don’t own a camera. Every video on my feed was generated. Claude wrote the prompt. Higgsfield made the footage. Nobody can tell the difference.

12. RENDER: Artifacts

Claude can output fully functional HTML, CSS, and JavaScript as a live preview inside the chat. Ask it to build a calculator, a landing page, a data viz - and it shows you the working version. I built a simple prompt testing tool this way.

Quick setup:

1. Click on the Artifacts Icon on the left side of the chat menu.

2. Select the category.

3. Ask: “Build me a [tool/page] and render it as an Artifact”

4. Interact with the live output directly in chat

5. Say “fix [issue]” or “add [feature]” to iterate

Read the step-by-step guide here👇

CONNECT - Claude as Your Integration Layer

13. CONNECT: MCP Servers

Model Context Protocol lets Claude connect to external tools - your calendar, your CRM, your database. This is the feature I’m most excited about right now. Not fully mainstream yet, but the builders are already using it.

Quick setup:

1. Go to Claude settings → Connectors → Customize → “+”

2. Search for the App that you want to connect to.

3. Connect an MCP server (start with a simple one like Google Calendar or Google Drive

4. Ask Claude to do something that requires that data

Read the step-by-step guide here👇

14. SEARCH: Web Search

Claude searches the web live and brings the results into your conversation. I use this for anything where my question has a “right now” component - current prices, recent launches, live events.

Quick setup:

1. Click on the “+” icon in the chat bar.

2. Toggle web search on

3. Ask any question that needs current information

4. Claude cites its sources - click through to verify

15. BROWSE: Claude in Chrome

The Chrome extension lets Claude see what’s on your screen as you browse. You can ask it to summarise, extract, or act on any page you’re looking at. I use it to extract structured data from pricing pages without copying anything manually.

Quick setup:

1. Install the Claude for Chrome extension from the Chrome Web Store

2. Browse to any page

3. Open the extension and ask “what’s on this page” or “extract [specific thing].”

Read the step-by-step guide here👇

This newsletter grows from your shares. If you got value from this, pass it on.

Share

16. SPREADSHEET: Claude in Excel

The Excel integration lets Claude read your spreadsheet and build formulas, analyse data, or generate charts based on what’s in the cells. I used it to clean a messy CSV in under 3 minutes last week.

Quick setup:

1. Install Claude for Excel from Microsoft AppSource

2. Open any spreadsheet

3. Ask: “Analyse this data and tell me the 3 biggest patterns”

Read the step-by-step guide here👇

Stop scrolling for one second.

You just learned 16 things that most Claude users will never discover.

The next 9 aren’t features.

They’re the difference between using Claude and being powered by it.

Don’t skim what’s coming.

AUTOMATE - Claude as Your Operating System

17. AUTOMATE: Cowork

Cowork is Claude’s desktop agent for non-developers. It can manage files, automate repetitive tasks, and move things between apps on your computer - no code required. Think of it as having a junior assistant who never gets tired.

Quick setup:

1. Download the Cowork desktop app from claude.ai

2. Open it and describe the task you want automated

3. Start with something small: organise a folder, rename files in bulk

18. BUILD: Second Brain with Claude

I used to lose every good idea I had. Read something useful - forgot it by Thursday. Had an insight in the shower - gone by the time I opened my laptop.

Then I built a second brain inside Obsidian using Claude. Now every article I read, every idea I have, every newsletter I write gets captured, connected, and retrievable in seconds.

This isn’t note-taking. This is Claude processing your raw thoughts and turning them into a structured, searchable knowledge system that compounds over time.

Quick setup:

1. Install Obsidian (free) and the Local REST API plugin

2. Connect Claude Desktop to your vault via MCP

3. Tell Claude: Here’s what I read today - extract the key ideas, connect them to what I already know, and save them as linked notes

Read the full guide here👇

My vault has 2,000+ notes. Claude built most of it. I just kept feeding it things I found interesting.

19. INSTALL: Skills

Claude Skills let you save a set of instructions that Claude always follows in a specific Project. It’s like giving Claude a permanent job description. I have a skill for newsletter writing, one for LinkedIn posts, and one for code review - all different.

Quick setup:

1. Open a Project

2. Add a document called “How to work with me on [task].”

3. Write your instructions there - Claude will follow them every time

Read the step-by-step guide here👇

20. STORE: Projects

Projects are persistent workspaces where Claude remembers your documents, your instructions, and your conversation history across sessions. Every serious workflow I have lives in a Project now - not a one-off chat.

Quick setup:

1. Click “Projects” in the left sidebar

2. Create a new Project with a clear name

3. Add any documents Claude needs to know about

This newsletter grows from your shares. If you got value from this, pass it on.

Share

21. REMEMBER: Memory System

Claude can remember information about you across conversations - not just within a Project. It stores preferences, context, and facts you’ve told it. I told Claude my newsletter’s voice rules once. It remembered them in the next session.

Quick setup:

1. Go to Settings → Memory

2. See what Claude currently remembers about you

3. Edit or add to it manually, or let Claude learn from conversations

22. PLAN: Project Planner

Ask Claude to build a full project plan - with milestones, tasks, owners, and timelines - for any goal. I used this to plan my newsletter editorial calendar for the next quarter. Gave me a structure I actually used.

Quick setup:

1. Say: “Build a project plan for [goal]. I have [X weeks] and [N people].
   Output it as: Phase / Milestone / Tasks / Owner / Deadline”

2. Iterate until the structure fits your reality

3. Copy into Notion or Asana

23. TEACH: Tutor Mode

Tell Claude you want to learn something and ask him to teach you - with examples, questions, and checks on your understanding. Not just explain it once. Tutor you through it. I used this to learn Python basics in 3 sessions.

Quick setup:

1. Say: “Teach me [topic]. Start with the basics. Ask me questions as you go to check my understanding.”

2. Answer the questions - even if you’re guessing

3. Ask “Why was I wrong?” on anything you miss

4. Use the copy-paste prompt pasted below:

Teach me how Claude's context window works 
and why it matters for my daily use.

Rules for this session:
- Start with the simplest possible explanation
- Use one real-world analogy
- After every concept, ask me one question 
  to check if I understood
- If I answer wrong, correct me gently and 
  re-explain before moving on
- If I answer right, go deeper
- Keep each response under 150 words

Start now.

24. REVIEW → PROMPT: Prompt Builder Loop

This is a workflow, not a feature. Use Claude to review your own prompts, score them, and rewrite the weak ones. I run every new prompt through this loop before I use it in production.

Quick setup:

1. Paste this copy-paste prompt into your claude new chat along with your prompt:

Here is a prompt I wrote:

[PASTE YOUR PROMPT]

Review it for:
1. Clarity — is the task unambiguous?
2. Role — does it give Claude a clear role?
3. Output format — does it specify exactly what I want?
4. Constraints — does it eliminate the outputs I don't want?

Score each out of 10. Then rewrite the prompt to score 9+ on all four.

Score each out of 10 - this one line forces Claude to be specific, not just polite about what’s wrong.

25. REFLECT: Claude as a Thinking Partner

This is the one nobody talks about. Ask Claude to challenge your assumptions. Push back on your plan. Find the hole in your argument. I use this before every big decision - not to get an answer, but to find the question I missed.

Quick setup:

1. Describe your plan, idea, or decision

2. Say: Play devil’s advocate. What’s the strongest argument against this? What am I not seeing?

3. Don’t defend yourself - just listen

This newsletter grows from your shares. If you got value from this, pass it on.

Share

The Honest Take

Not all 25 are worth your time right now.

Here’s the real breakdown:

Use daily: Projects, Memory, Web Search, Document Upload, Long Form Drafts, Code Review

Use when you need them: Extended Thinking, Deep Research, Artifacts, MCP Servers, Prompt Builder

Watch and wait: Claude Design for images (still maturing), Claude in Chrome (powerful but requires paid plan)

Underrated: Tutor Mode, Prompt Builder Loop, Second Brain with Claude, Thinking Partner - most people skip all four entirely

In 60 Seconds:

→ Claude has 25 distinct modes - most people use 3

→ Group them: Think / Create / Build / Connect / Automate

→ Daily drivers: Projects, Memory, Web Search, Document Upload, Drafts

→ Power moves: Extended Thinking, Artifacts, MCP Servers, Code

→ Underused: Tutor Mode, Thinking Partner, Prompt Builder Loop

Save this. Screenshot it. Come back to it.

Here are a few issues that you might have missed (go check them out):

• How to use Claude’s whole week without hitting limits

• How to Create Videos Using Claude

• How to Use Claude as a Financial Analyst

• Stop building Claude Skills like this

• Your AI Memory Is Broken if you are missing this one hack

• Clone Any Faceless YouTube Channel with Claude (Step-by-Step)

• How to fix your Obsidian graveyard with Claude under 20 mins

• Which AI model should you use in 2026

• I gave Claude Fable 5 a Month-Long Project - Here is what happened

• 15 Insane Things People Built With Claude Mythos in 48 Hours

• Stop Prompting Claude. Build Loops Instead

• US Just Disabled Mythos and Fable 5. Here’s What’s Gonna Happen Next

• 7 advanced Claude Loops that run your work autonomously

• 20 Resources to master Claude in 7 Days

• 15 Claude Prompts that save me 30 hours a week

We tested it in public. Now go use it in private.

If this issue gave you something real, a framework, a starting point, a moment where something clicked, share it.

Share

Not for me. For the person in your life who’s been using Claude for six months and still asking, “How do I get better at this?

And for shorter takes between issues, follow me on X → Hamza Khalid

PS: Which of these 25 did you not know existed before today?

Hit reply - I read every response.

- Hamza 💙

I use Claude every day.

I still feel like I'm doing everything manually.

That was me six months ago.

Not because I wasn't using AI.

Because I was using it like a search engine - one question at a time, no system behind it.

These 15 prompts are the system I built to fix that.

Before I had these prompts locked in, I was spending my week writing first drafts from scratch, doing research I’d then rewrite anyway, replying to emails that took 20 minutes each, and building plans I’d revise three more times.

Now I don’t do any of that manually.

Six months ago, I had a bad week.

Not bad because nothing was happening. Bad because everything was happening at once - and I was handling all of it manually.

Client deliverable due Thursday. Newsletter due Wednesday. Three proposals are sitting in my drafts, half-written. A Notion dashboard with colour-coded priorities that made me feel organized but changed nothing.

I was using Claude every day. Multiple times a day. And I was still drowning.

That’s when I realized the problem.

I wasn’t building with Claude. I was asking Claude. One question at a time. No consistency. No system. Every session started from scratch - same context, same re-explaining, same mediocre output because I hadn’t learned how to ask properly.

I was using a power tool like a search engine.

So I stopped everything for two weeks. Not to rest. To test.

I tracked every prompt I used. Kept a note. Marked the ones that saved real time - 30 minutes or more. Deleted everything that didn’t clear that bar.

15 prompts survived.

That’s what this issue is.

Not 50 prompts that sound impressive. Not a swipe file. Fifteen that I actually go back to, every week, that make the difference between a productive week and a reactive one.

Here’s the honest version: most people will read all 15 and use none of them.

So before you go further - pick one answer:

What’s eating your week right now?

Writing?

Research?

Emails and proposals?

Planning?

Running the same tasks on repeat?

Find that category. Start there. The other four will wait.

If this is useful, share it with one person who needs it. It takes 10 seconds and costs nothing.

Share

Before these prompts, here’s what a typical week looked like:

Monday: staring at a blank doc trying to write a first draft.

Tuesday: three browser tabs open, reading to “research” before actually writing.

Wednesday: rewriting an email proposal for the fourth time.

Thursday: trying to remember what you decided last week.

Friday: wondering where the week went.

After these prompts:

Monday: first draft done in 40 minutes. Prompt 1.

Tuesday: research compressed into a structured brief. Prompt 4.

Wednesday: proposal written, sent, done. Prompt 8.

Thursday: weekly plan already built on Monday, prompt 10.

Friday: you’re either shipping or you’re resting, not catching up.

That’s not a productivity improvement.

That’s a different way of working.

The person who has a system for this looks fundamentally different from the person who doesn’t - in client calls, in output quality, in how much they can take on.

Category 1: Writing Prompts

Prompt 1: The First Draft Killer

Use this when you have a topic in your head but are staring at a blank page.

You are a newsletter writer for a technical-but-human AI newsletter called AI In Public.

Write a complete first draft for an issue on this topic: [Claude's new memory feature and how to set it up in 10 minutes].

Rules:
- Open with a bold claim or vivid contrast — not context
- Write in first person as Hamza Khalid — specific, honest, direct
- Include 5 numbered steps with exact actions per step
- Total length: 1,200–1,500 words
- No filler. No theory without proof. Short sentences.

Don't ask me questions. Write the full draft.

Don’t ask me questions. Write the full draft - this line alone saves 4 back-and-forth rounds. Without it, Claude hesitates. With it, Claude commits.

Prompt 2: The Rewrite Surgeon

Use this when you have a draft that’s “almost there,” but something feels off.

Here is a draft I wrote: [paste your draft here]

Your job is to rewrite it with these specific fixes only:
1. Cut every sentence that doesn't add information or create emotion
2. Replace every passive verb with an active one
3. Make the opening line stronger — bold claim or vivid contrast
4. Shorten any paragraph over 4 lines into 2–3 lines

Do not change the structure. Do not add new ideas. Surgical fixes only.
Return the full rewritten draft.

Surgical fixes only are the key phrase. Without it, Claude rewrites your voice out of the piece. With it, you get your draft back - tighter.

Prompt 3: The Headline Factory

Use this whenever you need a title, email subject line, or post hook.

Topic: [I tested 12 Claude prompts for a month. Here are the 5 that actually saved time.]

Generate 10 headline options using these 5 formats:
1. Accusation ("You're doing X wrong")
2. Desire ("How to X in Y minutes")
3. Bold claim ("X just changed Y")
4. Number list ("N things that X")
5. Contrast ("Most people do X. I do Y.")

Give me 2 headlines per format. Score each out of 10 for curiosity, clarity, and click-likelihood. Recommend the strongest one and explain why.

The scoring system is what makes this useful. Without it, you still have to pick. With it, Claude defends its recommendation - and you can disagree with the data.

Category 2: Research Prompts

Prompt 4: The 10-Tab Killer

Use this before you open 10 browser tabs on a topic you need to understand fast.

I need to understand [AI agents and how they differ from regular Claude prompts] well enough to teach it to a non-technical audience in a 5-minute read.

Give me:
1. A plain-English explanation (3 sentences max)
2. The 3 most important things to know — with one real example each
3. The 2 most common misconceptions people have about this
4. One specific use case I can test myself today

Format it as a numbered list. Keep each point under 4 lines. No academic language.

The way it is presented to a non-technical audience is what controls the output. It tells Claude the ceiling for complexity - and forces it to choose examples that are actually useful.

Prompt 5: The Competitor Intelligence Brief

Use this when you need to understand what a competitor, creator, or company is doing - fast.

I need a competitive intelligence brief on [Justin Welsh's LinkedIn content strategy].

Cover:
- What topics he covers (top 3 categories)
- What content format he uses most
- What his audience seems to respond to most (based on what you know)
- 3 things he does well that I should study
- 1 thing he doesn't do that I could own

Be specific. No surface-level observations. I need actionable intelligence, not a summary.

Actionable intelligence, not a summary, is the phrase. Claude will give you a Wikipedia-level summary by default. This one line forces it to go a layer deeper.

Prompt 6: The Source Validator

Use this before you publish anything where facts matter.

Here are 5 claims I'm about to publish in a newsletter: [paste your claims here]

For each claim:
1. Tell me if it's verifiably accurate, likely accurate, or uncertain
2. Flag anything that sounds like it could be AI hallucination
3. Suggest where I should verify it before publishing (specific source type)

Don't just say "verify this." Tell me exactly what I should look for and where.

I learned to use this one the hard way.

Six months ago, I published a stat in the newsletter.

One reader replied within 20 minutes.

“Hamza - that number is wrong. I checked.”

He was right.

I hadn’t verified it.

I’d trusted a Claude output and sent it to 4,000 people.

I never made that mistake again.

This prompt runs on every issue now, before anything goes out.

Category 3: Communication Prompts

Prompt 7: The Cold Outreach Writer

Use this when you need to reach someone you’ve never spoken to — client, collaborator, or press.

I want to reach out cold to [Sarah Chen, Head of Content at a B2B SaaS company called Loom].

My goal: [Pitch a 3-month AI content strategy project worth $4,500]

My credibility: [I've grown 3 B2B newsletters to 5,000+ subscribers in under 6 months using AI workflows]

Write a cold outreach message that:
- Opens with something specific about them or their company (not a generic compliment)
- States the offer in one sentence — no buildup
- Shows one proof point that's relevant to their situation
- Ends with a single low-friction ask (a 20-minute call, not a commitment)

Under 100 words. No subject line filler like "Quick question" or "Touching base."

No subject line filler like Quick question - naming the bad examples is what stops Claude from defaulting to them. Constraints only work when they're specific.

Prompt 8: The Proposal Builder

Use this when you need to pitch a client or send a project proposal.

I need to write a proposal for this project: [Building a 3-month AI content strategy for a B2B SaaS company. Budget: $4,500. Timeline: 6 weeks].

My strengths to highlight: [I've done this for 4 similar companies, each grew newsletter subscribers by 40%+ in 90 days]

Write a proposal that:
- Opens with their problem, not my services
- Shows the outcome, not just the process
- Has 3 clear deliverables with timelines
- Ends with a single call-to-action to book a 20-minute call

Under 300 words. Professional but human. No corporate jargon.

Opening with their problem, not my services - this is the instruction most freelancers never give. Claude defaults to pitching. This forces it to listen first.

Prompt 9: The Feedback Translator

Use this when you get vague client feedback that you actually need to act on.

A client gave me this feedback on my work: [paste feedback here]

Translate this into:
1. What they actually want changed (be specific)
2. What they probably mean but haven't said directly
3. The 3 most important changes I should make first
4. Any feedback that contradicts something they asked for originally

Don't soften anything. I need the honest read.

Don’t soften anything is critical. Claude has a natural tendency to be diplomatic. This removes that filter, so you get the real interpretation.

Category 4: Planning Prompts

Prompt 10: The Weekly Plan Builder

Use this every Monday morning instead of spending an hour building your week from scratch.

Here's my situation this week:
- Projects in progress: [AI In Public newsletter, 2 client proposals, onboarding call Thursday]
- Deadlines: [Newsletter due Wednesday, proposals due Friday]
- Available hours: [Mon–Wed: 4 hrs/day, Thu–Fri: 2 hrs/day]
- Energy pattern: [I think best in the mornings — afternoons are for admin]

Build me a daily plan for this week that:
- Protects my best hours for deep work
- Batches similar tasks together
- Has buffer time built in (I always underestimate things)
- Flags any conflicts or overloads

Format it as a simple day-by-day breakdown. No productivity lecture. Just the plan.

No productivity lecture. Just the plan - I added this after Claude gave me a motivational speech about my schedule. I don’t need the pep talk. I need the output.

Prompt 11: The Decision Filter

Use this when you’re stuck between two options and going in circles.

I'm deciding between: [Launching a paid Notion template store vs. growing my newsletter to 10,000 subscribers first]

Here's my situation: [I have 4,200 subscribers, 3 months of runway, and about 8 hours a week to invest in a side project]

Walk me through:
1. The actual risk of each option (not the perceived risk)
2. What each option makes harder in 6 months
3. What success looks like for each — and how long it realistically takes
4. Your honest recommendation — pick one and defend it

Don't hedge. I want a clear answer I can push back on.

Don’t hedge. I want a clear answer I can push back on - this is the line that changed how I use Claude for decisions. A hedged answer helps no one.

Prompt 12: The Content Calendar Builder

Use this to fill a month of content in 15 minutes instead of 3 hours.

I run an AI newsletter called AI In Public for founders, creators, and beginners who want to use AI without the overwhelm.

Build me a 4-week content calendar for June with:
- 1 newsletter issue per week (include title + 2-line description)
- 3 Substack Notes per week (short-form, shareable)
- 2 LinkedIn posts per week (one practical, one opinion)

Themes to hit this month: [Claude's memory feature, how to use AI for client work, AI tools that save time]

Make every piece feel like a standalone discovery — not a series. Format it as a clean weekly table.

Make every piece feel like a standalone discovery - without this, Claude writes a curriculum. Readers don’t want a curriculum. They want to feel like they found something.

The first 12 prompts save you hours on tasks you’re already doing.

These last 3 are different.

They’re not for tasks.

They’re for the stuff that keeps coming back - the recurring work that never actually gets done because you handle it from scratch every single time.

If you’ve ever thought, “I feel like I just did this last week,” - that’s what these are for.

Category 5: Systems Prompts

Prompt 13: The SOP Writer

Use this to turn any repeatable task into a process someone else (or Claude) can run.

I do this task regularly: [Writing and scheduling a Substack newsletter from draft to published]

Watch how I describe my process: [I start with a topic, outline 5 steps, write a draft in Claude, run it through my editorial checklist, add screenshots, format in Substack, schedule for 7am Tuesday]

Turn this into a clean SOP (Standard Operating Procedure) with:
- Step-by-step instructions written for someone doing this for the first time
- Decision points clearly marked (what to do if X, what to do if Y)
- Time estimate per step
- Common mistakes to avoid

Format as a numbered list. Keep it short enough to actually be used.

This prompt saved me 6 hours last month alone - I handed this SOP to a VA, and they ran the whole workflow. That’s what an SOP actually does.

Prompt 14: The Recurring Brief

Use this to build a reusable prompt you can drop into Claude Projects as a standing instruction.

I want to create a standing brief for Claude that captures how I work, so I don't have to re-explain myself every session.

Ask me these questions one at a time and use my answers to write a final brief I can paste into Claude Projects:
1. What's your main work or project right now?
2. Who is your audience and what do they care about?
3. What tone and style should I always use with you?
4. What are 3 things I should never do in your outputs?
5. What does a perfect response from me look like to you?

After I answer all 5, write the final brief in second person, ready to paste.

I run this prompt with every new major project. It takes 5 minutes and saves hours of drift across a long conversation.

Prompt 15: The Async Update Builder

Use this to replace the 30-minute team update call that could have been a message.

I need to send a project update to [my client / my team] about [the AI content strategy project].

Here's where things stand: [Week 2 of 6 complete. Newsletter audit done. Content pillars drafted. Waiting on brand voice document from client. On track for Friday delivery.]

Write an async update that:
- Leads with status (on track / at risk / blocked)
- Has clear progress bullets (what's done)
- Has a clear next steps section (what happens next and when)
- Flags anything they need to do
- Is under 150 words

Professional but not robotic. They're a client, not a boss.

Professional but not robotic is a style instruction, not a vibe. It changes the sentence structure, not just the tone. That’s what makes the output actually usable.

This newsletter grows from your shares. If you got value from this, pass it on.

Share

In 60 seconds:

→ Writing prompts: first draft, rewrite, and headlines - on demand

→ Research prompts: kill the 10-tab spiral before it starts

→ Communication prompts: emails and proposals that sound like you, not like AI

→ Planning prompts: weekly plan, decisions, and content calendar in minutes

→ Systems prompts: SOPs, standing briefs, and async updates that run without you

Save this. Screenshot it. Come back to it.

Here are a few issues that you might have missed (go check them out):

• How to master Claude Inside Excel

• How to use Claude’s whole week without hitting limits

• How to Build Claude Skills

• How to Create Videos Using Claude

• How to Use Claude as a Financial Analyst

• Claude Just Became a Video Studio

• Stop using 7 apps to do just 1 thing

• How to build an app with Claude Artifacts

• Claude for Chrome

• Stop building Claude Skills like this

• I set up my second brain in under an hour

• How to use Claude Design like an Anthropic Engineer

• Your AI Memory Is Broken if you are missing this one hack

• Clone Any Faceless YouTube Channel with Claude (Step-by-Step)

• How to fix your Obsidian graveyard with Claude under 20 mins

• Which AI model should you use in 2026

• I gave Claude Fable 5 a Month-Long Project - Here is what happened

• 15 Insane Things People Built With Claude Mythos in 48 Hours

• Stop Prompting Claude. Build Loops Instead

• US Just Disabled Mythos and Fable 5. Here’s What’s Gonna Happen Next

• 7 advanced Claude Loops that run your work autonomously

• 20 Resources to master Claude in 7 Days

• Vibe Coding: The Complete Claude’s Beginner Guide 2026

We tested it in public. Now go use it in private.

If this issue gave you something real, a framework, a starting point, a moment where something clicked, share it.

Share

Not for me. For the person in your life who’s been using Claude for six months and still asking, “How do I get better at this?

And for shorter takes between issues, follow me on X → Hamza Khalid

PS: Which of these 15 prompts are you going to test first - and what task are you trying to kill?

Hit reply. I read every response.

- Hamza 💙

Not a concept.

Not a mockup.

A working app, live on the internet, with a link you can share.

I did it this week.

I built an AI Tool Comparison Card Generator - you input two AI tools, Claude compares them, and it spits out a clean shareable card.

The kind of thing creators post on X and LinkedIn every day.

I used a method called vibe coding.

I’ll build an simple app and show you every prompt I used, in order, copy-paste ready.

If this is useful, share it with one person who needs it. Takes 10 seconds.

Share

Two weeks ago, I was manually writing AI tool comparisons for LinkedIn posts.

Claude Sonnet vs ChatGPT-4o.

Gemini vs Perplexity.

I’d spend 20-30 minutes formatting each one - making it look clean enough to screenshot and post.

Then I thought: what if I just built the tool instead?

I opened Claude.

I described what I wanted in plain English.

I had a working version in 52 minutes.

I documented every single prompt along the way.

This issue is with the documentation.

I’ll be honest with you about something.

Six months ago, I had a list of 14 app ideas sitting in a Notion doc.

Every single one of them was still just an idea.

Not because I lacked motivation.

Because every time I tried to build one, I’d spend 3 hours watching tutorials, get lost in installation errors, and close my laptop feeling worse than when I started.

I wasn’t a developer. I didn’t want to become one.

I just wanted my ideas to exist in the world.

Then I found vibe coding. I built my first working app in 47 minutes.

I’ve built 9 more since.

This issue is everything I wished I had when I started.

What Is Vibe Coding?

AI researcher Andrej Karpathy coined the term in early 2025.

His framing: “fully giving in to the vibes, embracing exponentials, and forgetting that the code even exists.”

The practical version: you describe what you want to build.

Claude writes the code.

You test it, describe what broke, and Claude fixes it.

You never need to read a line of code unless you’re curious.

This is not a developer shortcut.

It’s a different path - built for people with ideas and zero interest in spending 6 months learning syntax.

The old way of building a tool:

→ Have an idea

→ Learn to code

→ Get stuck

→ Watch YouTube tutorials

→ Abandon it.

The vibe coding way:

→ Have an idea

→ Describe it to Claude

→ Test it

→ Describe what broke

→ Ship it.

If this is useful, share it with one person who has an app idea they’ve been sitting on. Takes 10 seconds.

Share

Here's the shift that changes everything.

Most people believe there are two kinds of people in tech: those who can build things, and those who can't.

Vibe coding breaks that.

There's a third kind now.

People who can describe things precisely enough that the right tool builds them.

That's it.

That's all you need to be

The Live Build: AI Tool Comparison Card Generator

Here’s what I wanted to build:

A simple interactive app.

You type in two AI tools - say, Claude and ChatGPT.

You hit a button.

Claude compares them across 5 categories and displays a clean visual card.

You screenshot it and post it.

No API key.

No installs.

No browser tab.

The whole thing lives inside Claude’s artifact panel - free tier included.

Here are the exact prompts I used, in the exact order I used them.

Step 1: Set the Context Before You Write a Single Spec

The first thing most beginners do wrong: they jump straight into describing the app.

Claude builds something overengineered, and half the time it doesn’t even run.

One setup message prevents all of that.

Quick setup:

1. Open claude.ai

2. Start a fresh conversation

3. Paste this prompt first - before describing anything:

I want to build an interactive app inside Claude as an artifact.
Build it as a self-contained React component.
The app should work entirely inside the artifact panel — 
no API keys, no installs, no external calls needed.

I'll describe what I want in plain English. You build it.
When something looks wrong, I'll tell you what I saw and you fix it.
Always return the complete updated component — not just the changed part.

Ready? I'll describe the app now.

No API keys, no installs, no external calls - this is the constraint that makes it free.

Claude becomes both the builder and the brain.

You get a working app with zero setup.

If this is useful, share it with one person who needs it. Takes 10 seconds.

Share

Read more

You save threads.

You bookmark guides.

You screenshot prompts at 11 pm.

And then you close the tab and go back to using Claude the same way you did before.

That’s not learning. That’s collecting.

There is a difference - a massive one.

Information without application is just a very organized form of ignorance.

This issue is not a resource dump. It is a structured path.

I wasted a lot of time collecting before I started learning.

This issue is the map I wish I had on day one.

Send this to one person right now.

Share

Before we go into the courses, here’s what Claude can actually do.

Most people use 3 of these. Maybe 5.

I condensed all of Claude's capabilities into a single visual so you can see the full picture before you start learning it.

25 ways to use Claude

This is what you’re learning. Not a chatbot. A complete operating system.

PART 1 - THE OFFICIAL COURSES

Anthropic published 10 free courses.

They’re sitting on their learning hub right now.

Most Claude users have never opened a single one.

Here is every course you need:

1. Claude 101

The actual starting point.

Most people skip this because they think they already know Claude.

They don’t.

This course teaches you how Claude processes instructions, why it responds the way it does, and how to structure your requests so it actually understands you.

🔗 https://anthropic.skilljar.com/claude-101

If you want pre-built Skills that install in one command, Claude Kit has 19 of them, already token-measured and ready to go → https://theclaudekit.com/

2. AI Fluency

This one isn’t about Claude specifically; it’s about how to think about AI. You’ll learn the mental models that separate people who get results from people who get frustrated.

🔗 https://anthropic.skilljar.com/ai-fluency-framework-foundations

3. Introduction to MCP

Model Context Protocol is how Claude connects to external tools, files, calendars, and apps.

This course explains what MCP is, how it works, and why learning it now puts you ahead of 99% of users.

🔗 https://anthropic.skilljar.com/introduction-to-model-context-protocol

4. Intro to Agent Skills

Skills are reusable instruction sets you build once, and Claude carries them into every session automatically.

This course shows you how to build your first Skill and how to structure it so Claude uses it correctly every time.

🔗 https://anthropic.skilljar.com/introduction-to-agent-skills

5. MCP: Advanced Topics

Once you’ve done Course 3, come back here.

This is where it gets serious: connecting multiple tools at once, building agent workflows that chain actions together, and setting up systems that run without you in the loop.

🔗 https://anthropic.skilljar.com/model-context-protocol-advanced-topics

6. AI Fluency for Students

Built specifically for academic workflows.

You’ll learn how to use Claude for research, writing, note-taking, and building learning systems that actually stick.

If you’re a student or you know one who’s still doing everything manually, this is the one to send them.

🔗 https://anthropic.skilljar.com/ai-fluency-for-students

7. AI Fluency for Educators

Designed for teachers who want to use AI in the classroom without losing control of the learning process.

Covers how to design AI-assisted lessons, how to think about student use of AI, and how to build workflows that save you hours of prep time every week.

🔗 https://anthropic.skilljar.com/ai-fluency-for-educators

8. Building with the Claude API

This is where you move beyond the chat interface and start building real tools.

Claude becomes the engine inside your own apps, automations, and workflows. But you will write your first API call by the end of this course, and that changes what’s possible.

🔗 https://anthropic.skilljar.com/claude-with-the-anthropic-api

9. Claude with Amazon Bedrock

For teams already inside the AWS ecosystem.

This course covers how to deploy Claude through Amazon Bedrock, the access layer, the setup, and the key differences from using Claude directly.

🔗 https://anthropic.skilljar.com/claude-in-amazon-bedrock

10. Claude with Google Vertex AI

Same concept as Course 9, but for Google Cloud.

If your infrastructure lives in GCP, this is your version. Covers deployment, configuration, and the specific considerations for running Claude inside Vertex AI at scale.

🔗 https://anthropic.skilljar.com/claude-with-google-vertex

The model you’re about to learn just got a major upgrade.

Before you start the courses, know what you’re working with.

I condensed the entire Claude Opus 4.8 release, benchmarks, new features, effort control, dynamic workflows, and top use cases into one cheatsheet.

Now you know what the tool can do. Let’s learn how to use it.

If this is useful, share it with one person who needs it. Takes 10 seconds.

Share

PART 2 - THE HANDS-ON GUIDES

The official courses tell you what Claude can do.

These guides show you what to actually build with it.

LAYER 1 - EVERYDAY USE

Start here. These change how you use Claude daily.

Claude Skills 101

Most people re-explain themselves to Claude every single session.

Skills fix that. You build an instruction set once, your role, your context, your preferences, and Claude carries it automatically from that point forward.

This guide walks you through building your first one from scratch.

Build Your Prompt Library

Every time you find a prompt that works, you use it once and lose it forever.

That’s the problem this guide solves.

It shows you how to build a personal prompt library inside Claude, organized by use case, searchable, and self-improving the longer you use it.

If you want content that sounds like you wrote it, MarketingKit has a voice engine, a humanizer, and 20 commands for the daily content.
→ https://theclaudekit.com/marketing

Stop Hitting Claude’s Limits

Usage limits are the most frustrating part of Claude for daily users.

This guide covers the three specific changes I made that stopped it from happening.

If this is useful, share it with one person who needs it. Takes 10 seconds.

Share

Claude Connectors

Every time you copy an output from Claude and paste it into another app, you’re wasting time on a step that shouldn’t exist.

I went from 7 open tabs to one workflow in a single afternoon.

This guide shows you the exact setup.

Claude for Chrome

This is Claude living inside your browser, not in a separate tab, right there on the page you’re reading. Summarize articles, research topics, write replies, and draft content.

This guide covers the setup that actually sticks and the three use cases where it saves the most time.

Most people don’t fail at Claude because they lack information.

They fail because they’re prompting it wrong from the start.

Before you go deeper into the guides, here’s the single most important mindset shift.

I condensed the most common Claude prompting mistakes and the exact fixes into one cheatsheet.

If this is useful, share it with one person who needs it. Takes 10 seconds.

Share

LAYER 2 - THE BUILDER LAYER

Ready to move beyond prompts. This is where it gets real.

Claude Loops

A Loop is a sequence of Claude actions that chain together and run in order, one output feeding the next.

This guide breaks down 7 advanced loops I use in my own workflow, with the exact structure so you can copy and adapt them.

Stop Prompting - Build Loops Instead

Single prompts are for getting an answer. Loops are for building a system.

This guide shows the exact difference between a prompt and a loop, with real before/after examples.

If you want slash commands that run entire workflows in one line, that’s exactly what Claude Kit is built for. → https://theclaudekit.com

Claude Artifacts

Artifacts are how Claude builds live, functional tools directly inside the chat window.

Calculators. Dashboards. Content trackers. Data visualizers.

This guide shows you the prompting pattern that makes it work and the use cases where Artifacts beat everything else.

Claude Design 101

Claude can generate UI designs, wireframes, and functional interface layouts.

This guide covers how Anthropic’s own engineers use Claude for design work, the prompting approach that gets professional output.

Ship better software with Claude Code. EngineerKit is 25 commands built for exactly that.

→ https://theclaudekit.com/engineer

If this is useful, share it with one person who needs it. Takes 10 seconds.

Share

Claude in Excel

Claude has a native Excel integration that most users have never heard of.

This guide walks through the setup, the things it does that ChatGPT can’t do inside a spreadsheet, and the exact workflows where it saves the most time.

MarketingKit has a voice engine, a humanizer, and 20 commands for the daily content grind. → https://theclaudekit.com/marketing

When you’re ready to move faster - use these.

I built 70 copy-paste Claude prompt shortcuts across 7 categories. Every shortcut is one line. Everyone works immediately. No setup. No re-prompting.

Save this. You’ll come back to it every week.

Stop here for a second.

You’ve just read more structured Claude education than most people find in six months of searching.

You have two options right now.

Option 1:

Keep reading, finish the issue, save it, and let it sit in your inbox next to 47 other things you were going to act on.

Option 2:

Open one link from Layer 1 before you keep going. Anyone.

Takes 3 minutes.

Then come back and finish.

The people who choose Option 2 are the ones who message me three weeks later, saying everything changed.

Every single time.

LAYER 3 - THE SYSTEMS LAYER

This is where Claude stops being a tool you use and starts being a system that runs for you.

Claude’s Second Brain

This guide builds a full personal knowledge system inside Claude, notes, research, and context, all connected and retrievable on demand.

Fix Your Obsidian with Claude

If your Obsidian vault is a graveyard of half-finished notes you never look at, this guide fixes it.

Claude goes through the vault, surfaces what’s actually useful, connects what should be linked, and turns a broken system into a working one.