Introduction

You’ve been using Claude. You’ve been watching people build entire businesses with Skills and orchestration layers and multi-agent pipelines, and you’re sitting there thinking... what am I missing?

I’ve combined every resource worth reading into a single course on Claude Skills. Not theory. Not “here’s what a Skill could do.” Actual, build-it-right-now, deploy-it-today instruction. In less than 10 minutes you’ll have your first custom Skill running. After you finish this, you will understand Skills better than 99% of the people talking about them online.

Yes, really.

Here’s how this is structured:

• Module 1: Foundations - what Skills actually are and how to build your first one

• Module 2: Architecture - scripts, orchestration, and what to do when you have more than three Skills fighting each other

• Module 3: Testing and Iteration - how to stop guessing and start proving your Skills work

• Module 4: Production Deployment - making Skills survive across sessions, at scale, over time

In every module I’m going to give you the foundations AND the prompts to get AI to do the heavy lifting for you. Because here’s the thing - you need to understand what’s happening, but you don’t need to suffer through building it manually if you don’t want to.

Let’s go.

Module 1: Foundations

Skills vs Projects vs MCP - Know What You’re Actually Building

Before you build anything, you need to understand where Skills sit inside Claude’s ecosystem. Three tools. Three completely different jobs. Most people conflate them. Don’t be most people.

Projects are your knowledge base. You upload a brand guideline PDF and you’re telling Claude: “Here’s what you need to know.” That’s it. It’s static. It’s reference material. It’s a library. The librarian doesn’t DO anything with the books - it just knows where they are.

Skills are your instruction manual. You’re telling Claude: “Here’s exactly how you perform this task, step by step.” This is procedural. This is automated. This isn’t a librarian - this is a trained employee who knows exactly how to process an invoice the way YOU want it processed, every single time.

MCP (Model Context Protocol) is your connection layer. This plugs Claude into live data sources - your calendar, your database, your inbox. Skills then tell Claude what to DO with that data. MCP is the plumbing. Skills are the instructions for what flows through the pipes.

So, how do you know if you need a Skill?

Simple. If you’ve typed the same instructions at the start of more than three conversations, that’s a Skill begging to be built. If you want Claude to stop being a generic chatbot and start being a professional operator in a specific domain, Skills are how you turn it into an employee.

The Anatomy Of A Skill

Here’s where every other guide on the internet decides to overcomplicate things and scare you off. Let me strip it down to what it actually is.

A Skill is a folder on your computer. Inside that folder is a text file. That’s it.

A folder with a text file called SKILL.md.

I know. Anticlimactic. But that’s the truth, and the truth is your friend here because it means you can build one in minutes, not days.

The folder follows three rules:

The Root Folder must use kebab-case naming. That means lowercase, words separated by hyphens. invoice-organiser. email-formatter. csv-cleaner. No spaces. No underscores. No capitals. If you’re the kind of person who names folders “My Cool Skill v2 FINAL (2)” - break that habit right now.

SKILL.md is the brain. This is case-sensitive. Not skill.md. Not README.md. Exactly SKILL.md. All your instructions live here.

references/ is optional. If your instructions need a massive brand guide or a long template, drop it in this subfolder instead of pasting it into SKILL.md. Think of it as the filing cabinet next to the employee’s desk.

Drop the whole folder into ~/.claude/skills/ on your machine.

Claude finds it automatically.

That’s the entire physical architecture. A folder, a markdown file, and optionally a subfolder for reference docs. I told you this was simple.

Where Do They Run?

This matters more than most guides tell you, and most guides don’t tell you at all.

Claude Code is the command-line tool for developers. Skills here live in your project directory under .claude/skills/ or globally at ~/.claude/skills/. They have access to the file system, bash commands, and can execute code. This is where you build Skills that manipulate files, run scripts, and interact with your codebase. If you’re a developer, this is your playground.

Claude Desktop (CoWork) is the desktop agent for non-developers. Skills here work through the desktop interface and can interact with your screen, applications, and files through the agent’s capabilities. Same SKILL.md format. Different execution environment.

The format is identical. The environment is different. Know which one you’re building for.

If you’re ever unsure whether you even NEED a Skill, or you just want Claude to help you figure it out, here’s a prompt that does the thinking for you:

I want you to help me identify whether I need a Claude Skill.

Here's how this works:

1. Ask me to describe the 3-5 tasks I repeat most often when
   using AI assistants. For each one, ask me:
   - What instructions do I typically give at the start?
   - How often do I repeat this task per week?
   - Does the output need to follow a specific format, tone,
     or structure every time?

2. After I describe each task, score it on a "Skill Readiness"
   scale of 1-10 based on:
   - Repetition frequency (higher = more ready)
   - Instruction complexity (more specific instructions =
     more ready)
   - Output consistency requirements (stricter format needs =
     more ready)

3. Rank my tasks from highest to lowest Skill Readiness score.

4. For my top-scoring task, tell me:
   - Why this is the best candidate for my first Skill
   - What the Skill would need to contain
   - An estimate of time saved per week if I automate it
   - Whether this is better suited for Claude Code or
     Claude Desktop (CoWork)

Start by asking me about my first repeated task.

Building Your First Skill

Alright. Theory is over. Time to actually build something.

Step 1: Define the Job

Before you write a single word, answer three questions. And I mean actually answer them - not hand-wave your way through with vague intentions.

What does this Skill do? Be ruthlessly specific. “Help with data” is useless. You know what’s not useless? “Transform messy CSV files into clean spreadsheets with proper headers, enforce YYYY-MM-DD date formatting, and strip empty rows.” THAT is a Skill that works.

When should it fire? Think about what you’d actually type. “Clean up this CSV.” “Fix these headers.” “Format this data.” Those are your triggers. If you can’t list at least five phrases you might use to invoke this Skill, you haven’t thought about it hard enough.

What does “good” look like? You need a concrete example of the finished output. Not a description. An actual before-and-after. If you can’t show someone what “done” looks like, your Skill doesn’t know what “done” looks like either.

Listen closely. This step is where 90% of bad Skills are born. Vague instructions create vague outputs. Every. Single. Time. It’s not Claude’s fault your Skill produces garbage - it’s yours, because you told it to “handle things appropriately” instead of telling it EXACTLY what to do.

Don’t trust yourself to get specific enough? Good - that’s self-awareness. This prompt forces the precision out of you:

PROMPT: THE SKILL DEFINITION INTERVIEW

You are a Skill Definition Specialist. Your job is to interview 
me until we have a razor-sharp definition of the Claude Skill 
I want to build. You will not let me get away with vague answers.

Run this interview process:

PHASE 1 - THE TASK
Ask me: "What task do you want to automate?" 
After I answer, pressure-test my response:
- If my answer is vague (e.g., "help with emails"), push back 
  and ask me to describe EXACTLY what the Skill should do, 
  with a specific input and specific output.
- Keep asking "Can you be more specific?" until the task 
  description is concrete and actionable.
- Confirm the final task definition back to me in one sentence.

PHASE 2 - THE TRIGGERS
Ask me: "What would you actually type into Claude to activate 
this Skill? Give me 5 different ways you might phrase the request."
After I answer:
- Suggest 3-5 additional trigger phrases I probably missed.
- Ask me about negative boundaries: "What similar-sounding 
  requests should NOT trigger this Skill?"

PHASE 3 - THE QUALITY STANDARD
Ask me: "Show me or describe exactly what a PERFECT output 
looks like for this task."
After I answer:
- Ask me to describe what a FAILED output looks like 
  (so we know what to avoid).
- Ask me about edge cases: "What's the weirdest or most 
  broken input this Skill might receive? How should it handle it?"

PHASE 4 - THE SUMMARY
Compile everything into a structured "Skill Definition Brief" 
with these sections:
- Skill Name (in kebab-case)
- One-Sentence Purpose
- Trigger Phrases (positive)
- Negative Boundaries (when NOT to fire)
- Input Description
- Output Description
- Quality Standard (what "good" looks like)
- Edge Cases to Handle

Present this brief and ask me to confirm or revise before 
we proceed.

Start Phase 1 now.

Step 2: Write the YAML Triggers

At the top of your SKILL.md file, you write a block of metadata between --- lines. This is called YAML frontmatter. It tells Claude when to activate your Skill.

Here’s an example:

---
name: csv-cleaner
description: Transforms messy CSV files into clean spreadsheets. Use this skill whenever the user says 'clean up this CSV', 'fix the headers', 'format this data', or 'organise this spreadsheet'. Do NOT use for PDFs, Word documents, or image files.
---

Three rules that make or break your triggers:

Write in third person. “Processes files...” not “I can help you...” Claude isn’t talking about itself here. It’s reading a job description.

List exact trigger phrases. Claude is conservative about activation. CONSERVATIVE. You need to spell out what the user might say. Be pushy. Be embarrassingly explicit. If you’re not slightly cringing at how over-the-top your trigger phrases are, you haven’t written enough of them.

Set negative boundaries. Tell Claude when NOT to fire. This prevents your Skill from hijacking unrelated conversations. Without negative boundaries, your CSV cleaner will try to activate every time someone mentions a spreadsheet, even if they just want to talk about Excel formulas.

Here’s the thing most people miss. The description field is the single most important line in your entire Skill. Not the instructions. Not the examples. The description. If it’s weak, your Skill never fires. If it’s too broad, it fires when you don’t want it to. Everything downstream depends on getting this right.

PROMPT: THE YAML TRIGGER GENERATOR

You are a YAML Frontmatter Specialist for Claude Skills. 
Your job is to write the most effective possible YAML trigger 
block for the top of a SKILL.md file.

Here is my Skill definition:
[PASTE YOUR SKILL DEFINITION BRIEF HERE, OR DESCRIBE YOUR 
SKILL IN 2-3 SENTENCES]

Generate the YAML frontmatter following these strict rules:

1. The "name" field must be in kebab-case (lowercase, 
   hyphens only, no spaces or underscores).

2. The "description" field must be "pushy" - meaning it 
   should aggressively list trigger scenarios because Claude 
   is conservative about skill activation. Include:
   - A clear one-sentence summary of what the skill does 
     (written in third person: "Processes..." not "I can...")
   - At least 5-7 explicit trigger phrases the user might say, 
     formatted as: "Use this skill whenever the user says 
     '[phrase 1]', '[phrase 2]', '[phrase 3]'..."
   - Negative boundaries: "Do NOT use this skill for [X], 
     [Y], or [Z]."
   - Context clues: "Also activate when the user uploads 
     [file type] and asks for [action]."

3. Keep the entire description under 300 words but make 
   every word count.

Output ONLY the YAML block (between --- markers), ready to 
paste directly into a SKILL.md file. No explanation needed.

