Three steps to get 80% of the value out of AI

1. Basics

Use Claude or ChatGPT. I use Claude so I’ll use Anthropic-branded names like “Claude” to refer to AI in general. While Gemini is pretty good for questions with an objective answer, for agentic tasks or open-ended questions it is pretty terrible compared to the other two. Also, its personality is really annoying, and Google keeps adding useless minor features which make it even more annoying. So I don’t recommend Gemini unless you need video generation.

For Claude, start with the $100 plan (Claude Max 5x).

“$100 per month for a subscription is ridiculous. I’m not paying that.”

If you are actually incapable of paying that because of financial difficulties, then unfortunately you will not be able to get close to 80% of the value that AI currently offers. That being said, there is still useful information here which would help you get more value, and you can still accomplish much more with AI than you can without.

Regardless of your financial situation, one or more of these may apply to you:

If none of these apply to you, then it’s probably not worth reading any of this, whether you’re impoverished or a billionaire. Otherwise, if any of those do apply to you and you are not experiencing financial difficulties, by choosing to not pay $100 for just one month, you would be intentionally:

  1. Restricting yourself from AI which can help you accomplish an order of magnitude more than the next best subscription tier.
  2. Refusing to gain experience with relevant AI systems during an age where AI is the beacon of technological progress and becoming integrated into almost every workflow. In other words, indefinitely delaying the compound interest on your productivity, learning, and awareness of technology, which will translate into less financial gain in the future. More importantly, it will limit your long-term achievement and professional fulfillment.
  3. Enforcing a psychological barrier on experimenting and trying to push AI to the limit because you know you have very limited usage, which will indefinitely reinforce the baseless conclusion that AI is actually not that useful.
  4. Agreeing to continue wasting time on tedious tasks which give you no fulfillment and make your life worse.
  5. Missing out on a lot of fun.

And all this to save $100, which, for someone not experiencing financial difficulties, is not a lot of money. I highly doubt that in one year you’re going to look back and regret spending $100 to experiment with the most revolutionary technology of at least the last decade, even if you find that it wasn’t useful for you.

From now on I’ll assume that you did spend the $100, but even if you didn’t, you’ll probably find some of this info useful.

With that out of the way: for short conversations/questions which don’t require the AI to call any tools except a simple web search, use the regular app. For anything else, use the terminal CLI version of Claude Code (“CC” for short). It has to be CC because that’s the version of Claude that can directly interact with your computer, run commands, and write/run programs to help you do all kinds of tasks. It is called Claude Code but it should really be called Claude Everything.

Why use the terminal version instead of the app version? The terminal is intimidating, ugly, has no graphical user interface, etc., so why not just use the pretty app? Because the app version of CC is built on top of the functionality of the terminal version, which means it sits a layer above what’s actually going on. This is bad because:

So, just choose the CLI, and you’ll be done with step 1.

2. ASK

Now you’ve spent $100, you’ve opened the terminal, you’ve realized you have no idea what to use CC for, and you hate me because I convinced you to waste your money. Just relax for a moment.

One concrete, really helpful thing you can do if you’re lost is to go about your day as you would if CC didn’t exist and note down everything you do. When you’re done, dump it all into CC and say “here’s what I did today. Can you help me with any of this?” But this isn’t even the key of this step. What you really need to do is get into a certain mindset. That mindset is to just ask Claude.

To elaborate, there are two kinds of tasks to do on a computer. The first is the kind that you want to be doing. For example, a task that I enjoy doing is writing a blog post. There are also tasks that you don’t want to be doing. Here are my personal examples of the latter:

For the kinds of tasks that you don’t want to do, before starting the task, ask CC if it can help you. It will say “yes” or “no”.

If it says “no”, you want to say, “Come on. It’s 2026 and you’re a terminal agent with access to all the knowledge on the internet and any programmatic tool on this computer. I think you can help a lot more.” Literally copy and paste that in. Then, it will either say: “You’re absolutely right!” or it will still say “No”. If it says “No” again, congratulations. You have just improved your sense of what CC can and can’t do. Repeat 100 times and you will develop a good intuition for the kinds of tasks to delegate to CC.

There will also be times that it says it can do something but actually it does it really badly. That’s ok — this still improves your intuition, and doesn’t mean you should stop asking. Before doing anything manually on your computer, ask CC if it can do it for you. You’ll be surprised at the kinds of things it can help with.

I could’ve ended this section here, but usually when I give people this advice I see them 10 minutes later clicking around on their computer throwing away valuable minutes or hours of their life completely unnecessarily. I hate seeing people waste their life, so I will try to reinforce the point.

Pretend you are a kindergartener. You just walked into a class on the first day of school. You’re the first one there, but as the minutes go by the class starts filling up. Except the people sitting down around you are big, scary teenagers. The professor has also walked in and is preparing equations on the chalkboard before class — he’s writing symbols on the board that you’ve never seen, and you hear someone mention “calculus”.

You have two choices:

  1. Approach the professor and politely ask him if you’re in the right class, saying that you might be lost.
  2. Walk up to the professor, spit in his face, tell him he’s stupid, wipe away everything he painstakingly set up on the board, scrawl “2+2=4” on it, walk to the door, and let out a fart before ultimately making your exit.

All the time, I see people making the second choice. Please don’t do that. Assume that you know nothing, and just ask Claude. Here are some (exaggerated but useful) examples to illustrate what I mean by “just ask Claude”:

The point is: just ask.

Note: This does not mean that CC should do your thinking for you in domains that you want to be good at, are inherently interested in, or will benefit you to think about in the long-term. I’ve searched far and wide and I haven’t found anyone that wants to be good at making slideshows, so I’m using that as an example.

3. Compound interest