Then, below the YAML block, provide a "Trigger Confidence 
Report" that rates:
- Activation likelihood on relevant requests: X/10
- False positive risk (firing when it shouldn't): X/10
- Coverage of common phrasings: X/10

If any score is below 7/10, suggest specific improvements.

Step 3: Write the Instructions

Below the --- marks, you write your workflow in plain English. Structured with headings. Sequential. Under 500 lines.

This is where a lot of people go wrong in the opposite direction from Step 1. They were too vague in the definition, and now they’re writing a novel in the instructions. You don’t need War and Peace. You need a recipe that a very smart, very literal employee can follow without asking you questions.

Two components make this work:

The Steps. Break the workflow into a logical sequence. Each step is one action. Not two actions smooshed together. Not a paragraph of explanation. One clear, imperative command.

1. Read the provided file to understand its structure
2. Identify the row containing the true column headers
3. Remove any empty rows or rows containing only commas
4. Enforce proper data types (dates must be YYYY-MM-DD)
5. Output the cleaned file with a summary of changes made

The Examples. This is where the magic actually lives. A single concrete example showing input and expected output is worth more than 50 lines of abstract description. I cannot stress this enough. Claude learns from examples the way humans learn from watching someone do the thing. Show it the thing.

PROMPT: THE SKILL INSTRUCTION ARCHITECT

You are a Claude Skill instruction writer. Your job is to 
generate the complete instruction body for a SKILL.md file 
that is clear, sequential, and under 500 lines.

Here is my Skill definition:
[PASTE YOUR SKILL DEFINITION BRIEF FROM STEP 1]

Here is the YAML frontmatter already written:
[PASTE YOUR YAML BLOCK FROM STEP 2]

Now generate the full instruction body that goes BELOW the 
closing --- of the YAML block. Follow these rules precisely:

STRUCTURE RULES:
1. Start with a one-paragraph "Overview" that states what 
   this skill does and when it activates, written for Claude 
   (not for a human reader).
2. Break the workflow into numbered steps under a 
   "## Workflow" heading. Each step must be:
   - One clear action
   - Written as an imperative command ("Read the file..." 
     not "The file should be read...")
   - Specific enough that there is only ONE way to 
     interpret it
3. Include a "## Output Format" section that specifies 
   exactly how the final output should be structured 
   (file type, formatting, sections, tone, etc.)
4. Include a "## Edge Cases" section that tells Claude 
   how to handle:
   - Missing or incomplete input
   - Ambiguous requests
   - Conflicting instructions
   - Unexpected file formats or data types

EXAMPLE RULES:
5. Include at least 2 concrete examples under a 
   "## Examples" heading:
   - Example 1: A straightforward "happy path" showing 
     normal input → expected output
   - Example 2: An edge case showing unusual input → 
     how Claude should handle it
   Each example must show ACTUAL input and ACTUAL expected 
   output, not abstract descriptions.

QUALITY RULES:
6. Total length: aim for 100-300 lines. Cut anything 
   that doesn't directly instruct Claude on how to 
   execute the task.
7. Never use vague language like "handle appropriately" 
   or "format nicely." Every instruction must be specific 
   and testable.
8. If the skill requires referencing external files 
   (brand guides, templates), add a "## References" 
   section with the instruction: "Read [filename] from 
   the references/ directory before beginning the task."

Output the complete instruction body as markdown, ready to 
paste directly below the YAML frontmatter in a SKILL.md file.

After the instructions, provide a "Quality Checklist" that 
confirms:
- [ ] Every step is a single, unambiguous action
- [ ] At least 2 concrete examples included
- [ ] Edge cases are covered
- [ ] Output format is explicitly defined
- [ ] Total length is under 500 lines
- [ ] No vague or interpretable language remains

Step 4: The One Level Deep Rule (References)

If your instructions reference a massive brand guideline or template, don’t paste the whole thing into SKILL.md. That’s context bloat, and context bloat is the silent killer of Skill performance.

Save it as a separate file inside the references/ folder. Then link to it directly from your instructions.

But here’s the critical constraint that most people learn the hard way: never have reference files linking to other reference files. Claude will truncate its reading and miss information. One level deep. That’s it. No rabbit holes. No “see also” chains. Your reference file is a dead end by design.

Think of it like giving an employee a binder. They can open the binder and read it. But if page 7 of the binder says “now go read the other binder on the third shelf,” you’ve lost them. One binder. One level. Done.

PROMPT: THE REFERENCE FILE ORGANISER

You are a Skill Reference File Organiser. I have documents 
that my Claude Skill needs to reference during execution. 
Your job is to prepare them for the references/ directory.

Here are my reference documents:
[PASTE OR UPLOAD YOUR BRAND GUIDE / TEMPLATE / SOP / 
STYLE SHEET / ANY REFERENCE MATERIAL]

For each document, do the following:

1. ASSESS: Is this document short enough to include 
   directly in the SKILL.md file (under 50 lines of 
   relevant content)? If yes, recommend inlining it 
   instead of creating a separate reference file.

2. COMPRESS: If it needs to be a separate reference file, 
   extract ONLY the sections that are directly relevant 
   to the Skill's task. Remove all preamble, background 
   context, and information the Skill will never need. 
   Aim to reduce the document by 50%+ while keeping all 
   actionable instructions.

3. FORMAT: Structure the compressed reference file with:
   - Clear markdown headings
   - Bullet points for rules and constraints
   - Bold text for critical requirements
   - A "Quick Reference" summary at the top (under 10 lines) 
     that captures the most important rules

4. NAME: Suggest a kebab-case filename for each reference 
   file (e.g., brand-voice-guide.md, email-template.md).

5. LINK: Write the exact line I should add to my SKILL.md 
   file to reference this document, e.g.:
   "Before beginning the task, read the brand voice guide 
   at references/brand-voice-guide.md"

6. VALIDATE: Check for the "One Level Deep" rule. Flag 
   any reference file that links to or depends on 
   ANOTHER reference file. If found, merge them into a 
   single file.

Output each prepared reference file in full, ready to save 
directly into the references/ directory.

Step 5: Assemble and Deploy

You’ve got every component. Time to put it together.

Your folder structure should look like this:

your-skill-name/
├── SKILL.md          (YAML header + instructions from Steps 2-3)
└── references/       (optional, from Step 4)
    └── your-ref.md

Drop the folder into ~/.claude/skills/ on your machine.

Done.

But wait. Before you declare victory, you want to make sure the whole thing is airtight. You wouldn’t ship code without running tests, and you shouldn’t deploy a Skill without an audit. This prompt does a final QA pass on your complete SKILL.md file:

PROMPT: THE SKILL QA AUDITOR

You are a Claude Skill Quality Assurance Auditor. I have 
built a complete SKILL.md file and I need you to audit it 
before I deploy it.

Here is my complete SKILL.md file:
[PASTE YOUR ENTIRE SKILL.MD FILE HERE]

Run the following audit checks and report results:

## 1. YAML FRONTMATTER AUDIT
- [ ] name field exists and is valid kebab-case
- [ ] description field exists and is over 50 words
- [ ] description is written in third person
- [ ] At least 5 trigger phrases are listed
- [ ] Negative boundaries are defined (when NOT to activate)
- [ ] Description is "pushy" enough (would Claude actually 
      fire this skill on a relevant request?)
SCORE: X/10

## 2. INSTRUCTION CLARITY AUDIT
- [ ] Every step is a single, unambiguous action
- [ ] No vague language ("handle appropriately", 
      "format nicely", "as needed")
- [ ] Instructions are in imperative voice ("Read the 
      file" not "The file should be read")
- [ ] Sequential logic is correct (no step depends on 
      information from a later step)
- [ ] Total instruction length is under 500 lines
SCORE: X/10

## 3. EXAMPLE QUALITY AUDIT
- [ ] At least 2 examples are included
- [ ] Examples show ACTUAL input and ACTUAL output 
      (not abstract descriptions)
- [ ] At least one edge case example is included
- [ ] Examples are realistic (represent real-world usage)
SCORE: X/10

## 4. EDGE CASE COVERAGE AUDIT
- [ ] Missing/incomplete input is handled
- [ ] Ambiguous requests are handled
- [ ] Unexpected file types or data formats are handled
- [ ] The skill knows when to ask for clarification 
      vs. make a reasonable assumption
SCORE: X/10

## 5. REFERENCE FILE AUDIT (if applicable)
- [ ] All referenced files are at one level deep only
- [ ] No circular references
- [ ] Reference instructions in SKILL.md are clear 
      ("Read X before beginning")
SCORE: X/10

## OVERALL DEPLOYMENT READINESS: X/50

If any section scores below 7/10, provide SPECIFIC 
rewrites for the failing sections. Output the corrected 
text ready to paste directly into the file.

If overall score is 40+/50, confirm: "READY TO DEPLOY."
If below 40, list the critical fixes needed before 
deployment, in priority order.

The Shortcut: Let Claude Build Your Skill For You

If everything above feels like too much effort - or you just want to see how fast this can actually go - there’s a shortcut.

Anthropic built a meta-skill called skill-creator that constructs Skills for you through conversation. It’s Skills building Skills. We’re living in the future.

Here’s how it works:

1. Open a new chat. Type: “Use the skill-creator to help me build a skill for [your task].”

2. Upload your assets. Templates you use. Examples of past work. Brand guidelines. Anything that shows Claude what “good” looks like.

3. Answer the interview. The skill-creator asks you clarifying questions about your process, your edge cases, and your quality standards.

4. It generates everything. The formatted SKILL.md. The pushy description. The folder structure. Packaged and ready.

5. Save the folder to ~/.claude/skills/. Done.

Next time you ask Claude to perform that task, your Skill fires automatically.

Module 1 complete. You now have a deployed Skill. In Module 2, you’re going to learn what happens when “just instructions” isn’t enough, and how to architect Skills that actually scale.

Module 2: Architecture

You’ll eventually have more than a couple Skills. That’s when things get interesting - and when things start breaking if you don’t understand architecture.

I’m going to teach you the manual version of all of this AND give you prompts to automate it. But understanding the WHY matters here. A prompt can build the thing for you, but only you can decide whether the thing should exist in the first place.

When Instructions Aren’t Enough

Everything you’ve built so far uses plain English instructions. Claude reads them, follows them, produces output. That works beautifully for tasks that are about language, judgement, tone, decisions.

But some tasks need computation. They need code that runs. Calculations that execute. Data transformations that are too precise for “hey Claude, figure out the average.” Natural language is great for “rewrite this email in our brand voice.” It is terrible for “calculate a 90-day rolling weighted average with exponential decay.”

That’s what the scripts/ directory is for.

Use instructions when: The task is about judgement, language, formatting, or decision-making. “Rewrite this in our brand voice.” “Categorise these meeting notes.” “Draft an email.” Claude’s language brain handles these perfectly.

Use scripts when: The task requires precise computation, file manipulation, data transformation, or integration with external tools. “Calculate the running average of these numbers.” “Parse this XML file and extract specific fields.” “Resize all images in this folder to 800x600.” You wouldn’t ask your copywriter to do your accounting. Same principle.

Use both when: The task requires computation AND judgement. “Process this CSV (script), then write a human-readable summary of the anomalies found (instructions).” The script does the math. The instructions do the thinking. Together, they’re unstoppable.

How Scripts Work Inside a Skill

Your Skill’s instructions tell Claude WHEN and HOW to execute the scripts. The scripts themselves live in the scripts/ folder and do the actual computation.

Here’s a complete example:

data-analyser/
├── SKILL.md
├── references/
│   └── analysis-template.md
└── scripts/
    ├── parse-csv.py
    └── calculate-stats.py

In your SKILL.md, you reference the scripts like this:

## Workflow

1. Read the uploaded CSV file to understand its structure.

2. Run scripts/parse-csv.py to clean the data:
   - Command: `python scripts/parse-csv.py [input_file] [output_file]`
   - This removes empty rows, normalises headers, and
     enforces data types.

3. Run scripts/calculate-stats.py on the cleaned data:
   - Command: `python scripts/calculate-stats.py [cleaned_file]`
   - This outputs: mean, median, standard deviation, and
     outliers for each numeric column.

4. Read the statistical output and write a human-readable
   summary following the template in references/analysis-template.md.
   Highlight any anomalies or outliers that would concern
   a non-technical reader.

The key insight here - and it’s one of those things that seems obvious once you see it but isn’t obvious until you do: the scripts handle the computation, the instructions handle the judgement. They work together. Neither one is trying to do the other’s job.

Script Best Practices

Keep scripts focused. One script, one job. parse-csv.py doesn’t also calculate statistics. That’s a separate script. If you find yourself naming a script do-everything.py, you’ve gone wrong somewhere.

Make scripts accept arguments. Your script should take input/output file paths as command-line arguments, not hardcode them. This makes the Skill flexible instead of brittle.

Include error handling. Your script should exit with a clear error message if the input is malformed, missing, or the wrong format. Claude can then read the error and communicate it to the user instead of silently producing garbage.

Document the interface. At the top of each script, include a comment block explaining: what the script does, what arguments it expects, what it outputs, and what errors it might throw. Future you will thank present you.

PROMPT: THE SKILL SCRIPT BUILDER

I have a Claude Skill that needs executable scripts for
tasks that require computation rather than language processing.

Here is my current SKILL.md:
[PASTE YOUR SKILL.MD]

Here are the computational tasks that can't be handled by
instructions alone:
[DESCRIBE EACH TASK THAT NEEDS A SCRIPT, e.g.:
- "Parse XML files and extract specific fields"
- "Calculate statistical summaries of numeric data"
- "Resize and compress images in a folder"]

For each task, build a script that follows these rules:

1. Language: Use Python unless the task specifically requires
   another language. Python is available in both Claude Code
   and CoWork environments.

2. Interface: Accept all inputs as command-line arguments.
   No hardcoded file paths. Print output to stdout or write
   to a specified output file.

3. Error handling: Catch all common failure modes (missing
   files, malformed data, wrong types) and exit with a clear
   error message that Claude can parse.

4. Documentation: Include a comment block at the top with:
   - What the script does
   - Required arguments
   - Expected output format
   - Possible error conditions

5. Dependencies: Use only Python standard library where
   possible. If external packages are required, list them
   in a requirements.txt.

After generating the scripts:

6. Update the SKILL.md workflow to reference each script
   with the exact command syntax Claude should use.

7. Add error handling instructions to SKILL.md: what should
   Claude tell the user if a script fails?

Output:
- Each script file ready to save to scripts/
- Updated SKILL.md with script references
- requirements.txt (if external packages needed)

Multi-Skill Orchestration: When Your Skills Start Fighting Each Other

Here’s what happens after you build your fifth Skill. You start noticing conflicts. And they will drive you absolutely insane until you understand why they’re happening.

Your Brand Voice Enforcer fires when you wanted the Email Drafter. Your Code Review Assistant activates on a code snippet you just wanted formatted, not reviewed. Two Skills both think they should handle the same request and Claude picks the wrong one.

This is the multi-skill orchestration problem. And it gets worse - MUCH worse - the more Skills you build.

Here’s what’s happening under the hood. When you make a request, Claude scans all available Skills and evaluates their YAML descriptions against your prompt. It reads all the descriptions, scores each one for relevance against what you typed, and the highest-scoring Skill fires. If nothing scores above the activation threshold, none fires.

The problem is straightforward: if two Skills have overlapping trigger phrases, the wrong one might win. If descriptions are too vague, Skills fire on irrelevant requests. If descriptions are too narrow, Skills never fire at all. You’re walking a tightrope, and the tightrope gets thinner with every new Skill you add.

So, what do you do?

Three rules for multi-skill harmony:

Rule 1: Non-overlapping territories. Every Skill must have a clearly defined domain that doesn’t bleed into another Skill’s domain. The Brand Voice Enforcer handles voice compliance. The Email Drafter handles email composition. The Content Repurposer handles format transformation. No overlap. Period. Think of it like departments in a company. Accounting doesn’t do marketing’s job. Marketing doesn’t do engineering’s job. If two departments are fighting over the same task, you have an org chart problem.

Rule 2: Aggressive negative boundaries. Every Skill’s YAML description must explicitly list the other Skills’ territories as exclusions. Your Email Drafter should say “Do NOT use for brand voice checks or content repurposing.” Your Brand Voice Enforcer should say “Do NOT use for drafting emails from scratch or repurposing content.” Yes, this is redundant. Yes, redundancy is the point. You’re building fences, and fences need to be visible from both sides.

Rule 3: Distinctive trigger language. Each Skill should have trigger phrases that are unique to its function. “Check the voice” should only match the Brand Voice Enforcer. “Draft an email” should only match the Email Drafter. If you find yourself using the same trigger phrase for two Skills, one of them has a scope problem that needs fixing.

When the wrong Skill fires, the problem is almost always in the YAML description. Almost always. Here’s a prompt that audits your entire library for conflicts:

PROMPT: SKILL CONFLICT AUDITOR

I have multiple Claude Skills deployed and I'm experiencing
conflicts (wrong Skills firing, Skills not firing when they
should, or overlapping functionality).

Here are the YAML descriptions for ALL of my deployed Skills:

SKILL 1:
[PASTE THE FULL YAML DESCRIPTION FROM SKILL 1]

SKILL 2:
[PASTE THE FULL YAML DESCRIPTION FROM SKILL 2]

SKILL 3:
[PASTE THE FULL YAML DESCRIPTION FROM SKILL 3]

[ADD MORE AS NEEDED]

Run the following conflict analysis:

## 1. TERRITORY MAP
For each Skill, define its territory in one sentence.
Visualise the territories as a list and identify any overlaps.

## 2. TRIGGER PHRASE COLLISION TEST
List every trigger phrase from every Skill.
Flag any phrase that could match more than one Skill.
For each collision, recommend which Skill should own
the phrase and suggest an alternative for the other.

## 3. NEGATIVE BOUNDARY AUDIT
For each Skill, check whether its negative boundaries
explicitly exclude the territories of ALL other Skills.
Flag any missing exclusions.

## 4. AMBIGUOUS REQUEST TEST
Generate 10 realistic user requests that are ambiguous
(could potentially match multiple Skills).
For each, predict which Skill would fire and whether
that's the correct choice.

## 5. DEAD ZONE CHECK
Identify any common user requests that would NOT trigger
any of the deployed Skills but probably should.

## 6. RECOMMENDED FIXES
For each issue found, provide the corrected YAML description
ready to paste directly into the SKILL.md file.

Present findings as a structured report with priority-ranked
fixes.

Reference Strategies That Actually Scale

Module 1 covered the basics: one reference file, one level deep, keep it compressed.

But what happens when your Skill needs to reference a 50-page brand guide, a 30-page style manual, AND a library of templates? If you load all of that every time the Skill fires, you’re burning Claude’s context window on references it doesn’t need for the current task. That’s like making the employee read the entire company handbook every time they need to send a single email.

You need conditional loading. Load only what’s relevant to what the Skill is actually doing RIGHT NOW.

PROMPT: REFERENCE ARCHITECTURE DESIGNER

I have a Claude Skill that needs to reference multiple large
documents. I need help designing the reference file architecture
so Claude loads only what it needs for each request.

Here are the documents my Skill needs access to:
[LIST EACH DOCUMENT WITH ITS APPROXIMATE LENGTH AND PURPOSE,
e.g.:
- Brand voice guide (50 pages, covers tone, vocabulary,
  formatting)
- Email templates (10 templates for different situations)
- Client list with preferences (200 entries)
- Style manual (30 pages, covers visual and written style)]

Here is my SKILL.md:
[PASTE YOUR CURRENT SKILL.MD]

Design a reference architecture that:

1. Splits large documents into focused sub-files that can
   be loaded independently.

2. Creates a "quick reference" version of each major
   document (under 30 lines) that covers 80% of use cases.

3. Writes conditional loading instructions for the SKILL.md
   that tell Claude which references to read based on the
   type of request.

4. Ensures the "one level deep" rule is maintained (no
   reference file links to another reference file).

5. Estimates the token savings vs. loading everything
   every time.

Output:
- Complete folder structure diagram
- Each reference file (compressed and formatted)
- Updated SKILL.md with conditional loading instructions
- Token efficiency estimate

Module 2 complete. You now understand scripts for computation, multi-skill orchestration for conflict-free deployment, and reference strategies that scale without torching your context window.

In Module 3, you’re going to learn how to stop guessing and start PROVING your Skills work. Not “try it and see.” Prove it with data.

Module 3: Testing + Iteration

Here’s the difference between a Skill that “kind of works” and a Skill that runs like a trained employee. It’s this module. Testing, debugging, iterating until the failure modes are eliminated.

Most people build a Skill, try it twice, it looks “fine,” and they move on. Then it fails spectacularly on the third edge case they didn’t anticipate. And they blame Claude. And Claude didn’t do anything wrong - it followed their half-baked instructions perfectly.

The Five Failure Modes

Before you test anything, you need to know what you’re testing FOR. Every Skill failure falls into one of five categories. Learn to diagnose the category and the fix becomes obvious.

Failure Mode 1: The Silent Skill (Never Fires)

Your Skill is sitting there like an employee who showed up to work but nobody told them they had a job to do. You type a request that should trigger it. Claude responds normally. No indication the Skill was even considered.

Root cause? Your YAML description is too weak. Claude’s activation threshold requires a strong match between what you typed and the description. If your description is vague, generic, or missing key trigger phrases, it never crosses the threshold.

Look at your description. Does it explicitly list the words and phrases you just typed? If you said “clean up this spreadsheet” but your description only mentions “CSV files,” there’s your gap.

Fix: Make your description more pushy. Add more trigger phrases. Add context clues. The description should be almost embarrassingly explicit about when to activate. If it doesn’t feel a little over-the-top, it’s not pushy enough.

Failure Mode 2: The Hijacker (Fires on Wrong Requests)

The opposite problem. You ask Claude something completely unrelated and your Skill activates like an overeager golden retriever. You wanted to draft an email but the Content Repurposer decided it was its moment to shine.

Root cause: Your YAML description is too broad, or your negative boundaries are missing.

Look at what you typed and find which words matched the Skill’s description. Then check whether those words should have been excluded.

Fix: Add negative boundaries. “Do NOT use for [list every similar-but-different task].” Tighten your trigger phrases to be more specific.

Failure Mode 3: The Drifter (Fires But Produces Wrong Output)

The Skill activates correctly. Good. But the output doesn’t match what you expected. It’s close but not right. Formatting is off, tone is wrong, it skips steps.

Root cause: Your instructions are ambiguous. There’s more than one way to interpret what you wrote, and Claude chose a different interpretation than you intended. This is always YOUR fault, not Claude’s. Claude followed your instructions. Your instructions were just ambiguous enough to allow multiple valid interpretations.

Read your instructions as if you’ve never seen them before. Find the sentences that could mean two different things. That’s where the drift happens.

Fix: Replace ambiguous language with specific, testable instructions. “Format nicely” becomes “Use H2 headings for each section, bold the first sentence of each paragraph, keep paragraphs to 3 lines max.” Leave zero room for interpretation.

Failure Mode 4: The Fragile Skill (Works Sometimes, Breaks on Edge Cases)

Works perfectly on clean, well-formed inputs. Then you give it something slightly weird - incomplete data, unusual formatting, missing fields - and it collapses like a house of cards.

Root cause: Your edge case handling is incomplete. You built the Skill for the happy path and forgot that real-world inputs are messy, broken, and sometimes actively hostile.

Feed your Skill the worst-case version of every input. Missing fields. Extra fields. Wrong data types. Partially corrupted files. Mixed languages. See where it breaks.

Fix: Add explicit edge case instructions. For every scenario where it breaks, add a specific instruction: “If [condition], then [specific action].” No ambiguity. No “handle appropriately.”

Failure Mode 5: The Overachiever (Adds Things You Didn’t Ask For)

The Skill produces the requested output but ALSO adds unsolicited commentary, extra sections, creative embellishments you didn’t want. It answered the question, and then kept going. And going.

Root cause: Your instructions tell Claude what TO do but not what NOT to do. Without constraints, Claude defaults to being maximally helpful - which sometimes means doing way more than you asked for. Sound familiar? It’s sycophancy by design. Claude wants to please, and “doing more” feels like pleasing.

Fix: Add explicit scope constraints. “Do NOT add explanatory text, commentary, or suggestions unless the user asks for them. Output ONLY the [specified format] and nothing else.”

PROMPT: THE FAILURE MODE DIAGNOSTIC

My Claude Skill is not working as expected. I need help
diagnosing and fixing the problem.

Here is my complete SKILL.md:
[PASTE YOUR SKILL.MD]

Here is what happened:
- What I typed: [PASTE THE EXACT REQUEST YOU MADE]
- What I expected: [DESCRIBE EXPECTED BEHAVIOUR]
- What actually happened: [DESCRIBE ACTUAL BEHAVIOUR]

Diagnose this against the 5 Failure Modes:

1. Silent Skill (never fired) — Is the YAML description
   strong enough to match my request?
2. Hijacker (fired on wrong request) — Is the description
   too broad? Missing negative boundaries?
3. Drifter (wrong output) — Are instructions ambiguous?
4. Fragile Skill (broke on edge case) — Was my input
   an edge case not covered?
5. Overachiever (added unrequested content) — Are scope
   constraints missing?

For the identified failure mode:
- Explain exactly what caused the failure
- Provide the specific fix (corrected YAML, instruction,
  or edge case handling)
- Show the corrected section of SKILL.md ready to paste
- Suggest a test prompt to verify the fix works

Testing Your Skill (For Real This Time)

Here’s the thing. The Skills 2.0 update killed the guesswork. You now have professional-grade testing built in to Claude. Stop eyeballing your results and pretending that counts as testing. Go use the actual tools.

Evals: Write test prompts. Define exactly what the expected behaviour should be. The system runs your Skill against those prompts and returns a Pass/Fail grade. Not “looks okay.” Pass. Or Fail. Binary. Deterministic. Beautiful.

Benchmarks: Track your Skill’s pass rate, token consumption (cost), and execution speed over time. You can see whether your version 3 rewrite actually made things better or just felt like it did. Feelings are not data. Data is data.

A/B Comparator: Run a blind test between two versions of your Skill’s instructions. Hard data on which one wins. No more “I think version B is better.” You KNOW version B is better because the numbers say so.

Description Optimiser: Tells you definitively whether your YAML triggers will fire correctly when users ask for the task. No more guessing about trigger reliability.

Keep iterating until two consecutive evaluation runs show no significant improvement. That’s your signal. Your Skill is production-ready. Not “feels done.” Measurably done.

Module 3 complete. You now have a production-grade Skill backed by data, not vibes.

Module 4 is the final piece: deploying Skills that work across sessions, at scale, over time.

Module 4: Production Deployment

Your Skills work. They’re tested. They’re deployed.

Now the question shifts from “does it work?” to “does it work at scale, over time, across sessions?” Because here’s the thing about Claude’s context window - it fills up. And when it fills up, Claude forgets what happened yesterday. Your beautifully tested Skill doesn’t mean much if it can’t remember what it did in the last session.

State Management: The Shift Handover

When you’re running a Skill across multiple sessions - writing a book, building a complex app, managing a multi-week project - Claude’s context window eventually hits its limit.

It forgets what happened yesterday.

Expert Skill builders solve this with a “shift handover” system. Inside your SKILL.md, you add one instruction:

“At the start of every session, read context-log.md to see what we completed last time. At the end of every session, write a summary of what you finished and what’s still pending.”

That’s it. That’s the entire system.

Think of it like a hospital shift change. The incoming doctor reads the chart. They know exactly what happened, what’s pending, and what to watch for. They don’t need the outgoing doctor to stand there and re-explain everything from scratch. The chart IS the memory.

Your AI works the same way. The context log is the chart. Claude reads its own notes from the previous session and picks up exactly where it left off.

The End Game

You can keep opening Claude every morning and typing the same instructions you typed yesterday. And the day before. And the day before that. Burning through minutes that compound into hours that compound into weeks of lost output.

Or you can spend 10 minutes right now, build one Skill, and never type those instructions again.

The people who build Skills are operating Claude like a custom-built system tuned to their exact specifications. They’ve got an employee that knows their preferences, follows their processes, and improves over time.

Everyone else is using it like a chatbox.

Build your first Skill today. Pick the one task you repeat most often. Follow the steps above. Deploy it. Time how much faster your next session runs.

Then build another one.

And then...

You will see performance start to deteriorate. Your Skills will start contradicting each other. Claude will have too much to read before it starts working. Context bloat creeps back in.

So, what do you do?

You clean up. You consolidate rules and remove contradictions. You trim the fat. And it will feel like magic again.

That’s really the secret. Keep it simple, iterate on what works, be religiously mindful about context, and own the outcome. No Skill today is perfect. But a good Skill is a thousand times better than typing the same instructions into a chatbox every single morning.

Go build something.

If you want to be in the action of actually surrounded by builders then join my private club: joinopusclub.com

Let me be straight with you.

I tried everything. AWS servers. Remote cloud setups. Wrong API keys. Wrong models. I had eight agents running on Telegram simultaneously with “different brains” and every single one kept forgetting what the others were doing. The context just evaporated. Over and over. I tried Kimi. I tried Opus. I burned through roughly $2500 on Anthropic API tokens alone, and I made every mistake you can possibly make in this space.

What I’m about to show you is the other side of that mess. The lean, clean, actually works setup. So simple that your mum would use it, and I mean that in the best possible way.

If you can copy and paste, you’re already qualified.

1/ What you actually need

The machine - your always-on bot host

Nothing fancy. You need a computer that stays powered on 24/7. Minimum specs are laughably modest: 2GB of RAM, a couple of CPU cores, and 20GB of storage. That’s it.

Got an old laptop collecting dust? That works. Want to splash out on an M4 Mac Mini? you’re looking at $700 depending on where you live, and you don’t need to spend that to get started today.

What I actually did? I bought a VPS. A VPS - Virtual Private Server - is essentially a computer in a data centre that you rent by the month. It runs 24/7, it’s already connected to the internet, you don’t need to plug anything in, and you manage it entirely through your keyboard. No physical machine sitting in your home. No setup beyond logging in.

I’m using Contabo for $15 a month. 16GB RAM, enough storage, always on. For the price of a couple of coffees a month, your agent runs around the clock without touching your personal computer.

Old laptop → free.

Mac Mini → $700 once.

VPS → $15/month and running in ten minutes.

Pick what works for you.

2/ The 4 accounts you need

1. Claude Pro - The Brain

Go to claude.ai and sign up. Pro is $20/month, Max is $90/month with significantly more usage. Either works to start, but you’ll hit Pro’s limits faster than you expect once your agent is actually running.

Critical point: you want a Claude membership, not an Anthropic API console account. The console charges per token - every message, every response, it adds up fast. The membership is a flat rate. Way better value. I’ll show you exactly where to find your token during setup.

2. Brave Search - The Eyes (Free)

Without this, your agent is working from static knowledge with no internet access. Sign up at brave.com/search/api, grab your key. Two minutes, done.

3. Gemini 3.1 - The best model today

Google literally just dropped Gemini 3.1 Pro yesterday. It's their most capable model yet - significantly better reasoning, stronger on complex problem-solving, and built for ambitious agentic workflows. It's genuinely impressive. Not part of this core setup, but if you want to experiment with what's possible beyond Claude, this is the one to play with right now.

4. Telegram Bot - The Mouth

This is how you talk to your agent. Free messaging app, dedicated bot you create in two minutes through a tool called BotFather. We’ll walk through it step-by-step during setup.

3/ The actual setup - step by step

Assuming you will go with the VPS way of setting up OpenClaw, since it’s the easiest way you can do right now while you’re reading this article — here’s how it works.

Your VPS is a remote computer you control through your own laptop’s Terminal. To connect, open Terminal on your laptop and type:

ssh root@YOUR_VPS_IP

Replace YOUR_VPS_IP with the IP address your VPS provider gave you when you signed up. Hit Enter, type your password when prompted, and you’re in. Everything from here runs inside that connection.

Step 1 - Install Claude and get your token

Run this to install Claude’s command-line tool:

curl -fsSL https://claude.ai/install.sh | bash

Log in when prompted. Then close and reopen your SSH connection, and run:

claude setup-token

Copy the token it shows you into your notes app. Remove any trailing space - that single invisible character breaks everything and costs you an hour of debugging.

Step 2 - Install Node.js

You’re on Linux now, not Mac. Run this instead:

curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
apt-get install -y nodejs

Step 3 - Install OpenClaw

npm install -g openclaw

Step 4 - Run the onboarding

Type openclaw and hit Enter. Accept the disclaimer, select Quick Start. When asked for a model, choose Anthropic → Anthropic Token. Paste your token. No trailing space.

Navigation: Spacebar to select, Enter to confirm, arrow keys to move.

Step 5 - Connect Telegram

Select Telegram. To get your bot token: open Telegram, search @BotFather, send /newbot, follow the prompts (username must end in “bot”). BotFather hands you a token — paste it into Terminal.

Step 6 - Skills setup

Skip everything except the three hooks at the end — select all three of those. Everything else is noise you can add later.

Step 7 - Hatch it

Select Hatch in TUI. Your bot wakes up. HTTPS error? Trailing space on your token. Fix it, rerun onboarding.

Step 8 - Pair with Telegram

Send your bot something like:

“Your name is [BotName], my name is [YourName]. Here’s my pairing key: [paste key].”

Open your bot on Telegram, enter the pairing key, and it replies there. That’s the moment.

Step 9 - Add Brave and QMD

Just talk to your bot on Telegram:

• “Set up Brave Search — here’s my key: [paste]”

• “Install the QMD skill.”

QMD is your agent’s long-term memory. Install it now before you start chatting — doing it mid-conversation causes resets and lost history.

4/ Now make It actually yours - this Is the part that matters

Most people skip this section and then wonder why their agent sounds like a generic customer service chatbot. Don’t skip this section.

OpenClaw uses three core files to define who your agent is and what it knows:

SOUL.md — Your agent’s personality. How it talks. What it cares about. Its communication style. Formal or casual? Blunt or warm? Detailed or concise? This file is where that gets defined.

USER.md — Information about you. Your name, your job, your schedule, your preferences, the tools you use daily. The more honest and detailed this is, the more useful your agent becomes.

MEMORY.md — Long-term memory. Your agent updates this file over time as it learns things about you — so it remembers things between conversations, days, and weeks.

You could fill these out manually. But here’s the smarter move: let your agent interview you. Once it’s live on Telegram, send it something like:

“You just came online for the first time. I want you to ask me questions to get to know me — my name, what I do, my goals, how I want you to talk to me, what tools I use daily, what I need help with. Ask them one at a time. Then use my answers to fill out SOUL.md and USER.md.”

It’ll run through 10–15 questions. Answer honestly. Talk about your actual life, your actual work, your actual habits. The more real you are, the better your agent understands you.

Pro tip: reply with voice notes instead of typing. You’ll give more natural, detailed answers, and it’s ten times faster. By the end of this process, your agent has genuine context. It knows who you are. It remembers. This is the difference between a chatbot and something that actually feels like a tool built for you specifically.

4/ Every mistake I made — so you don’t have to

1. You don't need to run Opus 4.6 for everything. It's the most expensive model and should be saved for genuinely complex reasoning tasks. For day-to-day use, Kimi is way cheaper and delivers surprisingly close results. Use Opus 4.6 when you actually need it. Use Kimi for everything else.

2. Running eight agents on Telegram simultaneously. Different brains, different contexts, constantly losing track of each other. One smart agent destroys that every time.

3. Leaving the context files empty for a week. Wondered why my agent sounded robotic and unhelpful. Filled out SOUL.md and USER.md properly. Night-and-day difference - immediately.

4. Installing QMD halfway through. Agent kept resetting and losing chat history mid-conversation. Install it from day one.

5. Ignoring voice messages. I use WhisperFlow, the way I used my agent completely changed. I use it ten times more when I can just talk to it on the go rather than type everything out.

That's genuinely all you need.

From zero to a 24/7 AI agent running on a $15 server - not bad for an afternoon's work. Go have fun with it. And if you want to go deeper, subscribe to my newsletter.

I'm working on something that I think is going to change how anyone builds with agents and you don't want to miss it.

Subscribe now

A week from now, two versions of you exist...

One is still watching tutorials, bookmarking articles, telling themselves they’ll “get to it eventually” while AI reshapes their industry around them

The other is building tools, automating workflows, and deploying AI as infrastructure... billing more, working less, turning down clients

Same starting point, different trajectory, and the split happens in the next 7 days

This is the curriculum that creates version two

I call it the Operator Sprint: the compressed, high-intensity sequence that builds AI skills in the order that maximizes compounding, where each day unlocks capabilities for the next, and by day 8 you’re not just using AI, you’re deploying it

Not another prompt engineering post you’ll bookmark and forget, not a course teaching yesterday’s techniques, not theory that sounds smart but produces nothing

This is the path from overwhelmed to operational... hands-on, current, specific, one focused session per day for 7 days

Here’s the thing most AI education gets wrong: they teach you tools before they teach you thinking, so you memorize prompts instead of developing intuition

We’re going to fix that in a week

Let’s build version two together

Day 1: the mental model that makes everything else click

Most AI education starts wrong

They teach prompt tricks before you understand why prompts work, so you’re copying templates instead of adapting to situations

Today we fix that... and once you have this foundation, you’ll never look at AI the same way again

How AI actually reads your words

When you type “the bank was steep” the model has a decision to make: are you talking about money or a riverbank?

The attention mechanism solves this by weighing which surrounding words matter most, it’s constantly asking “what context helps me understand this word?” and that simple insight explains 80% of why some prompts work and others fail

Give the model clear context and it makes better decisions, starve it of context and it guesses

You’ve probably felt this without knowing why, some prompts produce exactly what you want while similar prompts produce garbage, the difference is usually context clarity

The parameter that changes everything

Temperature controls randomness on a 0-to-1 scale

At 0 the model gives you its most confident answer every time, at 1 it takes creative risks

Set it low for factual queries and analysis, push it higher when you want unexpected ideas

This single parameter separates frustrating AI sessions from productive ones, most people never touch it and wonder why their results feel random

Try this right now: run the exact same prompt twice at temperature 0, you’ll get nearly identical outputs, then run it at temperature 1 and watch how different each generation becomes

Why AI lies to you and how to catch it

Here’s something counterintuitive: AI doesn’t know what’s true

It predicts what text is likely to come next based on patterns, and confident-sounding text patterns exist for both facts and fiction, so the model produces both with equal confidence

Studies show nearly half of AI-generated citations are partially or completely fabricated... the model invents author names, journal titles, even URLs that don’t exist

The fix isn’t hoping they’ll patch this, hallucination is structural, not a bug

Instead: verify specific claims, use low temperature for factual queries, ask the model to acknowledge uncertainty, and later this week you’ll build RAG systems that ground responses in real documents to eliminate this problem entirely

The model landscape: know your tools

The “best” model changes based on what you’re doing, and using the wrong one for your task is like using a screwdriver as a hammer

Here’s how the landscape breaks down right now:

Claude from Anthropic owns coding, marketing/long-form writing, and spreadsheet analysis... Claude Opus 4.5 leads the benchmarks and the community feedback, and the Claude in Excel integration alone is worth the subscription for anyone spending more than an hour per week in spreadsheets

Gemini 3 Pro from Google dominates research... that 1M token context window means you can upload an entire research corpus, a full codebase, months of meeting transcripts, and Gemini holds all of it while answering questions with full context, plus native Google Search integration pulls current information rather than hallucinating

GPT-5 is a useful negative example... it consistently produces the most generic, obviously-AI-written output, understanding what mediocre AI output looks like helps you avoid producing it

Grok for real-time social analysis on X, limited use case but nothing else does it as well

The decision framework

Stop asking “which AI is best” and start asking “what am I trying to do”

Coding and technical writing → Claude... research requiring current information → Gemini... long document analysis → Gemini... marketing copy and brand voice → Claude... spreadsheet work → Claude with Excel integration... social media analysis → Grok... image generation → Nano Banana Pro... video generation → VEO 3.1 or Kling 2.6

This framework eliminates the decision paralysis that keeps most people switching between models and mastering none

Today’s assignment: sign up for Claude and Gemini if you haven’t, run the same prompt through both at different temperature settings, observe the differences, internalize the mental model... this is the foundation everything else builds on

Day 2: prompt engineering and context architecture

Knowing which model to use is only half the equation... you also need to know how to communicate with them effectively

Forget the clever tricks, the game changed, clarity beats cleverness now, and the people getting results are writing prompts that read like good briefs, not like magic spells

Format by model

Claude was trained with XML tags so it responds exceptionally well to structure like this:

<context>

background information here

</context>

<task>

specific instruction here

</task>

<format>

how to structure the output

</format>

GPT and Gemini work well with JSON when you need structured data back

The format isn’t magic, it’s about giving the model clear signals about what you want, XML tags function like section headers in a document, they reduce ambiguity and the model rewards clarity with better outputs

Chain-of-thought for hard problems

When you need the model to work through something complex, adding “let’s think through this step by step” before asking for an answer significantly improves results

This isn’t placebo, reasoning tasks show measurable improvement when you prompt the model to externalize its thinking process

Use it for math, logic, multi-step analysis, and debugging... skip it for simple questions where the extra thinking adds nothing

The system prompt formula

Effective system prompts contain four elements:

Role — who the AI should be, like “you are a senior financial analyst specializing in tech valuations”

Behavior — how it should interact, like “ask clarifying questions before making assumptions and acknowledge when you’re uncertain”

Constraints — what it should avoid, like “do not give specific investment advice”

Output structure — how to format responses, like “lead with a 2-sentence summary then provide supporting analysis”

A good system prompt converts a general-purpose AI into a specialized assistant for your specific workflow, and once you’ve built one that works, you can reuse it hundreds of times

Now zoom out: context engineering

Prompt engineering was the 2024-2025 skill, context engineering is the 2025-2026 skill

The shift recognizes that individual prompts matter less than the information environment you create around your AI interactions

Shopify CEO Tobi Lutke defined it as “the art of providing all the context for the task to be plausibly solvable by the LLM”

The four strategies:

Write — save context outside the active window using scratchpads and reference files the AI can access

Select — choose what enters context through RAG and dynamic retrieval rather than dumping everything in

Compress — summarize verbose information before including it

Isolate — use separate conversation threads or sub-agents for different contexts that shouldn’t mix

Today’s assignment: build your first system prompt using the four-element formula for a task you do repeatedly, test it across Claude and Gemini, then set up a Claude Project... upload relevant documents, write custom instructions, and run your first conversation with persistent context, one focused project per task beats one massive project with everything

Day 3: build your custom knowledge assistant

This is where the Operator Sprint pays off most directly: you build an AI expert on YOUR knowledge base that cites sources and doesn’t make things up

RAG stands for Retrieval Augmented Generation and it sounds complex but the concept is simple: before answering your question, the system searches your documents for relevant information and includes that in the context

This grounds responses in your actual data rather than the model’s training, which dramatically reduces hallucination and enables domain-specific expertise

NotebookLM for zero-code RAG

Google’s NotebookLM requires no setup and works remarkably well

Upload PDFs, Google Docs, YouTube videos, or websites and the system becomes an expert on that content with inline citations

Audio Overviews generate podcast-style discussions of your documents, Mind Maps visualize complex topics, Deep Research in the Plus tier provides comprehensive analysis across your sources

This is the fastest path to a working knowledge assistant... under an hour from nothing to a functional system

Claude Projects as an alternative

Upload documents to a Claude Project and every conversation in that project references them automatically

More flexible than NotebookLM when you need to create outputs like documents and code rather than just query information

The insight most people miss: one focused project per task beats one massive project with everything, a project for “client proposals” with relevant case studies and pricing works better than a general “work stuff” project with hundreds of files competing for attention

You can also create knowledge containers in Claude Skills... invest time working with Skills, it’s worth it

Understanding what’s happening under the hood

For those who want to go deeper: documents get split into chunks and converted to numerical representations called embeddings, those embeddings get stored in a vector database, when you ask a question your query becomes an embedding and the database finds the most similar document chunks, those chunks plus your question go to the LLM which produces a grounded answer

You don’t need to build this yourself... NotebookLM and Claude Projects handle it, but understanding the mechanism helps you troubleshoot when results aren’t what you expect

Today’s assignment: build a NotebookLM notebook with documents from your actual work... client files, research papers, internal docs, whatever you reference repeatedly, then build a parallel Claude Project with the same content, compare the outputs, notice how grounded responses feel completely different from generic AI answers

Day 4: creative tools — image and video generation

This is where AI gets tangible and marketable fast

Image generation: Nano Banana Pro

Late 2025 was supposed to be when AI image generation matured, instead one model leapfrogged everything else and reset expectations completely

What Nano Banana Pro gets right:

Perfect text rendering — for years AI images couldn’t spell, text came out garbled or mirrored, now it generates correctly-spelled text in any style you specify, this single capability opens use cases that were impossible before like infographics, posters, social graphics with headlines

Reasoning before rendering — the model thinks about your scene, considering composition and lighting and subject relationships before generating pixels, the result is images that feel intentional rather than random

Search grounding — it can use Google Search to create factually accurate infographics about real topics, not just aesthetically pleasing nonsense

Prompting Nano Banana Pro

Forget the 2024 approach of loading prompts with “4k, trending on artstation, masterpiece” garbage

This model understands natural language, describe what you want like you’re briefing a photographer

The structure that works: subject with descriptive details, then action, then environment, then composition notes, then lighting, then any specific text requirements

Example: “a minimalist movie poster for a thriller, the title ‘SILENT ECHO’ in distressed sans-serif at the top, a lone cabin in a snowy forest viewed from above, high contrast black and white, title perfectly legible and centered”

Midjourney V7 still produces the most artistic and cinematic output for stylized work, Flux is the open-source option for running image generation locally

Video generation: know the limits

I need to be honest here... AI video demos look incredible, the actual experience of using these tools is humbling, that said, they’re production-ready for specific use cases

VEO 3.1 from Google is the most complete package: native audio generation with synchronized dialogue and sound effects, up to 60 seconds, 4K output, vertical format support for social platforms

Kling 2.6 produces the most cinematic realism for short clips... many “real” videos circulating on social media are actually Kling generations

What you need to know: 5-10 seconds is the reliable range, complex physics still fail, budget 3-10 attempts per usable clip, prompt like a director describing what the camera sees not a storyteller describing narrative

Current sweet spot: social media shorts under 15 seconds, B-roll footage, product reveals, concept visualization

Today’s assignment: generate 10 images with Nano Banana Pro using the natural language prompting approach, then create 3 short video clips with VEO 3.1 or Kling 2.6... notice how the prompting skills from day two directly apply here, specificity and context clarity determine output quality

Day 5: coding with AI — even without coding skills

English is now a programming language

Andrej Karpathy called it “vibe coding” and the name stuck because it captures something real: you describe what you want, AI generates code, you run it and observe, then iterate based on results

Non-developers are building functional tools this way, and developers are shipping 10x faster than before

For developers: Claude Code and Cursor

Claude Code runs in your terminal and can read entire codebases, make multi-file edits, run tests, and create commits autonomously... by end of 2025 it hit $1B in annualized revenue, that growth rate reflects developers voting with their wallets after trying everything else

Cursor is an AI-first IDE built on VS Code, import your existing settings and you’re productive immediately

These two tools together cover terminal work and IDE work, everything else is a downgrade at this point

For non-developers: build real things

Lovable takes natural language descriptions and produces complete web applications, no coding knowledge required

Bolt.new does similar rapid prototyping from plain English

Replit provides a browser-based development environment with AI assistance for those learning

The practical tasks this enables for people who never wrote code: automation scripts for file organization, data extraction from PDFs and websites, simple web tools for personal use, custom productivity apps

Today’s assignment: build something, if you’re a developer pick a project you’ve been procrastinating on and use Claude Code or Cursor to ship it today, if you’re not a developer go to Lovable or Bolt.new and describe a simple tool you wish existed... a calculator for your niche, a dashboard for tracking something, a landing page for your service, watch it materialize from a paragraph of English

Day 6: automation and integration — AI as infrastructure

This is where AI stops being a chat tool and becomes infrastructure

The difference between using AI and deploying AI is automation: systems that run without your involvement, processing inputs and producing outputs

N8n: the automation backbone

I tested every automation platform extensively and landed on n8n for clear reasons... it’s open-source and self-hostable with unlimited free executions, which matters when you’re running hundreds of workflow executions per day

Claude Code can generate n8n configurations from natural language descriptions: describe the workflow you want in plain English, Claude Code generates the technical implementation, deploy it

This bypasses the learning curve for visual automation builders entirely... you’re describing outcomes and receiving infrastructure

MCP connects everything

Model Context Protocol is an open standard that lets AI systems connect to external tools and data sources

Think of it as a universal adapter: implement MCP once and your AI can talk to Google Drive, Slack, GitHub, databases, whatever you need

Claude Desktop ships with pre-built MCP servers for common services, n8n can create custom MCP servers from workflows

Workflows that produce real value

Content repurposing: publish a blog post and automatically generate LinkedIn, Twitter, and Instagram versions scheduled through Buffer... one piece of content becomes four without additional effort

Customer feedback routing: new submissions get sentiment analysis, negative feedback routes to urgent Slack channels, support tickets created when needed... problems surface before they escalate

These aren’t theoretical, they’re running in production for businesses right now, and once you understand the pattern you can build custom versions for any repeating process

Today’s assignment: identify the three most repetitive processes in your work, design an automation for the simplest one using n8n, if you have Claude Code set up let it generate the configuration from your plain English description, deploy it and watch it run without you

Day 7: the frontier — open source, personal agents, and what’s next

Today you look ahead... because mastering AI means understanding where it’s going, not just where it is

Open source models: the shift that’s coming

Open source caught up to closed models in ways that seemed impossible two years ago

Kimi K2 from Moonshot AI has over a trillion parameters and beats GPT-5 on major benchmarks while costing roughly 1/10th as much through API access... they just released 2.5 and it’s a beast

DeepSeek V3.2 matches GPT-5 performance with 90% lower training costs and can be self-hosted

The timeline: right now access open source through APIs via OpenRouter... 6-12 months consumer hardware runs capable local models for daily use... 12-24 months open source likely matches or exceeds closed models for most practical tasks

The Operator Sprint prepares you for both worlds: closed models now, open source when the infrastructure catches up

Personal AI agents: the end state

Here’s where things get genuinely weird...

We’re watching the birth of AI assistants that aren’t chatbots in browser tabs, AI that runs on your hardware, connects to every platform you use, remembers everything, and takes action autonomously

Clawdbot is what Siri should have been... an open-source project that runs entirely on your hardware, connects to WhatsApp, Telegram, Slack, Discord, Signal, iMessage, has persistent memory across every conversation, and can read/write files, control browsers, execute scripts, and build its own extensions

The self-modifying part is what matters: ask it to add a feature it doesn’t have, it writes the code, tests it, and hot-loads the changes

2026 is the year of personal agents, the infrastructure exists, the early adopters are already living in this future

Today’s assignment: explore OpenRouter and run the same prompt through 3 open source models, compare outputs to Claude and Gemini, then if you want to see where personal AI is heading check out Clawdbot on GitHub... you don’t need to set it up today, but understanding what’s possible changes how you think about everything you built this week

The Operator Sprint: why this sequence works

This curriculum follows a deliberate progression and the order matters

Day one gives you the mental model so you’re developing intuition not memorizing tricks

Day two gives you the communication skills that multiply the value of every AI interaction that follows

Day three gives you knowledge infrastructure that eliminates hallucination for your domain

Day four gives you creative tools with immediate commercial applications

Day five gives you the ability to build things that didn’t exist before

Day six gives you automation that works while you sleep

Day seven gives you the map for where all of this is heading

Each day compounds on the previous one... the prompting skills from day two make day four’s image generation better, the context architecture from day two makes day three’s RAG systems more effective, the coding from day five powers day six’s automations

The single highest-leverage move

Build a Claude Project for a task you do repeatedly

Upload relevant documents, write custom instructions that define behavior, and suddenly you have a specialized assistant that saves hours every week

Not hypothetical hours, real hours, the kind you can redirect toward work that matters or reclaim for your life outside work

Resources worth bookmarking

Anthropic Prompt Guide — official documentation with patterns that work

OpenAI Tokenizer — visualize how text becomes tokens, essential for understanding context limits

Andrej Karpathy’s LLM videos — foundational understanding that ages well as tools change

NotebookLM — free RAG without code, working knowledge assistant in under an hour

OpenRouter — unified access to every major model including open source options

The path forward

7 days from now, two versions of you exist

One completed the Operator Sprint and can do things that seemed impossible a week ago: building tools, automating workflows, deploying AI infrastructure that runs without constant attention

The other is still collecting bookmarks, still planning to start, still waiting for the “right time”

Same starting point, different trajectory

The window matters because the gap between AI-fluent and AI-confused is widening every month, the people who build these skills now will have compound advantages that grow over time, while the people who wait will face an increasingly steep climb

The roadmap is here

The tools work

7 days, one focused session daily, and you’re operating instead of observing

What happens next is your choice, but the choice is time-sensitive, and waiting has a cost

Let’s build version two

Subscribe now

Here is your weekly dose of 4-Good Finds, a list of what I’m learning and testing.

1/ New word that’s helping me stress less about unfinished projects

Greek has these beautifully compact words that capture entire concepts we can’t express in English. Meraki is one of them.

I’ve started using it as a filter. Before I start something, I ask: “Can I bring meraki to this?” If the answer is no, maybe I shouldn’t be doing it. Or maybe I need to find a way to make it matter.

Simple question. Keeps me honest about what’s worth my time.

2/ If you’ve been wanting to build something and get paid for it - Apify is running a $1M challenge right now.

I don’t usually share stuff like this, but this one felt worth mentioning for anyone here who builds things.

Apify (they make automation tools for AI agents) is looking for people to build and publish “Actors” on their platform. Basically: you build a useful automation tool, publish it on their store, and if people use it, you get paid.

The structure: $2 per active user (capped between $100-$2,000 per tool), weekly $2,000 spotlight awards, and $30K/$20K/$10K for the top 3 builders at the end.

If you’re a developer or someone who tinkers with automations and you’ve been looking for a reason to actually ship something — this might be it. Deadlines have a funny way of making things happen.

Not for everyone, but if this is your thing: https://apify.com/challenge

3/ If your work touches numbers, now or in the future, and you want to learn math properly,

I made a detailed thread that shows a from the ground up math you’ll actually need.

Read here

Math is one of those things I wish someone had been honest with me about earlier.

I struggled with it in school. Turns out my problem wasn’t that I was “bad at math, I just wasn’t doing enough of it. I was reading explanations and watching videos and thinking I understood. I didn’t.

The best way to learn math is to do math. Find a quiet place and do the exercises in each section of the book. As many as you can every single day. Form a habit and stick to it. Get it done.

4/ Casual reminder that Harvard University has recently updated their FREE online classes

Here’s the catalog

Happy learning 🍀

Abi

A Hungarian psychology professor once wrote to famous creators asking them to be interviewed for a book he was writing.

What’s interesting isn’t who said yes. It’s how many said no.

Peter Drucker, the management writer:

“One of the secrets of productivity (in which I believe whereas I do not believe in creativity) is to have a VERY BIG waste paper basket to take care of ALL invitations such as yours - productivity in my experience consists of NOT doing anything that helps the work of other people but to spend all one’s time on the work the Good Lord has fitted one to do, and to do well.”

Saul Bellow’s secretary:

“Mr. Bellow informed me that he remains creative in the second half of life, at least in part, because he does not allow himself to be a part of other people’s ‘studies.’”

Richard Avedon: “Sorry — too little time left.”

György Ligeti’s secretary:

“He is creative and, because of this, totally overworked. Therefore, the very reason you wish to study his creative process is also the reason why he (unfortunately) does not have time to help you in this study. He would also like to add that he cannot answer your letter personally because he is trying desperately to finish a Violin Concerto which will be premiered in the Fall.”

The professor contacted 275 creative people. A third said no. Their reason was lack of time. A third said nothing. We can assume their reason for silence was the same and possibly the lack of a secretary.

Here’s what most people miss about creation.

They think it’s about talent. Inspiration. The right idea at the right moment.

It’s not.

Time is the raw material of creation. Wipe away the magic and myth and all that remains is work. The work of becoming expert through study and practice. The work of finding solutions to problems and then finding problems with those solutions. The work of trial and error. The work of thinking and perfecting.

That’s it. That’s what creating actually is.

It consumes everything. It is all day, every day. It knows neither weekends nor vacations. It is not when you feel like it. It is habit, compulsion, obsession, vocation.

The common thread that links creators is not what they think or how they feel. It’s how they spend their time. No matter what you read, no matter what they claim, nearly all creators spend nearly all their time on the work of creation.

There are few overnight successes and many up-all-night successes.

Here’s the part nobody wants to hear.

Saying “no” has more creative power than ideas, insights, and talent combined.

“No” guards time — the thread from which we weave our creations.

The math is simple: you have less than you think and need more than you know.

But you were never taught to say no. You were taught the opposite. “No” is rude. “No” is a rebuff, a rebuttal, a minor act of verbal violence. “No” is for drugs and strangers with candy.

So you keep saying yes. And you wonder why nothing gets made.

Creators don’t ask how much time something takes. They ask how much creation it costs.

This interview. This letter. This trip to the movies. This dinner with friends. This party. This last day of summer.

How much less will I create unless I say no? A sketch? A stanza? A paragraph? An experiment? Twenty lines of code?

The answer is always the same: yes makes less.

You do not have enough time as it is. There are groceries to buy, gas tanks to fill, families to love, and day jobs to survive.

People who create know this. They know the world is all strangers with candy. They know how to say no and they know how to suffer the consequences.

Charles Dickens, rejecting an invitation from a friend:

“’It is only half an hour’ — ‘It is only an afternoon’ — ‘It is only an evening,’ people say to me over and over again; but they don’t know that it is impossible to command one’s self sometimes to any stipulated and set disposal of five minutes — or that the mere consciousness of an engagement will sometimes worry a whole day… Whoever is devoted to an art must be content to deliver himself wholly up to it, and to find his recompense in it. I am grieved if you suspect me of not wanting to see you, but I can’t help it; I must go in my way whether or no.”

Read that line again. The mere consciousness of an engagement will worry a whole day.

It’s not just the hour you lose. It’s the mental real estate. The open loop running in the background. The fractured attention that makes depth impossible.

“No” will make you look aloof. Boring. Impolite. Unfriendly. Selfish. Anti-social. Uncaring. Lonely.

Let it.

“No” is the button that keeps you on.

- Abi

If you’re anything like me, you’ve been lied to about what makes a career fulfilling.

“Follow your passion.” “Find your purpose.” “Do what you love and you’ll never work a day in your life.”

It sounds nice. It’s also mostly wrong.

I used to think the dream job equation was simple: find what excites you, pursue it relentlessly, and satisfaction will follow. But when you actually look at the research, three decades of it across positive psychology, motivation science, and job satisfaction, the picture is completely different.

Most career advice is written by people who either got lucky or are trying to sell you something. They tell you to journal about your passions, visualize your ideal day, and trust that the universe will align.

The universe doesn’t care about your vision board.

What actually predicts whether you’ll be fulfilled in your work is far more concrete, far more actionable, and far less romantic than the self-help industry wants you to believe.

This letter is comprehensive.

It’s not a quick dopamine hit of motivation that evaporates by tomorrow. This is the kind of thing you’ll want to bookmark, reference when making career decisions, and actually think about.

We’re going to dismantle the two biggest myths about fulfilling work, rebuild from first principles using actual evidence, and give you a framework you can apply immediately.

Let’s begin.

I – Money Will Not Save You

People say money can’t buy happiness, then spend their entire careers optimizing for compensation.

Which is it?

The research is clear, and it’s not what either side wants to hear.

Money does make you happier. But the effect is pathetically small compared to what most people sacrifice to get it.

A landmark 2010 study by Kahneman and Deaton surveyed thousands of Americans. The findings: going from $40,000 to $80,000 in household income only moved life satisfaction from about 6.5 to 7 out of 10.

That’s doubling your income for half a point.

But here’s where it gets interesting. When they measured day-to-day emotional experience - whether people actually felt happy, calm, or unstressed - the line went flat around $50,000. Beyond $90,000, income had zero relationship with how people felt on a daily basis.

Now, more recent research suggests happiness might continue increasing slightly past these thresholds. Kahneman himself revisited the data in 2023 and noticed ceiling effects that may have artificially flattened the curve.

But even the most generous interpretation of the evidence leads to the same conclusion: beyond a moderate income that covers your needs and provides some security, chasing money is one of the least efficient ways to increase your life satisfaction.

You already know people who prove this. The miserable investment banker. The unfulfilled corporate lawyer. The person who “made it” financially and still feels empty.

They’re not anomalies. They’re the predictable outcome of optimizing for the wrong variable.

Adjust for your situation: if you’re single with no dependents in a moderate cost-of-living area, you’re looking at roughly $80,000 (2026 dollars) as the threshold where additional income stops moving the needle much. Add for dependents, expensive cities, and retirement savings as needed.

If you’re a college graduate in a developed country, you’ll likely land well into this range over your career anyway. Which means the marginal return on sacrificing other things for higher pay is close to zero.

The lesson isn’t that money is irrelevant. It’s that once your basic needs are met, almost everything else matters more.

II – You Don’t Actually Want A Low-Stress Job

“I just want something that’s not too stressful.”

I hear this constantly. And I get it. Burnout is real. Chronic stress destroys health and relationships.

But here’s what the research actually shows: the relationship between stress and wellbeing is not linear. It’s not “less stress = more happiness.”

It’s a curve.

Studies of high-ranking government and military leaders — people managing enormous responsibilities with less sleep and more demands — found they had lower stress hormones and less anxiety than their subordinates.

Why? Control.

When you have agency over how you work, when you set your own priorities and decide how to tackle challenges, demanding work becomes energizing rather than depleting.

The distinction isn’t between stressful and non-stressful jobs. It’s between:

• Challenges that match your abilities vs. demands that exceed or underwhelm them

• Short-term intensity vs. chronic, unrelenting pressure

• High autonomy vs. low control

• Strong social support vs. isolation

• Viewing stress as useful vs. viewing it as purely harmful

A job with no challenge is boring. Boredom is its own form of suffering. A job with demands that exceed your abilities without support is crushing. But a job with meaningful challenges, autonomy, and the right context? That’s where you find flow.

The optimal state of inner experience is one in which there is order in consciousness. This happens when psychic energy—or attention—is invested in realistic goals, and when skills match the opportunities for action.

– Mihaly Csikszentmihalyi

A good book (and TED talk with over 10 million views) by psychologist Kelly McGonigal claims that stress itself isn’t the problem. It’s your belief about stress that determines whether it harms you.

She cites a study that tracked 30,000 adults over eight years. People who experienced high stress and believed stress was harmful had a 43% increased risk of dying. But people who experienced high stress but didn’t view it as harmful had the lowest risk of death in the study, even lower than people who reported relatively little stress.

Read that again.

The belief that stress is killing you might actually be what’s killing you.

McGonigal’s argument is that when you reframe stress, when you see your pounding heart as your body rising to meet a challenge rather than evidence that you’re falling apart, your physiology literally changes. Your blood vessels stay relaxed instead of constricting. Your body produces oxytocin, making you more social and more likely to seek support.

This isn’t woo-woo. It’s measurable in a lab.

The implication is uncomfortable for people who’ve built their entire worldview around stress avoidance. Maybe the goal was never to eliminate stress. Maybe it was to stop fearing it.

III – The Six Ingredients (That Actually Matter)

Forget salary brackets and prestige rankings.

When researchers actually study what makes people satisfied with their work, not what they think will make them satisfied, but what actually correlates with fulfillment, six factors emerge consistently.

1. Engaging work

What you do hour by hour matters more than your title, company, or industry.

Engaging work draws you in, holds your attention, and creates flow states. It’s why an hour of spreadsheet editing feels like torture while an hour of a well-designed game feels like minutes.

Four factors predict engagement:

• Freedom to decide how you perform your work

• Clear tasks with defined beginnings and ends

• Variety in what you do

• Feedback so you know how you’re doing

Each correlates strongly with job satisfaction (r=0.4 in meta-analyses). These aren’t soft suggestions. They’re the most empirically verified predictors we have.

2. Work that helps others

Here’s a pattern that should disturb you:

Revenue analysts, fashion designers, and TV newscast directors all have engaging work by the criteria above. Yet over 75% of people in these roles say their work isn’t meaningful.

Fire service officers, nurses, and neurosurgeons? Almost everyone finds them meaningful.

The difference is obvious: the second group directly helps people.

The evidence is robust. People who volunteer are less depressed and healthier. A meta-analysis of 23 randomized studies showed performing acts of kindness makes the giver happier. Global surveys find people who donate to charity are as satisfied with their lives as those who earn twice as much.

Helping others isn’t the only path to meaning, but it’s one of the most reliable.

3. Work you’re good at

Competence creates a sense of achievement — one of the core ingredients of life satisfaction identified by positive psychology.

But there’s a more practical reason: skill gives you leverage. If you’re good at something others value, you can negotiate for everything else; meaningful projects, engaging tasks, fair compensation, better conditions.

Even if you love art, if you pursue it without developing real skill, you’ll end up doing boring graphic design for companies you don’t care about.

Passion without competence is a trap.

4. Supportive colleagues

You don’t need to be friends with everyone at work. But you need people who will help you when you’re stuck.

“Social support” is among the strongest predictors of job satisfaction in major meta-analyses (r=0.56). Whether you can get assistance, feedback, and collaboration matters more than whether you’d grab launch with your coworkers.

Interestingly, people who disagree with you but care about your success — what Adam Grant calls “disagreeable givers” — often provide the most valuable input. They’ll tell you what others won’t.

5. Absence of major negatives

This sounds obvious, but people consistently underweight it:

• Commutes over an hour (especially by bus)

• Excessive hours

• Pay that feels unfair

• Job insecurity

The negative impact of a brutal commute can outweigh multiple positive factors. People take jobs they’re excited about, then spend two hours a day in traffic and wonder why they’re miserable.

Don’t ignore the basics.

6. Fit with the rest of your life

You don’t have to get everything from your career.

Einstein had his most productive year in 1905 while working as a patent clerk. Plenty of people find meaning through side projects, volunteering, relationships, or philanthropy while maintaining a job that simply pays the bills.

Consider how your work integrates with everything else you value.

IV – Why “Follow Your Passion” Fails

This phrase has become gospel.

Google Ngram shows its usage exploding over the past few decades. Every commencement speech, every influencer, every well-meaning parent repeats it.

And it’s not completely wrong. Intrinsically motivating work does make people happier than a big paycheck. We covered that.

But “follow your passion” fails in three specific ways.

First, it implies passion is sufficient.

Even if you love basketball, a job in basketball where you hate your colleagues, receive unfair pay, and find the work meaningless will still make you miserable. Passion doesn’t override the six ingredients. If anything, pursuing your passion into competitive fields makes satisfying those ingredients harder because everyone else is competing for the same limited positions.

Second, it alienates people who don’t have an obvious passion.

Most people don’t feel a burning calling toward a specific career. Telling them to “follow their passion” just makes them feel broken. If you don’t have a clear passion, you’re not defective. You can develop one.

Third, it encourages premature narrowing.

If you love literature, you might assume you need to become a writer and ignore dozens of other paths that could be equally fulfilling. People eliminate options that don’t immediately spark joy, not realizing that passion often develops after competence, not before.

Steve Jobs is constantly cited as the poster child for “do what you love.” But Jobs was passionate about Zen Buddhism, calligraphy, and Western history before he got into technology. He entered tech to make quick cash. His passion grew alongside his success.

The important thing for you to remember is that it does not matter in the least how you got the idea or where it came from.

– Maxwell Maltz

Your interests change more than you expect. Think about what obsessed you five years ago. It’s probably different from what interests you now. And as we established, humans are notoriously bad at predicting what will actually make them happy.

You have far more options for a fulfilling career than “follow your passion” suggests.

V – The Actual Answer

Rather than “follow your passion,” the formula that actually works is simpler and less romantic:

Get good at something that helps others.

That’s it.

If you develop rare and valuable skills in a domain that genuinely benefits people, everything else follows. You’ll have leverage to negotiate for engaging work, supportive colleagues, reasonable conditions, and fair pay. You’ll have meaning because your work matters. And you’ll develop passion because competence and contribution are intrinsically rewarding.

Adam Grant’s work in Give and Take shows that people with a “giving mindset” end up among the most successful because they attract more help and are fueled by purpose. The caveat is that pure givers who don’t protect their own wellbeing burn out. You need the other ingredients too.

People who orient their career around contribution become more motivated, more resilient, and more fulfilled than those who chase passion, status, or money.

They develop passion as a consequence of doing work that matters and doing it well. The passion comes second, not first.

VI – The Protocol

Everything above is useless if you don’t apply it.

Here’s how to actually use these ideas to evaluate your options and guide your decisions.

Exercise 1: Compare your current options

Pick two career paths you’re considering. Score each from 1-5 on:

• Engaging work (autonomy, variety, clarity, feedback)

• Helps others

• Potential to become skilled

• Quality of colleagues / social support

• Absence of major negatives

• Fit with your life outside work

Don’t expect any option to win on every dimension. Look for the best overall balance.

Exercise 2: Mine your past for signal

Your memory isn’t perfect, but ignoring your experience entirely is foolish. Answer these:

• When have you felt most fulfilled in the past? What did those experiences have in common?

• If you found out you had 10 years to live, what would you spend your time doing?

• What kinds of people do you work best with?

• What specific conditions (environment, pace, structure) make you thrive vs. drain you?

Exercise 3: Build your personal criteria

Combine the six research-backed ingredients with your own insights from Exercise 2.

Write down 4-8 factors that matter most to you in a fulfilling career. These become your decision criteria going forward.

When evaluating any opportunity, run it against this list. Not to find perfection, that doesn’t exist, but to find the best available option on balance.

Exercise 4: Identify your contribution path

Ask yourself:

• What problems in the world do I actually care about?

• What skills could I develop that would be valuable in addressing those problems?

• What’s the overlap between problems I care about and skills I could realistically build?

The intersection is your highest-leverage path.

The dream job isn’t found by looking inward for some hidden passion waiting to be discovered. It’s built by developing competence in work that genuinely matters, then structuring the rest; the environment, the people, the conditions.. to support that.

Get good at something that helps others.

Everything else is a footnote.

- Abi

Like many of you, I feel frustrated that Microsoft seems to be ignoring user feedback and forcing these features onto our systems, turning the OS into bloatware.

I believe AI should be an option, not a requirement.

So here’s how to quickly get rid of it completely in 3 minutes:

1/ Settings app

> Personalization
> Taskbar
> Other System Tray Icons
> Switch “Microsoft 365 Copilot App” Off

This hides Copilot from your task bar.

2/ Press Win + R

> Type in “regedit”
> Navigate to “HKEY_CURRENT_USER/SOFTWARE/POLICES/MICROSOFT/WINDOWS”
> Right-click on the “Windows” key
> New
> Key
> Name the new key “WindowsCopilot”
> Right-click on the new key
> New
> DWORD (32-BIT) value

3/

> Name the value “TurnOffWindowsCopilot”
> Double-click the name of the value
> Set the “Value Data” to 1
> Restart your computer

Or,

There’s also a Script you can use if you don’t want to go thro all of the above.

This script does exactly what the name implies. It targets and removes or disables the core AI-centric services and applications that come pre-installed with Windows 11.

This includes the Windows Copilot runtime, the AI-powered Windows Studio Effects for video calls, and related background services that run by default.

Think of it as a surgical tool to declutter the AI layer that Microsoft has started baking into the OS.

github.com/zoicware/RemoveWindowsAI

Congrats! Coplit is now completely gone from your computer.

Hope this helps.

You’ve had those days

The ones where you wake up with intentions and go to bed having done nothing

Where you scroll until your eyes hurt, where hours disappear into nothing, where you tell yourself tomorrow will be different

And tomorrow comes and it’s the same thing

You know what you want. You know what you should be doing. But somehow there’s this massive gap between knowing and doing

And that gap? it’s killing you slowly

Every zero day is another broken promise to yourself

Another reason to believe you’re not the kind of person who follows through

I don’t know you. But I know what it’s like to feel stuck.

What I’m about to share actually worked for me. You can take it or leave it. You don’t owe me anything. But if even one piece of this lights something in you, use it.

That’s all I’m asking.

1/ No more zero days

A zero day is when you do absolutely nothing toward whatever it is you want

Nothing toward your goal, your dream, your project, your health, whatever matters to you

No more of those

This doesn’t mean you need to grind for eight hours every day

It means you need to do something

It’s 11:58 pm and you did nothing all day? write one sentence. Do one pushup. Read one page.

One is not zero

That’s the whole point

When you’re stuck in the spiral of feeling like garbage, your behavior keeps the spiral going

You don’t break out of that spiral by suddenly becoming a productivity machine

You break out with a long string of non-zero days

Small. Consistent. Non-zero.

That’s how patterns change.

That's rule number one. Do not forget.

2/ There are 3 versions of you

Past you. Present you. Future you.

Sounds like self-help nonsense until you actually use it

Here’s how it works:

Be grateful to past you for the good decisions, even the small ones

Went for a walk yesterday instead of sitting on the couch? thank you, past me

Saved a little money last month? thank you, past me

Had a non-zero day even when it was hard? thank you, past me

That gratitude matters more than you think

Now flip it around

Do favors for future you like you’d do for your best friend

Tired as hell and don’t want to get up? this one’s for future me

Don’t feel like finishing that thing you started? this one’s for future me

Present you will always want comfort

But future you needs present you to show up anyway

and when future you becomes present you and life is a little better because of those choices?

You thank past you

That cycle... gratitude backward, favors forward... it builds something

it builds a relationship with yourself where you actually start trusting yourself again

3/ Forgive yourself

FORGIVE YOURSELF.

I mean it.

Maybe you got all the know-how, money, ability, strength and talent to do whatever is you wanna do.

But lets say you still didn't do it.

Now you’re beating yourself up for not doing what you need to, to be who you want to.

Heads up champion, being disappointed in yourself causes you to be less productive.

Tried your best to have a nonzero day yesterday and it failed? so what. I forgive you previous self. I forgive you.

But today? Today is a nonzero masterpiece to the best of my ability for future self.

Yesterday is done. Today is for future you.

4/ Exercise and books

Exercise makes you smarter. It clears your mind. It gives you energy. It’s doing a massive favor for future you every single time.

Books are the shortcut nobody uses

Almost everything you’re struggling with, someone else has already figured out

They wrote it down

It’s sitting there waiting for you

Reading is how you skip levels

That’s it

Four rules:

• no more zero days

• gratitude to past you, favors for future you

• forgive yourself

• exercise and books

You don’t need a complex system

You don’t need an app or a framework or a dashboard

You need to do one thing today that isn’t zero

And then do it again tomorrow

Anyway, here’s my Spotify focus playlist

Go have fun 🍀

-Abi

Three years ago, I’d never posted a single carousel in my life.

Today, I’m reaching 100 million views a month and have grown to 2 million followers in what might be the hardest niche to crack on Instagram: tech.

My DMs are constantly full of people messaging me about my content. It’s not just because the information is valuable. It’s because of how it’s written.

What I’m about to break down won’t work for absolutely everyone. But it works for most people who are trying to build an audience that actually generates real business.

There are tons of ways to grow on this platform. My strategy is simple: post a shit ton of high-value carousels, consistently.

But here’s the first thing you need to understand: a brilliant insight doesn’t automatically turn into a great carousel.

I still post incredibly valuable stuff that completely flops. Sometimes because my writing wasn’t tight enough. Sometimes because the algorithm just decided to ignore me that day. It happens.

So what actually matters when you sit down to write?

1/ It needs to be genuinely valuable

This sounds painfully obvious but you can’t just regurgitate advice that’s been floating around for years

I see the same recycled tips everywhere... stuff said a thousand times and it won’t make anyone stop swiping

Trendy audio clips with zero substance mostly don’t work either, at least not the way most people try it

I’ve seen a few wizards turn that into a legitimate strategy but when i tried that route i just failed lol

You need to dig into your experience and pull out insights that are fresh

Things that haven’t been beaten to death across the platform

Ideas that could genuinely shift how someone approaches their work or thinks about their business

The difference between content that gets ignored and content that gets saved is whether you’re saying something new

Or at least saying something old in a way that makes people see it differently

Ask yourself before posting: would i save this if someone else made it?

If the answer is no, keep working on it

2/ It needs to be immediately actionable

An insight without a blueprint is basically entertainment, not education

I see carousels constantly like “this Instagram update is absolutely insane” with zero context or application

Maybe it gets views if you’re lucky... but it brings in almost no followers and definitely zero business opportunities

People don’t follow you because you noticed something, they follow you because you taught them how to use it

So if you’re writing about that Instagram update, don’t just point at it

Write “how to use Instagram’s new feature to double your reach:” and then walk through the actual process

Slide by slide, step by step, exactly how to implement it in their workflow

People will swipe through every single slide because you’re not just giving them information, you’re giving them a system

They’ll start thinking your account is worth following because every carousel teaches them something they can apply today

Not tomorrow, not eventually... right now

Do this consistently and some percentage of your followers will want to hire you because they’ve already seen proof you know what you’re talking about

The carousels become your portfolio

Examples:
- Post 1
- Post 2
- Post 3

3/ It needs to spark natural engagement

This is where most people mess up because they think engagement means begging for it “double tap if you agree” or “share this to your story if you found it helpful” just makes you look desperate

You want your carousel structured in a way that naturally creates comments and saves without asking

Saves happen automatically when your cover slide uses phrases like “here’s how” or “how to” or “do this”

Because you have maybe one second to stop someone mid-scroll and a ton of people operate on autopilot... they see something that looks useful, save it for later, keep scrolling

Your job is to make that first slide so clear and valuable that the save happens instinctively

For comments, you’ve got two main approaches and both work depending on your content:

First option is to push your opinion harder and take a clear controversial stance you could write “carousels outperform reels for building real followers, here’s the proof”

People will either argue with you or back you up in the comments, either way you’re getting engagement and your carousel is getting pushed to more people

Second option is to keep it slightly open and invite perspective “this is the carousel structure i’m using right now, curious if anyone’s tested a different approach”

This feels collaborative instead of combative, and people love sharing their own experiences when you give them an opening

Both strategies work, you just need to pick which one fits the content better

4/ It needs to be ridiculously easy to read

This seems super basic but it’s the difference between someone swiping through your whole carousel or bouncing after the first slide

Most people scroll through their feed at insane speeds, their eyes land on your cover slide for maybe one second before deciding whether to engage

If your design looks messy or your opening looks like a wall of text, they’re already gone

Your cover slide needs to be short and punchy, ideally one line that clearly signals what value you’re about to deliver

“how to X” or “why X doesn’t work” or “the X mistake you’re making”

After that, use one idea per slide whenever possible

This creates natural rhythm and makes everything way easier to process visually. Your brain can chunk information better when it’s not crammed into dense paragraphs

Throw in numbered steps or bullet points to organize complex information into digestible pieces

People can skim a slide and still grab the main points even if they don’t read every word

Also... white space matters

The space between your lines and sections gives people’s eyes a place to rest

Slides that are just solid blocks of text feel exhausting before you even start reading them

Then there’s your language, and this might be even easier if english isn’t your first language

Simplify everything as much as you possibly can

Aim for a conversational tone like you’re a mentor talking to students

Like you’re a smart person who deliberately chose simple words because you want to be understood, not because you want to sound impressive

Use “use” instead of “utilize”

Say “help” instead of “facilitate”

Write “get better” instead of “optimize performance”

The goal is that someone who knows absolutely nothing about your field could still follow what you’re saying

If your 14-year-old cousin couldn’t understand your carousel, it’s probably too complex

Dumb it down until it feels almost too simple, then stop there

5/ You need to develop your own recognizable style

When I scroll through my feed iIsee the exact same content written in the exact same style everywhere

Same hooks, same templates, same fonts, same voice

It all blends together into this generic AI-sounding content soup

But when someone has a carousel style i can identify instantly, a design and voice that screams “this is them”... i stop scrolling completely

I swipe through the entire thing because i know it won’t sound like everything else

Your style is what makes people remember you

Maybe you always use a specific color palette

Maybe you start most carousels with a question pattern

Maybe you write in fragments sometimes for emphasis

Maybe you use “tbh” or “honestly” when you’re about to drop a controversial take

Maybe you always end with the same type of CTA slide

These little patterns become your signature, and people start recognizing your carousels before they even see your name

The key is consistency without being formulaic

You want patterns people can recognize, but you don’t want every carousel to feel like you’re filling in a template

Find 3-4 structural and visual elements that feel natural to you and use them frequently

But mix up the order, change the context, adapt them to different topics

Your style should feel like you, not like you’re following a script

And when you nail all of this consistently...

You build an audience that respects your ideas, not just your follower count

People stop scrolling when they see your cover slide because they know you’re about to teach them something useful

Your carousels pull people to your profile because every single one delivers clear insights with actionable steps

Not vague advice, not motivational fluff, but systems they can implement

And when you’re ready to sell your services or products, the conversion becomes natural

Because you’ve been proving your expertise in public for months

They’ve already experienced your teaching style through your carousels

Hiring you or buying from you just feels like the logical next step

That’s the real power of writing carousels that don’t just get engagement... but build genuine followers who trust you

This applies to any format of content you write

Carousels, threads, long-form articles, newsletters... the principles are exactly the same

I’m using it to grow on Substack too

I just started writing articles 3 days ago and already got my first hit

Read it here: https://substack.com/home/post/p-183756184

All of the lessons above are applied there

Straight up value, walking you through the exact process of how to erase your digital footprints from the internet

Step by step, no fluff, just actionable systems you can implement immediately

It got nearly 2k likes.

Same formula: genuinely valuable insight + clear actionable steps + easy to read structure

The platform changes but the writing principles don’t

Now i’m not gonna lie... this is not easy, because this level of content requires so much research and structure and edits

But what’s the point of sharing content just for the sake of posting?

Why not have the intention of genuinely helping people?

Whatever field you have expertise in... or at least a field you’re willing to spend the hours going deep on

Come up with something that can actually help people who don’t have the time to do that research themselves. That’s the whole point

You put in the work so they don’t have to

You spend 10 hours researching so they can learn it in 3 minutes

That’s real value

And people feel the difference between content made to post and content made to help

One gets scrolled past, the other gets saved and shared

Choose which one you want to be known for

– Abi

The “vibe coding” thing people keep joking about is just the visible tip of something much bigger.

I spent the last two weeks building apps that I always wished existed.

From chord progression designers to screen recorders.

We are going into an era where every app will be built on demand. Buying software makes sense if it's solving a problem that cannot be generated.

If your problem can be generated and you’re still waiting for a company to solve it, you’re already behind.

This is me catching you up — with Claude Code.

Why claude

I’ve tried everything at this point. Chatgpt, cursor, copilot, gemini, all of it

They all work. But Claude is the only one I actually use now for building things, not because it writes better code (sometimes the others write better code honestly)

It’s because Claude asks instead of assumes

With chatgpt i’d prompt something and it would just... do it. Even if my prompt was unclear or I was asking for something that didn’t make sense. It would confidently give me something and let me figure out later that it was wrong

Claude does this thing: “just to clarify, do you want X or Y?” or “i’m assuming you want Z, is that right?”

Seems tiny but it changes everything when you don’t know what you’re doing. Those clarifying questions have saved me hours of debugging code that was solving the wrong problem.

The other thing is Claude explains what it’s doing without me asking. I’ll get the code and then a paragraph explaining why it made certain choices. Chatgpt just gives you the code and moves on.

For someone who’s actually trying to learn while building, that context matters. I’ve picked up more programming concepts from Claude’s explanations than from any tutorial i’ve tried.

1: The core mechanics

To control the machine, you must understand the machine. Claude operates on a strict 4-step loop:

• Receives Task: (e.g., “Fix the bug”).

• Gathers Context: It reads files to understand the codebase.

• Formulates Plan: It decides on a strategy.

• Takes Action: It updates files and runs tests.

The Lesson: Claude’s superpower isn’t IQ; it’s the ability to chain tools together. The model cannot “see” your computer; it relies on the Assistant to append instructions and execute formatted responses.

2: Context engineering

If you dump a massive codebase into the chat, the model degrades. You need Context Management.

The Map (/init): Run this once. It analyses your architecture and builds a Claude.md file, a map of your project’s soul. Critical Detail: The contents of this file are included in every single request. Keep it lean.

The 3-Layer Memory:

• Project Level: Shared instructions committed to the repo.

• Local Level: Your personal instructions (ignored by git).

• Machine Level: Global instructions for you across all projects.

The Laser (@): Don’t let it guess. Use @database_schema to force it to look at the exact file you need. This saves tokens and increases accuracy.

3: Two brains strategy

Claude has two distinct high-performance modes. Knowing when to use which is the difference between a bug fix and a system architecture. Note that both consume additional tokens so use them wisely.

• Mode A: Planning (Shift + Tab x2)

You use this when: You need Breadth (e.g., “Refactor this module across 10 files”).

What does it do? It halts execution to research the codebase and write a detailed implementation plan before touching a single line of code.

• Mode B: Thinking (”Ultra think”)

You use this when: You need Depth (e.g., “Why is this race condition happening?”).

What does it do? It gives Claude an extended “reasoning budget” to solve hard logic puzzles or debug specific issues.

Pro Tip: Paste screenshots to give it visual context on UI bugs. Note: Use Control-V (not Command-V), even on macOS.

4: Utilising the panic buttons

When the AI starts hallucinating, do not argue with it. Control the timeline.

• The Stop (Escape): Interrupts the output immediately.

• The Correction (Escape + Memory): Don’t just stop it; teach it. Pressing this allows you to add a memory (using #) about the mistake so it doesn’t repeat it next time.

• The Rewind (Double Escape): This is your time machine. It lets you jump back to before the mistake happened, erasing the bad context entirely.

• The Compact (/compact): If the conversation gets too long, this summarises the history while keeping the lessons learned, clearing out the clutter.

5: Utilising hooks (guardrails)

Stop fixing Claude’s mistakes manually. Automate the feedback loop using Hooks defined in your .clod/settings.local.json.

The “Security Guard” (Pre-Hook):

• Problem: Claude tries to read your sensitive .env file.

• Fix: A pre-hook that monitors the read or grep tools. If the path includes .env, your script exits with Code 2.

• The Feedback: You must print the error to stderr. This isn’t just a log; it is fed back to Claude, forcing it to recognise the block and change its strategy.

The “Type-Safety” Loop (Post-Hook):

• Problem: Claude edits a file but breaks the build.

• Fix: A post-hook that runs tsc --no-emit after every edit. If errors are found, they are fed back to Claude instantly so it can self-correct.

The “Anti-Bloat” System:

• Problem: Claude creates duplicate code.

• Fix: A hook that watches specific folders and spins up a secondary Claude instance to check for duplicates before committing.

6: Going god mode

This is where you leave 99% of developers behind.

Custom Commands: Stop typing repetitive prompts. Create a markdown file in .Claude/commands/ (e.g.,audit.md). Now, typing /audit runs that complex dependency check instantly.

Give it Hands (MCP): Plug in external tools using the Model Context Protocol. Run claude mcp add [name] to install servers like Playwright. Now Claude can open a real browser, click buttons, and fix CSS based on what it sees.

Security Note: You can auto-approve tools in your settings to speed up the workflow.

7: Scaling it

Stop waiting for humans to review your code.

GitHub Integration: Install the Claude App. It will now auto-review every Pull Request for bugs and security risks.

Architecture: It runs inside GitHub Actions. You can even add Custom Instructions in .github/workflows to teach it your team’s specific coding standards.

The SDK: Want to build pipelines? Import the Claude Code SDK into your Python or TypeScript scripts to embed this intelligence directly into your CI/CD workflow.

What’s actually possible now

Here’s the part that still surprises me

I’ve talked to actual engineers (people with years of experience), people who understand things i can’t even comprehend and some of them are shipping less than people who started vibe coding 6 months ago

Because they think in constraints. They see a problem and think “that would take three months to build properly” meanwhile some person with zero technical background just describes what they want and has a working prototype by Tuesday.

The market doesn’t care about your credentials or your experience. It cares about what you can deliver and right now, a person who thinks clearly and iterates fast can outship someone with a CS degree who’s worried about doing things the right way

I’m not saying vibe coders are better than engineers. We’re not. For anything complex or mission-critical you need someone who actually understands what’s happening under the hood but for the other 80% of things? the internal tools, the automations, the simple products, the workflows? you don’t need an engineering degree anymore. you need clarity and patience

Now find ideas, and go build them.

I just wanted to show a very simple process to get you started, to make you realize that it’s actually as simple as many are saying.

So I hope you go try it out! There’s nothing else that you need for this.

At best, you create something crazy.

At worst, you learn an incredibly productive skill not be left behind.

-Abi

No introduction needed, let’s get started.

Step 1: Preliminary Requirements

Go through each email you can think of that you've used in the past 10 years.

You'll want to recover them if you've lost access, so that you can access other websites you may have signed up to using them.

Step 2: Deleting old accounts from forgotten services

Deleting old accounts from forgotten services

Use the search function on your e-mail and look for phrases such as "Sign up" or "Welcome"

Recover account and login into each service that pops up (that you received a sign-up email) from

Step 2b:

Now look around the service for a delete account function, google around by searching ``"delete account" + "<service>"

If there isn't one, google or look around for a support e-mail to request for them to delete your account.

Step 2c:

For some services, you may want to purge all content and messages before you delete the account, as the account may be archived and a hacker or external entity may access this information at a later date.

That's something to bare in mind.

Step 3: Checking if your information has been compromised already.

Now you should have a list of all your usernames and all the services, ranging from streaming services to e-mails.

You need to use something called boolean searches to properly use Google to locate this info

Step 3b:

I'll be using ``s to denote normal quotations, as you will need to use the normal "" signs to perform these searches.

You need to google your account name

"<account_name>"

Sometimes maybe your account name + password like so:

"<account>" + "<password>"

Step 3c:

You should see possibly pastebin links or underground databases publicly accessible on the internet, or possibly leaked private information.

This is normal. It happens to a lot of services.

Note down what passwords/information was compromised.

Step 3d:

Some database leaks are a bit more private and are still being shared/sold in private circles, but you can use this website:

haveibeenpwned.com

To check if you’ve been compromised, so you can change your live information to be different..

Step 4: Removing yourself from Google.

So now you’ve deleted your Facebook accounts, but when you google your name and location using boolean searches, there is cached information/links about yourself.

There is a solution for that, called the Google Console.

Step 4b:

You can use Google Console at:

https://google.com/webmasters/tools/removals

You can request for them to delete/update their search engine (which usually takes months organically) to remove those cached results if you provide a link to each.

Go through various google searches and do this

Step 5: Protecting yourself against Google legally tracking you (for the most part).

You should be disallowing Google to legally touch any of your data

Here you can go through each of Google’s services: https://myaccount.google.com/activitycontrols

Step 5b:

Protecting yourself against other services

Any other services you wish to use, you need to strip down the privacy settings to the absolute core.

If you want to use Facebook, make sure you make it almost entirely private, so people can't access private photos.

Step 6: Deleting old e-mails

Now you've just access to your old e-mails, it's time to delete them too.

Delete any e-mails you no longer need access to

DO NOT DELETE E-MAILS YOU MAY NEED IN THE FUTURE.

If you do need them, change security questions and password.

Step 7: Securing accounts

You should be REGULARLY changing your passwords on services every 6 months

Why?

Because new hackers gain access to new databases daily, and they'll start using that information to bruce force, or in the future, to personally attack you.

Step 7b:

Do NOT use any passwords similar to each other.

Hackers are smart. Especially when it's a personal attack.

They will easily combine your old passwords with your home address, or date of birth to accomplish finding your password to something they need.

Once they are in, some services will give them access to EVERYTHING and it's damn near impossible to get them out after they are in.

Good news is a lot of services are updating this, so that you can only have one session active at once.

Before you never knew who was in.

Step 8: PROTECTING your internet connection.

You should be using a VPN when using the internet.

DO NOT use a VPN when dealing with banking services or anything confidential, but do use it when publicly surfing the internet.

Using DuckDuckGo in combination with this will help

Step 8b:

Using a VPN that has no logs.

You need to make sure your VPN has had a PUBLIC audit to ensure that it has NO LOGS.

this means that it has no record of what you have used their internet connection for.

And when you use a VPN, it's hard for your ISP to know either.

Step 9: USING Burner accounts

You should be using burner accounts on known intrusive services such as Google by using a fake name and information.

This is LEGAL and you should do it to avoid having your information data mined across services.

Step 10: REGULARLY deleting your internet content.

You should be regularly deleting your tweets and old photos.

This data can be used against you to cross-reference your accounts and find more personal information.

Hackers will find a target and analyze them for months.

Step 10b:

Hackers will use your old internet information to do some of this analyzing in retrospect to piece together who your social circle is to find a vulnerability.

Anyone can be attacked. You just haven't been a target yet.

Defend yourself through prevention.

Step 10c:

Don’t believe me?

https://theverge.com/2019/10/11/20910551/stalker-attacked-pop-idol-reflection-pupils-selfies-videos-photos-google-street-view-japan

This is nothing. Very simple with the tools EVERYONE has access to today.

Final note:

In general, this is a very good checklist. There’s still a ton of stuff this won’t scrub, but it’s a good start.

The next step is to begin introducing false information that’s somewhat similar to yours. This results in any data analysis being unable to generate strong clusters of your legitimate information. Creating personas with the same name as you but different locations/ages/etc. Helps here.

Also, ask credit agencies to scrub all information about you more than 5 years old.

Also, remember to scrub all account emails from your online mailboxes, as this is also an easy way for an identity thief to recreate your identity or phish you at some later date.

Hope this helps.

Introduction

I am not a programmer supremacist.
I don’t believe code is magic.
I don’t think learning Python will save your soul.

But I am increasingly convinced that most people trying to “learn AI” are starting at exactly the wrong place and are paying for it with years of confusion, cargo-cult knowledge, and false confidence.

People open a reinforcement learning paper.
They watch a Karpathy talk.
They paste something into ChatGPT.
And then they realize that they don’t actually know what’s happening.

This is the prequel.
Start here if:

• you don’t know how to program

• you don’t know machine learning

• or you started reading the main article and felt that sinking “I should understand this but I don’t” feeling

If that’s you, good.
You’re early enough to avoid years of unlearning.

The First Lie: “I Know How to Code”

Having a PhD in AI does not mean you can program.
Having access to an LLM does not mean you can program.

Believing either of those is usually a negative signal.

Programming is harder than AI.
Not because it’s more complex but because it’s less forgiving.

Most researchers are bad programmers.
Most great programmers become competent researchers surprisingly fast.

I learned this the wrong way around.

Programming looks simple because it is simple.
But simple does not mean easy.

The real difficulty is that programming is almost always taught in a way that rewards cleverness instead of correctness. You’re trained to over-abstract, over-generalize, and over-engineer long before you understand the problem you’re trying to solve.

Unlearning this takes years.

If you’re brand new, you’re lucky. You don’t yet have bad instincts.

If you’re not new, you need to make a decision right now:
that your entire mental model of “good code” might be wrong.

Not flawed.
Wrong.

What Programming Actually Is

Programming is writing instructions that operate on data.

That’s it.

The instruction set is embarrassingly small:

• assign data to variables

• evaluate conditions

• loop

• group instructions into functions

You can learn the tools in a weekend.
You will spend a lifetime learning how to use them well.

This is why programming skill is not linear.

• a bad programmer creates problems

• a good programmer solves problems

• a great programmer removes entire classes of problems

The distance between those is not talent.
It’s taste.

Enough philosophy.
Here’s how to actually learn.

Learn Programming Like an Adult

1. Learn by Doing, Immediately

Start with something that takes hours.
Then days.

Games are excellent because failure is visible. The screen goes black. The character doesn’t move. The bug humiliates you in public.

Use raylib. It’s boring in the best possible way. Lightweight, opinionated, and written by people who clearly care about simplicity.

If a tool feels exciting, it’s probably stealing your attention.

2. Start With Python (But Don’t Linger)

Yes, many experienced developers hate Python.
Yes, they’re often right.

Start with it anyway.

Python removes friction so you can focus on logic instead of ceremony. Almost every AI system you’ll touch has Python at the top layer.

But here’s the important part: don’t stay.

Python’s design nudges you toward laziness if you’re not careful. Avoid:

• heavy external packages

• inheritance hierarchies

• decorators

• clever tricks

Force yourself to express everything as:

• assignments

• conditions

• loops

• functions

Build a few small things.
Then leave.

3. Learn C Early (Not First)

C is honest.

Painfully honest.

It forces you to confront what the machine is actually doing instead of hiding it behind abstractions.

You should understand:

• types and casts

• memory allocation

• stack vs heap

• pointers

• compilation and linking

This is why I don’t recommend C first. It demands too much context at once.

But learning it early rewires your brain permanently.

Avoid C++ for now. It’s C plus decades of accumulated mistakes.

4. Avoid Abstraction Like the Plague

Solve the problem you have.
Not the problem you’re fantasizing about.

Abstraction is seductive because it feels like intelligence. In reality, it’s often fear disguised as foresight.

C helps because it removes temptation.
No inheritance.
No magic.

Just you and the problem.

5. Use Git or Lose Your Mind

Make GitHub repos by default.
Commit often.

This is how you:

• don’t lose work

• understand your own mistakes

• stop being afraid of breaking things

Version history is psychological safety.

6. Use a Debugger

Print statements are for emergencies.

A debugger lets you:

• pause time

• inspect reality

• stop guessing

Use pdb for Python.
gdb + address sanitizers for C.

7. Learn Basic Unix Tooling

The terminal is not optional.

You need maybe ten commands:

ls, cd, cat, mv, cp, mkdir, top, pwd, head

Linux is best.
macOS is fine.
Windows requires WSL.

Do not obsess over customization. You’re learning to think, not to decorate your environment.

8. Don’t Get Nerd-Sniped

Avoid:

• dogmatic OOP and FP

• test-driven development as religion

• language hopping

• distro hopping

• Python type hints

• build systems rabbit holes

• modern web frameworks

• “best practices” discourse

• the new hot thing on X

9. Don’t Learn Programming via LeetCode

LeetCode trains interview performance, not programming.

Yes, learn basic data structures.
No, mastering dynamic programming won’t make you effective.

Projects matter.
Shipping matters.

10. IDEs Don’t Matter

Your editor is not your skill.

Use something boring.
Run code from the terminal.

Avoid AI-first editors until you can think without them.

Autocomplete is fine.

How to Learn Machine Learning (After You Can Code)

Becoming a competent researcher is easier than becoming a good programmer.

This is why most researchers are terrible programmers.

If you reverse the order, everything improves.

Unlike programming, ML education is actually decent.

Do CS231n.
Watch Karpathy or Johnson.
Do the problem sets.

Yes, all of them.

You need:

• matrices

• partial derivatives

That’s it.

Once you finish, you’ll understand:

• backprop

• autograd

• PyTorch

Reading Papers Without Losing Your Sanity

Start reading papers.

You will feel stupid.
That’s normal.

Most papers are written under constraints you need to understand:

• page limits

• reviewer incentives

• GPU scarcity

• deadline panic

This explains:

• unnecessary math

• missing ablations

• weak baselines

• contradictory results

The strongest signal is:

• open code

• multiple replications

• real usage

Even then, trust cautiously.

How Good Researchers Actually Think

Assume the paper is wrong.
Look for cracks.

Ask:

• are controls weak?

• are conclusions overfitted?

• are assumptions shared by everyone in the area?

The biggest opportunities appear when an entire subfield is wrong in the same way.

Progress comes from pattern recognition plus skepticism.

Conclusion

If you want to work on AI, don’t start with AI.

Start with programming.
Real programming.
Boring programming.

Most people are building castles on sand and wondering why they collapse.

Learn to think clearly.
The rest compounds.

It’s called “Semantic Collapse”, and it happens the moment your knowledge base hits critical mass.

Here’s the brutal math (and why your RAG system is already dying):

The problem is simple but devastating.

Every document you add to RAG gets converted to a high-dimensional embedding vector (typically 768-1536 dimensions).

Past ~10,000 documents, these vectors start behaving like random noise.

Your "semantic search" becomes a coin flip.

This is the Curse of Dimensionality rearing its ugly head.

In high-dimensional spaces, ALL points become equidistant from each other.

That "relevant" document? Same cosine similarity as 50 irrelevant ones.

Your retrieval just became a lottery.

Stanford's findings are brutal:

→ 87% precision drop at 50k+ documents
→ Semantic search worse than keyword search at scale
→ Adding more context makes hallucination WORSE, not better

We thought RAG solved hallucinations. It just hid them behind math.

Here's what's actually happening:

Your embedding model projects documents into 768D space. At small scale, semantically similar docs cluster together. Perfect.

But add enough documents and the space fills up. Clusters overlap. Distances compress. Everything looks "relevant."

The math is unforgiving:

Volume of a hypersphere concentrates at its surface as dimensions increase.

Translation: In 1000D space, 99.9% of your corpus lives on the outer shell, equidistant from any query.

Your “nearest neighbor search” finds... everyone.

Real-world impact:

- Enterprise RAG systems hallucinate MORE than base models
- Legal AI citing wrong precedents at scale
- Medical RAG mixing patient contexts
- Customer support bots pulling random articles

All because retrieval stopped working past 10k docs.

The current “solutions” are bandaids:

→ Re-ranking (adds latency, still noisy)
→ Hybrid search (keyword + semantic, marginally better)
→ Chunking strategies (delays the problem)

None address the core issue: embeddings don’t scale.

What actually works:

Hierarchical retrieval with compression. Instead of flat embedding space, build a tree structure with progressive summarization.

Think: Encyclopedia → Chapter → Section → Paragraph

Reduces search space from 50k to ~200 at each hop.

Or the nuclear option: graph-based retrieval.

Model documents as nodes with explicit relationships. Query traverses edges instead of embedding space.

More complex. Way more effective. What next-gen RAG will look like.

If you’re building on RAG today:

→ Benchmark retrieval quality at YOUR scale
→ Don’t trust vendor claims about “unlimited knowledge”
→ Implement hierarchical retrieval NOW
→ Monitor precision/recall, not just “it returned something”

Semantic collapse is real.

Thanks for reading!
Enjoy the rest of your day.

Everyone does this, and it’s taken to be the default because it’s easy. You can send the same resume with the click of a button to totally different companies, with no effort on your part other than preparing the resume.

There’s no way to stand out, no uniqueness.

Generally, the way to get around this is to ask for a referral or to reach out to someone at the company for some sort of informational interview. Both of these methods allow for a more personalized approach to job hunting.

But is it possible to go even one step further?

Stand Out

In 2016, Chris Seline was coming off a failed startup and looking for new opportunities.

Unlike most other people, though, Chris wasn’t a fan of the resume blast method.

His strategy was to target specific companies and try to get noticed creatively rather than use the traditional channels and get lost in the shuffle.

Chris decided that he really wanted to work for Reddit.

He planned to write a blog post and then email it to the CEO of Reddit.

The blog post is thorough - it’s 2000 words, technical, and you can tell a lot of effort was put into it.

Even if Chris had emailed his post to the Reddit CEO, there’s a strong chance he would have gotten an interview. 99% of applicants don’t put this much effort into an application, and receiving such a personalized email is a positive signal.

But Chris didn’t just email him.

Facebook Ads

He decided to use Facebook Ads to target the CEO of Reddit (Steve Huffman).

Here’s how he did it:

1. Find the Reddit CEO’s public Facebook profile

2. Use this to find out where he lived, what he liked, what he was interested in, etc

3. Use the above to run a super-targeted FB Ads Campaign

Note that Chris only wanted one person to click on this Ad, that’s why he had to go super targeted.

The Result

Chris ended up spending $10. The ad reached 197 people. 4 People clicked on it. One of them was the CEO of Reddit.

Next thing you know, Reddit HR reached out to schedule an interview. Nicely done.

I contacted Chris to find out if he actually got the job - here’s what he said:

I did not. It turns out they were just starting a search for “head of search” at Reddit, and asked if I would like to interview for that job. That would have been my dream job, and definitely worth a move across the country, even with 3 kids and a wife in tow (I live in DC), so naturally I was very excited and said yes. But after a few talks, they thought I didn’t have enough experience with big companies, so they asked if I would be interested in an IC role. I was, but I wasn’t willing to move across the country for that, and they didn’t want to hire remote workers. So that was that.

Chris Seline

Takeaway

The reason this is a fun story is due to the Facebook Ads.

However, I think what people may overlook is the amount of time and research Chris invested in writing the blog post that he eventually showed to the Reddit CEO.

If we go back to the beginning of this case study, notice how I mentioned that just blasting a resume to a company signals nothing unique and frankly a lack of effort.

A good way to resolve problems is to invert them - if we do that here, we get the following:

Chris’s blog post was well researched, relevant, and made him stand out. The FB Ads targeting was just the cherry on top.

Next time you see a job you really want to get, think about how you can go that one step further.

Thanks for reading!

​