If you structure and preserve information on your computer such that AI can repeatedly refer to it, you tap into the compound interest on AI’s capability, because it’ll gain more and more context about you. This means you can spend less time typing in prompts into a chatbox to explain what you’re trying to accomplish.

One great way to do this is to have structured information dumps (a folder) for the different things you think about and work on. If you need to do well on an upcoming exam, you can have an information dump of all the content from that class and tell CC to structure a study plan. If you’re looking for jobs, you can have an information dump including your resume, career preferences, and all the things you’ve done in the past. It can then seek out jobs for you, build you a resume, and do a million other things which are really useful.

To build a structured information dump, throw as much context as possible into CC and then say: “Make a structured folder with all this info such that you can easily navigate and refer to it later.” As soon as you need to work on something related to that information dump, you can cd into that directory (ask Claude if you don’t know what “cd” means) and dive right in.

Another great way to tap into this kind of compound interest is skills. CC has a skills folder which contains individual or grouped files. These files can either be textual files containing instructions for workflows, or programs which it can execute to aid the completion of a workflow. That’s pretty much all you need to know, because CC can create, read, update, and delete them on its own. You don’t have to touch them yourself.

There are two great methods for creating a skill:

  1. Send a bunch of unstructured, scattered instructions to Claude and tell it to make a structured skill for itself out of it. If you want to read it yourself to make sure it has the right instructions, just say: “Open the skill for me on my computer so I can read it.”
  2. Go through a workflow with CC once without a skill, giving it feedback on how it could’ve done better along the way. When you’re done, tell it to review what it did, along with your feedback, in order to create a skill to capture that workflow for future usage. I actually made a skill for this (a skill for creating skills) called /skillify. You can read or copy the whole thing below.
the full skillify skill
---
name: skillify
description: Use when the user has just worked through a non-trivial collaborative workflow and wants to package it as a reusable Claude skill
---

# Skillify

## Overview

Captures the workflow we just completed and packages it as a `SKILL.md` saved to `~/.claude/skills/<name>/`. The user owns the workflow; you own its translation into a durable, opinionated skill file.

## Principles

### Inventory before interviewing

**Read the conversation first, then ask.** Scan for: rules the user surfaced (corrections + validations), sources consulted, artifacts touched, anti-patterns hit, workflow steps in order, and before/after examples worth preserving. Most of what belongs in the skill is already in the conversation — asking about things you can infer wastes the user's time.

### Distinguish durable rules from one-off choices

**Not every decision belongs in the skill.** A one-off choice ("use 2.8M because the file has 2.86M rows") is not a rule. A durable rule is what generalizes ("verify every quantitative claim against source"). Only durable rules go in the skill body. One-off choices live inside worked examples.

### Anti-patterns are load-bearing

**Capture what NOT to do, not just what to do.** Pushback is signal. If the user said "this is a nothing burger" or "don't pad with vanity counts," that's a rule worth bottling. Most skills omit failure modes; ours shouldn't.

### Concrete examples next to abstract patterns

**Always include both.** Abstract rules without examples don't transfer. Pull 1–2 before/after pairs directly from the source session and embed them.

### Offer options, don't dictate

**Generated skills should present user choices, not edicts.** If the workflow involves iteration on subjective output (bullets, prose, code), bake "offer 2–3 options with one recommended pick" into the generated skill.

### Verify before recommending

**If a generated skill references files, paths, numbers, or external data, the skill must instruct verification.** Tell the generated skill to read source files and re-check counts.

## The Cycle

1. **Inventory** — scan the current conversation. Output a brief summary: rules surfaced, sources consulted, artifacts touched, anti-patterns hit, workflow steps observed, examples worth preserving. No questions yet.
2. **Interview** — ask only what you genuinely cannot infer. Likely gaps: skill name (propose 2–3 candidates), invocation triggers, anchor files/URLs, scope (project-specific vs general). Skip questions whose answers are obvious.
3. **Draft** — produce a `SKILL.md` following the template below. Show it before saving.
4. **Iterate** — accept revisions; user picks from options where applicable.
5. **Install** — write the final draft to `~/.claude/skills/<name>/SKILL.md`. Confirm the path.

## Generated-skill template

```
---
name: <name>
description: Use when <trigger condition>
---

# <Title>

## Overview
## Anchor sources       (files/URLs/repos to read at start, if any)
## Inputs               (what user provides at invocation, if any)
## Principles           (bold lead + paragraph)
## The Cycle / Workflow (ordered steps)
## Hard Rules
## Anti-patterns        (table or list)
## Examples             (1–2 before/after pairs from the source session)
```

Use only the sections the workflow demands.

## Hard Rules

- **No drafting before inventory.** Skipping this step misses durable rules.
- **No question the conversation already answered.** Re-read first.
- **No skill without anti-patterns.** If the session had pushback, capture it; if not, ask the user for failure modes to avoid.
- **No skill without at least one concrete example.** Abstract rules alone don't transfer.

## Common Mistakes

| Mistake | Fix |
|---|---|
| Transcribing the session verbatim | Distill — keep durable rules, drop one-offs |
| Asking the user for things in the conversation | Read first, ask only the gaps |
| Skipping anti-patterns because "it went well" | Pushback is signal — capture every correction |
| Single-take output with no choice | Present 2–3 options where iteration matters |
| Vanity-count rules ("must do X 5 times") | Rules are about kind, not count |

To tell Claude to use a skill, just type “/name-of-skill” and send that on its own. You can also continue typing to add instructions specific to what you want to do right now.

Bonus

Use Wispr Flow so you can talk out loud and have that converted to text which you can instantly send to CC. It’s much easier to communicate to Claude this way, and is especially useful if you’re not a really fast typer. You can also use macOS’s dictation feature for free (if you have a Mac), but it’s worse at transcribing your speech.