I don’t know the full answer.

But I know how to build.

So I can give you the recipe for building a $60K MRR company.

And I am not just going to say it.

I used TrustMRR to find a company that does $60K MRR.

I examined it first, then built a version with Claude Code in a couple of hours.

Sounds like a stretch.

It is the truth, and I am going to hand you the reverse engineering pipeline.

What is the reverse engineering pipeline?

Mine is five steps. I used it on both of my clients and on myself.

Most of my clients chase their rivals too closely.

I have spent hours on their competitors’ websites, taking notes on every feature, then turned back and built what they had.

This reverse engineering pipeline works for any business you want.

Even one that is not your rival, even one you just want to use for free.

Five steps.

Now, let me show you what I built and how I did it.

What I built with Claude Code and NotebookLM

I’ve built an SEO agent, using three tools.

TrustMRR to find it, NotebookLM to dissect it, Claude to rebuild it.

I pasted “trustmrr ai startups.” to Google and head to here.

Next, I liked the SEO bot and clicked on it.

It generated 1.7M$ by far and currently $60K MRR.

Here is what it looks like.

And here is what mine looks like.

Not the full product. The engine.

The part that took them a team and took me an afternoon.

Let me show you mine.

I bet the SEO Bot has many more features that can be discovered and implemented for those who really want to explore it in depth.

For now, my SEO skill that 6x my SEO traffic in 60 days is enough for me.

How to install the Claude Code skill and reverse engineer any product

Download the skill below.

Upload it to Claude Code.

Close the app and reopen it.

Then run the command.

Now you have the Claude skill to build anything you can point at.

Just give Claude the link, and it can help you recreate it.

Read more

You feel bored, and sometimes, just spend a voice memo, or curse when AI doesn’t remember yesterday.

Well, I’ve been there and done that.

Claude.MD files are a really solid solution for most cases, but what if there is a better way?

I already built a simple AI second brain, which is the level 2 after Claude.MD files setup, and can remember a lot of things.

But I don’t want it JUST not to forget.

I want it to be able to THINK.

And the system I built does this.

How does the AI second brain work?

The system I’ve built connected all my notes using Karpathy’s wiki method.

Simply put, it reads everything I’ve ever made and compiles it into a living wiki, one page per topic.

Every time an agent runs, it doesn’t just hand me an idea; it writes back into the wiki first, so the brain gets a little smarter every single time.

New topic? It opens a new page on its own.

The wiki never stops growing.

And next, the same Hermes agents go through these connections + my previous data (my 238 articles, my 1,391 Claude.ai conversations, my 138 Claude Code sessions) and generate a thought for me, one that can change everything.

My connections are:

• 📓 Post: Reads my old articles + builds, finds what actually made money (with live proof from the web)

• 🔨 Build: Looks at what I've built but never shipped, then tells me exactly what to make next.

• 🏛️ Stoic: reads my journal + my own psychology, and coaches me through the day.
  📣 Note: Studies my best Substack notes and hands me the next one to write.

These four agents each look at me from a different angle.

Every six hours, they update the wiki and then write me something new, while I sleep, in the journal.

Let me show you a couple of examples from here.

The AI second brain that never forgets

Here is one example “Build” suggestion.

Look at what it did.

It used my previous data(Claude code conversations), created a new SEO page, and also referred to one of my previous projects: cloning a website that generated $50K.

(This article will be published on Friday.)

How does it generate this?

First, to see how it generates, I clicked on “SEO Agent - Ideas,” the link right under the build.

These ideas were scraped from my previous Claude Code conversations: builds I created but never published as articles.

It also cross-checks them with my article data.

Based on these conversations and my previous Substack post ideas, I generated a new page called SEO.

Then it analyzed my Substack post statistics and reminded me that one of my previous articles converted 3 readers into paid subscribers.

So this one has conversion potential too.

The Second Brain That Thinks

I am working a lot. Probably like you.

Sometimes I break; that’s exactly why I lean on Stoic philosophy.

It keeps me consistent and calm, so I read a little Stoicism every day.

And now, I take daily notes about my last few days: how Substack went, what I should do, what I got wrong.

To make it actually work, I analyzed all of my Claude.ai conversations, using Claude itself, to build a profile of me.

How I act when I’m angry. When I get pissed. All of it.

It saved everything to a page called Gencay-Psychology, and every day it reads from there, plus my daily journal, then writes notes to me like this:

That’s the soft part.

Now the pragmatist part. It reads all of my past Substack note stats, how much each one shared, got liked, got restacked, plus every note I’ve ever written, and it generates new wiki pages using Karpathy’s method.

Then it analyzes the results, does its own web research to make sure my notes actually solve a problem, and suggests the next one to write, like this:

This is beyond crazy. One word: amazing.

Because, believe it or not, I started writing the Substack notes it told me to.

The Substack posts actually make sense, and I started backlogging them, and the daily Stoic notes?

They catch the exact mindset I keep losing.

How do you set up?

Now I’m going to explain how to set up.

You can do it in 3 steps.

Two of them take two minutes.

The third one, the skill does for you while you watch.

Here are the files 👇

Read more

There is always more work than time.

Another article to write, a customer to reply to, and a feature to build.

For decades, there was only one way to solve this problem.

Hire people.

But most people never do.

Not because they don’t want to, but because employees are expensive, hiring is risky, and managing people becomes another full-time job.

So they stay solo.

They work longer hours and become the bottleneck in their own business.

This has changed long ago, yet most people still sacrifice their sleep and health to grind and reach their goals.

Not because they have to.

Because they’re solving the wrong problem.

Most people think AI is another productivity tool.

They use it to write faster, summarize documents, or generate code.

That’s useful.

But it completely misses the biggest opportunity.

AI isn’t just another tool; it’s your first employee that can work 7/24.

And once you understand that difference, you’ll stop asking what AI can do.

You’ll start asking what you should never do yourself again.

In this guide, I’ll show you how to make that shift.

Read until the end, and I’ll show you how I would build an AI coworker for three completely different professions.

But don’t skip ahead.

Because before you build one, you need to understand why most people never do.

They never build one because they carry old beliefs about AI into a completely new way of working.

Let’s fix that.

Give me 10 minutes of your full attention.

By the end, you’ll stop thinking of AI as another tool and start thinking of it as your first coworker.

I – You think you’re not technical enough.

Most people never build an AI coworker because they assume building AI belongs to engineers.

It doesn’t.

Some of the best AI systems I’ve seen were built by teachers, marketers, writers, chefs, lawyers, and business owners who had never written a line of code before.

Today, building with AI often starts with writing plain English, as Andrej Karpathy said.

Want to build an app?

One prompt is all you need.

Want an AI agent?

Explain what it should do.

Want an automated workflow?

Write the process you already follow.

That’s exactly why tools like Claude became popular.

Many people still believe you need a computer science degree to build something useful.

The reality is that the barrier has shifted from coding to thinking clearly.

This is the era where imaginers become builders.

II. You judge AI after one prompt.

Most people open ChatGPT, write a vague sentence, get a mediocre answer, and decide AI is overrated.

That’s like interviewing one employee for thirty seconds before deciding nobody wants to work anymore.

AI is like well trained dog, it’ll follow your instructions.

Prompting is communication.

Being specific beats being clever.

Breaking tasks into steps beats writing one huge paragraph.

Treat AI like an intern on its first day.

The better your instructions become, the better your coworker becomes.

III. You think AI is expensive.

You see screenshots of companies burning hundreds of thousands of dollars on AI. You hear the NVIDIA CEO talk about million-dollar inference bills.

Then you decide AI isn’t for you.

Those numbers belong to companies serving millions of users. Not you.

Most people can build serious workflows on a $20 subscription.

Even heavy automation costs less than what you pay for streaming.

Here is the part nobody tells you.

Almost every paid tool has a free open-source twin.

ChatGPT feels expensive? Run DeepSeek.

Claude Code too pricey? You can run it for free with an alteration.

If you have mac mini, install the open source model and use it for free.

IV. You treat AI models like sports teams.

People defend ChatGPT like it’s their football club. Others die on the hill for Claude. Next year they’ll be cheering for something else.

I get the instinct, but technology doesn’t reward loyalty. It rewards paying attention.

ChatGPT was the best AI of 2023 and 2024. So was Nokia, once. I still use ChatGPT for some things, image generation, a quick read on a health or psychology question. But if you want strong technical work, if you want to build something real, Claude pulls ahead on almost every benchmark that matters. Most people didn’t catch up to that until 2026.

Here is the part people miss. The name on top changes. ChatGPT could leap back ahead tomorrow. Gemini could pass them both next month. In this market, one model release can flip the whole ranking in a single day.

So don’t marry a model.

Marry the outcome you want.

The tool underneath can always change, and it will.

V. You think you need every AI subscription.

A lot of people have AI FOMO.

ChatGPT, Claude, Gemini, Perplexity, plus a tool for music, one for video, one for images.

Before long, they pay for ten products and master none.

I pay for Gemini, Claude, and ChatGPT, plus a few others. But I have a reason. I build with them for two companies, and I test them so I can show you what works.

You don’t need five. Pick one and go deep.

Most ChatGPT users have never touched Codex or generated a single image with it. Most Claude users have never opened Cowork, never built a live Artifact, never run Claude Code. Ask one. I bet they don’t know all three exist.

That is the whole problem. People buy the next tool before they learn the one they already pay for.

One AI, used deeply, beats five used barely. Depth wins.

VI. You think AI replaces people.

When ChatGPT arrived in 2022, people expected AI to walk in and take the jobs. That isn’t what happened. AI still needs a person steering it. What changed was something quieter, and PwC caught it in the data.

They studied over a billion job ads worldwide and compared companies that went all in on AI with ones that didn’t.

Look at the chart. Grey is the AI companies. Orange is the rest. Grey wins every year. The ones using AI the most keep hiring more people, not fewer.

There is a second number, and this one is personal.

PwC found that people with real AI skills get paid 62% more than coworkers doing the same job without them.

The industry changes the size of the bonus, but never the direction. Every sector pays more.

I’ve spent thousands of hours building with AI. I have never seen a company hand all its work to a machine.

There is always a sharp mind behind it, aiming the tools. Instead of hiring five more people, they pay that one person more and keep building.

So be the sharper mind.

VII. You dismiss new AI too early.

Every breakthrough follows the same script. People laugh. People criticize. People ignore. Then they quietly start using it.

In 1946, the head of 20th Century Fox reportedly said TV wouldn’t last six months. People would get tired of staring at a plywood box every night. He ran a movie studio. He had every reason to see it coming. He was wrong about the biggest medium of the next fifty years.

I watched a smaller version of this with OpenClaw. People with thousands of subscribers, people who charge ten grand for consulting, smart people, said it was just ChatGPT with extra steps. Nothing new here.

Then it caught on. Everyone could see what it actually did. And those same posts about how shallow it was quietly disappeared. Now the same people post screenshots of themselves using it.

Here is the thing about AI. It doesn’t change by the day. It changes by the hour.

So when something new lands, don’t reach for the easy dismissal. Stay skeptical, but stay curious. The person laughing this year is the customer next year.

VIII. You built your business on someone else’s model.

Cloud AI feels solid. Until the day it isn’t.

Look at Claude Fable 5.

People built real workflows on it, and then access got pulled.

Anyone who wired their whole business to that one model woke up to a dead pipeline.

This happens all the time now. Models get retired. Prices jump overnight.

A feature you depend on quietly disappears.

OpenAI alone is shutting down dozens of older models this year, and every app still pointing at them just stops working.

I am not telling you to abandon cloud AI. I use it every day. I am telling you to keep a plan B.

Plan B is simpler than you think. Buy a mini PC, whatever your budget allows.
Install an open-source model on it.
And before you panic, no, this is not a PhD project.
You download one app and send it a message. That is the whole setup.

Your local model doesn’t need to beat the frontier ones. It just needs to keep the lights on when the cloud goes dark.

IX. You consume AI instead of building with it.

People love reading about AI. Watching the YouTube video. Buying the course. Saving the newsletter for later. Very few people open the tool and build something.

Reading feels like progress. It isn’t. Knowledge that never ships is just entertainment with extra steps.

Here is what I mean by building. You don’t need a big idea. You need a finished one.

I don’t just write this. I live it. I built a Polymarket bot with Claude Code that made 2.1x in 18 days on paper. I built a job hunter that scrapes Indeed, Upwork, and LinkedIn every morning and sends me the better-paid roles. I built a trading bot that copies millionaires. I built a night-shift agent that works while I sleep. When Claude Fable 5 got pulled, I rebuilt my whole stock analyst on a different model in one prompt, at half the price.

None of these started as something impressive. Each one broke in ways no tutorial warned me about, and fixing it taught me more than any article ever could.

The people getting extraordinary results aren’t the smartest in the room. They just ship more experiments. They built ten ugly things while everyone else was still watching videos about the perfect first project.

So close the article. Open the tool. Build the ugly thing.

X. Build your first AI coworker

Enough theory.

Let’s make this practical.

It doesn’t matter whether you’re a chef, marketer, broker, lawyer, or founder.

The idea stays the same.

• Give AI a role.

• Give it your knowledge.

• Give it a memory.

Then let it work while you focus on what humans do best.

The Chef

Step one, get the tool. Download Claude Code. It is one app, and when you open it you just talk to it like a person.

Step two, hand it your knowledge. Put your recipes, your cooking notes, and a few favorite cookbooks into a folder. Tell Claude, in plain words, “read everything in this folder and remember it.”

Step three, give it a job. Tell it, “every morning, look at what is in my fridge/ingredients, check it against my recipes, and send me three things I can cook today.”

Claude writes the little program that does this. You don’t write a line of it.

That is the whole thing. I built this exact setup. I call it Fridge Gourmet.

Also added one more step, where my AI turned the food into cool images.

Once it runs, push it further. Feed it the menus from the Michelin-starred restaurants you love, drop in the dish you’ve always wanted to recreate, add the cookbook that first got you into the kitchen.

Then ask for more than a recipe.

Have it write the dish and generate a photo of the finished plate, waiting for you each morning. You get the idea. The basic version saves you time. The next version teaches you to cook like the people you admire.

The Marketing Specialist

Step one, gather your past work. Every post, every newsletter, every campaign, and the numbers each one pulled. Drop it all in one folder.

Step two, hand it over. Tell Claude, “read all of this and learn which ideas turned free readers into paying ones.”

Step three, ask before you write. Every morning, before you start, ask it one question. “Which idea has the best shot at converting today?” You stop guessing from a blank page. Your coworker already knows what worked yesterday.

I run my own Substack exactly like this.

All of my substack post, note statistics saved inside Obsidian.

It gives me regular suggestions.

In the end, I'm the one who decides if it's worth publishing. That's why AI will always need human judgment.

The Broker

Step one, keep a journal. Every trade you make, write it down in one file. The date, the move, the reason. That file will be your AI’s memory.

Step two, give it the books. Upload your investing books into NotebookLM, a free Google tool that reads documents and answers questions about them.

Then build a Claude routine that connects NotebookLM to Claude. The routine takes your week of trades, feeds them into NotebookLM, asks the hard questions, and saves the answers into a weekly report.

Step three, let it grade you on its own. You can also ask it directly any time, “compare my trades this week against the rules in these books and tell me where I broke them.” It stops telling you only whether you made money. It starts telling you why. Connect it to your agent and the report lands while you’re having your Sunday breakfast, orange juice in hand.

I built this one too, a bot that writes its own weekly report and feeds the fix back to itself.

But why should you listen to me?

I don’t like talking about myself. I’m doing it here only because most of you subscribed in the last three months, so you don’t know me yet.

LearnAIWithMe grew from 5,000 to 15,000 subscribers in three months. Why the jump?

Because in March I pulled back from everything else and put almost all of it here, on Substack.

Before that, I built AI for enterprises, startups, and clients around the world. Over 7,000 freelance hours, a 100% Job Success Score on Upwork, and years of turning rough AI ideas into things that actually shipped.

I wasn’t always a freelancer. I trained as an engineer and worked for some of the largest companies in Turkey before any of this.

The plan now is simple. Build AI systems that actually work, every Monday, Wednesday, and Friday, and put the best of it in the Vault.

So if you want to build real AI systems and put them to work, you’re in the right place.

Subscribe now

Need this in your business?

You just read how to build an AI coworker that works while you sleep.
I build these for clients too, except I build the whole team, not just one coworker.
I built a production interview agent for a data platform used by 500K+ people.
I built 20+ AI agents for companies across finance, construction, marketing, even liquor brands.
I’m Top 1% on Upwork, Expert-Vetted, 7,000+ hours logged with international clients.
DM me, and we’ll talk.

Then the government pulled it, and it is still gone.

That left everyone with the same thought.

What if the model we build our work on, sometimes our living, gets taken the same way?

A government can pull it, a vendor can shut it down, or the price triples overnight.

Everyone agrees we need a plan B. Mine started with a Mac Mini.

I bought it to run my Hermes agent in an isolated environment, so I asked a simple question.

What if the agent needed no frontier model at all?

I have two favorite tools, Claude Code and NotebookLM. If I could run both of them on open source models, on my own machine, the cloud could not touch them.

So I built the system. Now they cannot take my AI away.

What will we build?

I run two favorite tools on my own machine, and neither one needs a frontier model behind it.

Claude Code pointed at a local model instead of the cloud. It still writes code and builds apps, it just runs on my desk now.

And I even created a website, using it, for $0.

NotebookLM was swapped for a local open source version. It turns my sources into a podcast and answers my questions, all offline, and my data stays safe.

I even created two different notebooks about Stoic philosophy and cortisol, the stress hormone.

Underneath both sits one engine, Ollama, running Gemma 4 on a Mac Mini with 16 GB. It can run millions of tokens, and it still costs me $0.

That is the whole stack: a small box, an open model, and two tools that owe nothing to a subscription.

Optional

To go fully off-grid, I connected it to my EcoFlow, a solar-powered battery station, making the whole system completely independent.

The trick that keeps it yours

Months ago, I bought a Mac Mini and quietly moved my work onto local models, while renting my whole stack from one company started to feel like a bad bet.

Then Fable 5 died in ninety minutes, and everyone felt that the bet went bad at once.

Now the hardware is drying up. The 512 GB Mac Studio that runs a serious model is gone; only the 96 GB versions are left.

When the person who builds OpenClaw says they cannot make these anymore, you listen.

The people who waited are buying scarce machines at a markup, learning this under pressure.

I am not in that line. My agent already runs on my desk, and I will show you exactly how I did it.

Read more

My turn came after fifty-seven minutes.

I said three sentences, and that was the entire reason I was there.

I am a practical man, and meetings are not where I am useful.

From the day AI entered my life, I wanted one thing out of it, something that pays.

The shortest path to that is money, and that path is not short at all.

That is why I have made many attempts.

I built a crypto trading bot once using Claude Code and OpenClaw. It reached a 77.8% win rate.

Two weeks ago, I built a copy-trading bot. It was reporting to me via Slack.

It ran fine on GitHub, but GitHub wore me down, so I rebuilt it on the Hermes agent on my Mac Mini.

Paper money, of course, because I am only testing.

Funny thing, this copytrade bot is up about 50%, and only 10 days have passed.

I seriously considered selling my XRP and using the money to build this for real with the Binance API.

My attempts did not stop there. I kept hearing one name. Polymarket.

And people (apparently) make a lot of money.

So, like always, I wanted to test it myself first, with paper money.

I had Claude Code write the script and sent it to the Hermes agent running on my Mac Mini.

The bot is alive right now and reporting to me, working on paper money, but it made 2.1x in 18 days.

Let me show you how this bot (developed by Claude Code) is working first, and I’ll hand out to you the script and the agent instructions so you can build your own without doing a lot of research and building like me.

Also, let me share the logs with you so you can see what the bot is doing. Like always, I’m saving detailed logs so I can continuously analyze and improve its performance.

Here are the logs of this trading bot as csv, to see the actual trades.

You can check when this bot did what.

But first, let’s start with the fundamentals.

What Polymarket Actually Is?

Polymarket is a prediction market.

People bet on outcomes.

Will this candidate win? Will this team take the cup? Will Bitcoin close above a number by Friday?

The price of a share is the crowd’s odds.

For instance, for the World Cup winner, currently, if you bet on Spain $1 and if Spain wins, you’ll get $6.02

Most people land there for the elections or the celebrity bets.

I don’t care about the topic; I care about the outcome.

The Polymarket Bot I've Built with Claude Code and Hermes

The bot watches one thing. The BTC 5-minute window on Polymarket.

Every minute, it reads the live Up and Down prices on Polymarket and decides.

Up, Down, or sit this one out.

When one side is a clear enough favorite, the bot places a paper bet. No real money yet.

The wallet is virtual. The market data is real. These are the same prices a human sees on the screen. The bot buys, holds to settlement, and logs what happened.

Claude Code wrote the script. The Hermes agent on my Mac Mini runs it on schedule and reports to Telegram.

Same setup as my other bots. Only the market changed.

How the Polymarket Trading Bot Works?

Claude Code wrote the logic as a single loop. Every minute, the bot wakes up, looks at the open window, and runs three checks.

• First, the odds.

  • The bot reads the live Up and Down prices on Polymarket. If one side sits far enough from 50 cents, there is a clear favorite. If both sit near 50, the crowd is split, and the bot waits.

• Second, the price.

  • A favorite is not enough. If that side already costs 96 cents, there is no room left to win, so it skips.

• Third, the timing.

  • One bet per window, never in the first or last seconds, held to settlement. When all three pass, the bot buys the favorite, the pricier side, for one dollar a share. A dollar back if it wins, nothing if it loses. The result lands in Telegram, and the loop starts over.

Here Are the Files

Three files. SOUL.md is the agent instructions Hermes reads. paper_engine.py is the paper-trading bot. polymarket_check_collect.sh is the wrapper that pulls market data and calls the engine every minute.

The engine does not run alone.

The wrapper feeds it the data.

Together, they are the bot.

Paper only. It never sends a real order unless you turn it on.

Download them, hand them to your agent, feed them your API key (polymarket API key is free).

Here are the files:

Read more

I refreshed, and the slot was dead.

I had built my whole Wall Street analyst on that model, and now the analyst had no brain.

A couple of my projects were left unfinished.

I thought there was nothing I could do about them.

Then I saw Fusion API, released by OpenRouter, outranking Fable 5.

At half the price.

I was shocked, so I decided to give it a try. I already had at least ten articles sitting in my drafts, so I thought, why not?

The results genuinely surprised me.

I built an SMC analyst using a single prompt, and it looks like this:

I’ll explain how it works, but first, let me explain what OpenRouter and Fusion API are.

What is OpenRouter Fusion, the API that replaced Claude Fable 5?

OpenRouter is one API key for every model.

You call one endpoint, and it routes you to OpenAI, Anthropic, Google, DeepSeek, whoever you name.

Fusion is the part that pulled me in. Fusion is not a single model. You send one prompt, and OpenRouter fans it across a panel of models at once. A judge reads every answer and marks where they agree, where they fight, and what all of them missed. Your model writes the final answer from that. A panel instead of an opinion.

Look at the API usage from my build.

It was mostly using Opus, but Gemini 3.1 Pro and GPT-5.5 were also involved.

How to run Claude Code on Fusion after Claude Fable 5 was suspended?

Claude Code speaks the Anthropic Messages format, and OpenRouter speaks it too. So you point Claude Code at OpenRouter, name Fusion as the model, and skip the proxy.

Grab a key from openrouter.ai, then run this block once.

echo '
export ANTHROPIC_BASE_URL="https://openrouter.ai/api"
export ANTHROPIC_AUTH_TOKEN="sk-or-YOUR-OPENROUTER-KEY"
export ANTHROPIC_API_KEY=""
export ANTHROPIC_MODEL="openrouter/fusion"
' >> ~/.zshrc
source ~/.zshrc
claude

The only thing you need to do is add your OpenRouter API key, paste it into your terminal, and watch it work.

Now you get the idea. Let me show you what I built.

What did I build with Fusion?

One screen, built for the chip trade. I named it the SMC Analyst, short for semiconductor, the only corner of the market that lets you trade the AI build-out at the source instead of chasing it through NVIDIA alone.

The left panel is the semiconductor watchlist.

The equipment makers like ASML and LRCX sit next to the foundry in TSM, the designers like NVDA, AMD, AVGO and MRVL, and the old guard in INTC and MU.

Each row carries two pills that the app computes on its own, so the trend pill reads price against the 50 and 200-day averages and the value pill reads the P/E and calls it cheap, fair, or rich.

You see the whole chain rated before you click anything.

Under it sits a positions tracker with live profit and loss, then the key metrics for whatever ticker you load, from P/E and price to sales down to margins, revenue growth, debt, and short interest.

Under that, the macro picture comes straight from the Fed, with the funds rate, the 10-year yield, CPI, and unemployment. It is the same data a terminal charges for, pulled from the source that publishes it for free.

The center is the chart, a year of candles with volume and the 50 and 200-day lines, recolored to the cream theme instead of the usual black box. Under it a news wire feeds the latest eight headlines into the analyst before it speaks.

The right panel is the analyst, and this is where Fusion earns its bill.

It does not cover the whole market, only chips, and it reads them like a desk analyst who thinks in cycles, capex, node transitions, and who depends on whom.

Ask it to read a name, and it answers from the numbers on your screen instead of from memory.

I loaded MRVL and asked it to look at my position.

The memo is one side of the analyst. The other is the chat tab, where you argue with it.

The same context sits behind both, so the chat answers from the price, the macro, and the news on your screen rather than from training data.

How the SMC analyst works on Fusion

The stack is five pieces.

• yfinance for price, fundamentals, and news

• fredapi for the Fed’s macro data

• lightweight-charts for the chart, TradingView’s own open-source library

• FastAPI as the backend, one file

• Fusion as the brain, through Claude Code on the OpenRouter API

The flow is simple.

The backend pulls fundamentals, macro, and the latest eight headlines into one context, and that context goes to the analyst with a semiconductor prompt.

The analyst returns a rating out of ten, the supply-chain position, three bull points, exactly three red flags, the macro read, and a verdict. The same context feeds the chat tab, so the analyst answers from the numbers on your screen.

I pasted a single prompt into Claude Code and watched it run on Fusion.

Also, if you don’t want to build the entire thing, I also uploaded the files to GDrive, so you can download them and run on your environment.

I’ll give them both.

First, here are the files.

Read more

I went looking for the answer. What I found surprised me and made sense at the same time.

The easier learning feels, the faster you forget it.

Re-reading your notes feels productive.

You recognize every line, so your brain tells you it knows the material.

Then the exam asks one question, and nothing comes out.

Researchers call this the illusion of competence.

Real learning runs the other way. You pull the information out of your head instead of pushing it back in.

You let yourself forget a little, then reach for it. The reach is what makes it stick.

Four things trigger that reach.

Retrieval. Spacing. Interleaving. Generation.

Every NotebookLM prompt below is built on one of them, so these are not generic study tips but NotebookLM learning prompts shaped around how memory works.

Each one is paired with the Studio feature that complements it.

And each one forces the reach that makes learning stay.

Each one has a fill-in template you can copy. Each one was tested on a real notebook.

(Mine is trained on Boris Cherny's 30-minute course, Mastering Claude Code in 30 Minutes. He created Claude Code.)

Zero coding. Nothing to install. Everything happens inside NotebookLM.

• If you are a student, these turn your notes into a system that makes the material stay.

• If you learn things on the job, papers, internal docs, and technical manuals, the same prompts work.

Let’s start with what I found about why most of what you read never sticks.

What is NotebookLM?

NotebookLM is a learning and research tool of Google, so it was first designed to help students with studying or researchers.

You can learn almost anything faster thanks to its multimodal capabilities, including video generation, image generation, and podcasts.

Its grounding feature also helps reduce hallucinations by connecting responses to reliable sources, and its long context window lets it retain and process more information at once.

Google has also linked it with Gemini, so you can now build apps with this connection, even on the free plan.

How to train NotebookLM?

Follow these steps to train it, or watch the screen recording above to see how I did it.

Steps: Visit here → Click on “Try NotebookLM” → Click on “Create new” → Add any source.

And that’s it. The whole setup takes about a minute; it’s really that simple, and it’s completely free.

Take a closer look at the Studio features. We will spend a lot of time here.

Let’s start learning with NotebookLM.

Retrieval: Pull it out of your head

Reading puts information in, but retrieval drags it back out, and that drag is what builds the memory. Every prompt here makes you produce the answer before you see it.

Prompt 1: The Brain Dump That Grades Itself (Retrieval)

You read the chapter twice, and you highlighted half of it, so it felt solid.

Then you close the book and try to write what you remember, and you get half a page. Maybe less.

The highlights looked like knowledge, but they were just ink on someone else’s words.

The 1-click way: Quiz feature

Open your notebook, and in the Studio panel, click Quiz.

NotebookLM reads your sources and writes the questions for you, so you answer, it scores, and the gaps show up where you were guessing.

But this quiz does not know you. It does not know what you already understand and what you keep getting wrong, because you never told it. It just pulls questions from the sources at random and hopes some of them land.

So it wastes half your time testing things you already know cold, while the topic that actually scares you shows up once, if at all.

To fix that, the quiz needs to know you first. You tell it what you know, and it points everything else at the gap.

(Select Quiz at the studio, click on > right next to it.)

Use this prompt.

Customize the “topic” and the “goal”.

Here is my brain dump on {topic}, written from memory. Compare it against my sources. 
List what I got right, what I got wrong, and the key points I missed. 
Rank the gaps by how much they matter for {goal}. 
Do not add anything I left out until after the comparison.

Now the quiz works on your weak spots instead of handing you a generic round of questions. You feed it what you know, and it spends every question on what you don’t.

Then, you can click one of the topics under Keep learning to turn your weak spots into the next quiz.

From there, click one of the topics under Keep learning, and NotebookLM turns it into a new quiz so you can keep improving.

When to use which?

• Quiz feature → A quick check when you have five minutes between classes.

• Custom prompt → Real exam prep, when you need to know what comes off an empty page and not just what you recognize.

Prompt 2: Flashcards That Make You Produce the Answer (Retrieval)

Your deck has two hundred cards, and you flip through all of them in twenty minutes. Every back side looks familiar, so you tell yourself you know this.

Then the exam asks for the same term cold, with nothing on the screen, and your mind goes blank.

The 1-click way: Flashcards feature

Open your notebook, and in the Studio panel, click Flashcards.

NotebookLM scans your sources and builds a full deck in a few seconds, with a term on the front of each card and its definition on the back.

But a normal card shows you the whole answer the second you flip it, so your brain coasts.

It sees the term and the full definition sitting together, recognizes both, and moves on feeling smart.

The real exam works the other way. It gives you a half-sentence with a blank in it and waits for you to fill that blank, and the blank is where the actual learning happens.

So you need a card that hides one piece and makes you produce it yourself.

(Select Flashcards at the studio, click on > right next to it.)

Use this prompt.

Make cloze-deletion cards from my sources on {topic}. 
On each card, hide one key term, number, or step inside a full sentence and leave a blank where it was, 
so I have to produce the missing piece from memory. 
Pull the hidden items from definitions, formulas, and cause-effect chains. 
Put the complete sentence with the answer filled in on the back, and cite the source for each card.

Here is what it produces.

Now every card makes you come up with the missing piece instead of reading a finished answer, and that blank does the work your highlighter never did.

If it still feels too easy, open the same panel and set the difficulty to Hard, and the blanks land on the trickier pieces.

When to use which?

• Flashcards feature → A first pass on new vocabulary, when you just need the terms in front of you.

• Custom prompt → Real review, when you need to pull the answer out yourself, because that is the part that the exam grades.

Prompt 3: The Recall Table You Fill In From Memory (Retrieval)

You study one chapter at a time, and each one feels finished the moment you move on. Then the final lands, it covers chapter two, and chapter two is gone.

You learned it six weeks ago, and you never touched it again.

The 1-click way: Data Table feature

Open your notebook, and in the Studio panel, click Data Table.

NotebookLM pulls the key concepts out of your sources and lays them into a clean grid, with the term in one column and the definition and an example sitting right next to it.

This is good when you want one tidy sheet to look things up on while you study.

But a table like this is something you read, and reading the answer is not the same as recalling it.

The definition sits one column over from the term, so your eyes slide across and your memory never has to do anything. You finish the sheet feeling caught up, and you have tested nothing.

So you blank out the answer column, and the same grid turns into a test you fill in from memory.

(Select the Data Table at the studio, and write your prompt in the description box.)

Here is the entire prompt.

Customize the {subject}

Build a recall table from all my sources on {subject}, not only the most recent one. 
Use three columns named Topic, Question, and Answer, and write one short question 
for each key point that makes me produce the answer from memory. 
Give me two versions of the table, one with the Answer column filled in and one with it 
left blank, so I can fill it first and check after. 
Weight the rows toward older material I am more likely to have forgotten.

Here is what this prompt generates when I customize the subject like this:

Claude Code workflows, onboarding, memory systems, MCP tools, planning, context management, and parallel agent workflows

Now you work down the blank version, write each answer yourself, and only then open the filled one to check. The grid stopped feeding you the answers, and it started asking for them, and it leans on the old chapters that quietly slipped while you were busy with the new ones.

When to use which?

• Data Table feature → A reference sheet, when you want every concept in one place to look up while you read.

• Custom prompt → Cumulative review, when the old chapters keep fading and you need to drag them back before the final.

Spacing: One long session feels productive, but most of it leaks out within a week. The same hours are split across several days, with gaps in between that let you forget a little and then pull it back, hold far longer.

These next two prompts put time itself into the plan.

Prompt 4: Turn Any Subject Into a Forgetting-Curve Calendar (Spacing)

You have two weeks until the exam, so you block out Saturday and plan to study all of it in one sitting.

By next Saturday, most of it has faded, so you sit down and study the same material again from scratch.

Spacing works because forgetting happens first.

Two back-to-back review sessions only strengthen familiarity.

The 1-click way: Report feature

Open your notebook, and in the Studio panel, click Reports, then pick Study guide.

NotebookLM turns your sources into one document with questions, key terms, and a glossary, all stacked together in a single pass.

Here is what it looks like.

But a study guide hands you everything at once, on one day, with no sense of when to come back to any of it. You read it Saturday, you feel on top of the material, and then the forgetting starts the moment you close the tab. What actually holds a memory is meeting the same thing again a few days later, and then again a week after that, right as it is about to slip.

So you need a schedule, not a pile, and the schedule has to tell you what to review on which day.

(Select Reports at the studio, click Create your own.)

Here is the entire prompt.

Customize the {subject} and the {start_date}.

Turn my sources on {subject} into a spaced review calendar that starts on {start_date}. 
List every major topic, and for each one set review dates at day 1, day 3, day 7, and day 14. 
Spread the topics across those dates so no single day repeats the same subject twice. 
Lay it out as a table with three columns named Date, Topic, and the one retrieval action I do in that slot.

Here is the report.

Now the same material comes back four times on a schedule instead of once in a panic, and each return lands right as the last one is starting to fade.

You stop relearning chapters from zero, because you never let them fall all the way out.

When to use which?

• Report feature → A single study guide, when you want everything in one sheet for one sitting.

• Custom prompt → A two-week run-up, when you want the same topics to resurface four times, spaced out so they actually stick.

Prompt 5: Your 10-Minute Daily Recall Set (Spacing)

A calendar tells you which day to review, but it does not put the questions in front of you when that day arrives.

So you finish a topic, you feel done with it, and you never open it again.

The plan said to come back Thursday, and Thursday came and went.

The 1-click way: Audio Overview feature

Open your notebook, and in the Studio panel, click Audio Overview.

NotebookLM turns your sources into a short narrated recap, and you can play it on the walk to class or while you make coffee.

This is good when you want to keep a topic warm without opening the book.

But by default, the hosts cover the whole source evenly, so they spend just as long on the parts you already know cold as on the parts that scare you.

You end up half-listening to a recap of things you nailed last week, and the one topic you actually keep failing slides by in fifteen seconds. The recap should do the opposite. It should park itself on your weak spots and barely mention the rest.

So you feed the hosts the exact topics you got wrong, and the audio turns into a private recap of your gaps.

(Select Audio Overview at the studio, and write your focus in the customize box.)

Use this prompt.

Customize the {weak spots} with the ones the quiz flagged.

From my sources on {weak spots}, build me today's recall set for {date}.
Pick five items I most likely studied a few days ago and would be starting to forget now. 
For each one, ask a question that makes me retrieve the answer before I see it, 
and put all five answers together at the end so I cannot peek early. 

Here is the audio overview generated.

Now each morning gives you five questions pulled from what you studied earlier in the week, and you answer them cold before you check. Ten minutes, and the old material gets dragged back up right as it is slipping, which is the whole point of spacing.

When to use which?

• Audio Overview feature → Passive review on a commute, when you just want the topic playing in the background.

• Custom prompt → If you know your weak spots and want to fix them, use it.

Interleaving (mix the topics up)

Studying one topic all the way to the end before you touch the next one feels clean and organized. The trouble is that the exam does not arrive one topic at a time, so mixing them while you study forces you to figure out which method even applies before you use it, and that choice is half of what the test is really checking.

Prompt 6: The Mixed Problem Set That Mimics the Real Exam (Interleaving)

You drill chapter four until every problem clicks, and by the end you feel sharp.

Then the exam puts a chapter four question between one from chapter two and one from chapter six, with no labels, and suddenly you cannot tell which method the question even wants.

You practiced solving the problems. You never practiced spotting which problem you were looking at.

The 1-click way: Quiz feature

Open your notebook, and in the Studio panel, click Quiz.

You know the output; we already did this before.

Here is what it looks like.

This is good when you are drilling one topic you just learned and want to see if it stuck.

But by default the quiz keeps the questions grouped, so you get ten in a row on the same idea, and the topic itself already tells you which method to use, so you never have to choose.

That is the easy version, and it hides the skill the exam actually tests.

The real test mixes everything together and tells you nothing, so the first thing you have to do is work out what kind of question you are even staring at.

So you want the questions shuffled across topics, with the labels stripped off.

(Select Quiz at the studio, click on > right next to it.)

Use this prompt.

Build a mixed problem set from my sources on {subject}. 
Pull questions from at least four different topics, and shuffle them so no two questions in a row 
come from the same topic. 
Do not tell me which topic each question belongs to, so I have to work out which concept applies 
before I solve it. 
Put an answer key at the end that reveals the topic and the solution for each one.

Here is what it generates.

They look similar, but they are not.

A grouped quiz never makes you pick. Ten questions come from the same topic, so the method is already decided before you read a word, and you just apply it. A mixed quiz takes that away.

Each question could be anything, so first you have to figure out which approach it needs, and only then can you solve it. That first step, picking the right method for a question nobody labeled, is the one the real exam grades.

When to use which?

• Quiz feature → Drilling a single topic you just learned, when you want a quick check on that one thing.

• Custom prompt → The final week, when the real exam will mix everything together, and you need to practice telling the questions apart.

Prompt 7: The Drill That Stops You Mixing Up Two Concepts (Interleaving)

Two terms sit close together in your notes, and you know both definitions cold.

Then the exam describes one of them in a sentence and asks which it is, and you pick the wrong one.

You never studied them side by side, so you learned each on its own and they blurred into each other the moment they showed up together.

The 1-click way: Flashcards feature

Open your notebook, and in the Studio panel, click Flashcards.

We already did this before.

This is good when you are meeting the concepts for the first time and just need to learn each one.

But one concept per card is exactly what leaves you mixing them up later.

The card teaches each idea alone, in its own clean little box, and it never once puts the two lookalikes next to each other.

So you walk in knowing both definitions and still lose points, because the thing you were never tested on is the difference between them. The cards that actually help are the ones that force you to choose.

So you build cards that put two similar concepts together and make you say which one fits.

(Select Flashcards at the studio, click on > right next to it.)

Use this prompt.

Customize the {subject}

Here is what it looks like.

Look through my sources on {subject} and find the pairs of concepts that are easiest to confuse with each other. 
For each pair, make a card that gives me a short scenario or example on the front, 
and asks which of the two concepts it is. 
On the back, give the answer and one line on the tell that separates the two. 
Cite the source for each card.

Let’s see the flashcards.

Now, each card drops you into a scenario and makes you choose between the two lookalikes, which is the exact moment you keep failing on the exam.

You stop reciting two clean definitions in isolation, and you start practicing the one thing that trips you, telling them apart when they show up together.

When to use which?

• Flashcards feature → A first pass on new concepts, when you just need to learn what each one is.

• Custom prompt → When two ideas keep blurring together and you lose points picking the wrong one.

Generation (produce it before you see it)

The strongest memory comes from making your brain reach for an answer it does not have yet, because the reach is what wires the answer in, and even a wrong guess leaves a hook the correct one can hang on later. This is the one thing a button cannot do for you, so two of the three prompts here drop the 1-click feature entirely.

Prompt 8: Guess Before You Read (Generation)

You open the explainer and let it walk you through the whole thing, and it all makes sense while you watch. Then you close the tab an hour later and almost none of it stays.

Watching is not the same as producing, because the answer never cost you anything, so your brain filed it as something it could always look up again.

The 1-click way: Video Overview feature

Open your notebook, and in the Studio panel, click Video Overview, then pick Explainer.

Here, you should also prompt it to generate new options. I only selected from the preselected ones.

NotebookLM turns your sources into a narrated video that walks through the topic with visuals, like a short lecture built from your own material.

This is good when you are seeing a new topic for the first time and want the shape of it before you go deep.

But by default, the video just tells you everything in order, so you sit there nodding while it does all the thinking out loud. Nothing asks you to come up with anything, and the answer you never reached for is the answer you forget first.

The fix is to make the video pose the question first and tell you to pause and answer before it moves on, so the guessing happens in the gap you create.

You steer that from the same panel, in the box that asks what the hosts should focus on.

(Select Video Overview at the studio, open Explainer, select the whiteboard, and write this in the focus box.)

Here is the prompt.

Make this an explainer on {topic} that turns me into a participant. 
Before each new idea, have the narrator pose a question about it and tell me out loud 
to pause the video and answer in my head before continuing. 
After that, give the answer and explain why it is right. 
Move through the key points this way, one question and one pause cue at a time, and use only my sources.

Here is what it looks like.

Now you commit to an answer before the source opens its mouth, and that single act of guessing does more for memory than three rewatches ever could. The misses are the most useful part, because once you guess wrong and see the right answer land, that correction sticks in a way a video never managed.

When to use which?

• Video Overview feature → A first look at something new, when you just want the shape of the topic.

• Custom prompt → Real encoding, when you want the topic to stay instead of making sense for a minute and then leaving.

Prompt 9: Teach It Back Until It Breaks (Generation)

You read the chapter, you understood every line, and you wrote clean notes. Then someone asks you to explain it out loud, and you freeze. The words are there, but they will not come out in order, and you realize that understanding a sentence while you read it is not the same as being able to produce it on your own.

The 1-click way: None

This is the first prompt with no feature behind it, and that is the whole point of it. A quiz checks whether you recognize the right answer from a list, but teaching is the opposite move.

You start from a blank space and build the explanation yourself, out loud, and then something pushes back on the parts you got fuzzy. No button does that, so you set it up in the Chat instead.

(Open the Chat, click Configure)

Next, customize it like this.

Use this prompt.

Customize the {topic} and your {level}.

We are going to flip roles. You are the student, and I am the teacher explaining {topic} to you. 
My level is {level}, so play a student just below that, curious and willing to ask why. 
I will explain the topic in my own words first, and you will let me finish without interrupting. 
Then ask me three questions, one about something I skipped or oversimplified, one that tests whether I understand why it works and not just what it is, and one harder one that pushes on an edge case or a link to another idea in my sources. 
Check my answers only against my sources, and if I say something the sources do not support, tell me. 
At the end, give me a score out of ten and name the one thing I should go back and study.

Now you have to build the explanation from nothing, in your own words, before anything helps you.

Let’s test it.

Paste this prompt to the chat.

Here is my explanation. 
Claude Code is an agentic assistant that works across your whole codebase, so instead of 
finishing one line at a time, it can build 
a feature and fix bugs across several files on its own.

Here is the answer.

Look at what it did with two plain sentences. It let your explanation stand, confirmed the part you got right, and came back with three questions at three depths. The first caught what you skipped. The second pushed on the why, not that it reads a git log but how it knows to. The third went past the material into an edge case, running sessions in parallel without them colliding.

Then it scored you an 8 and named the one gap to fix, context management with memory files and MCP tools. That score and that single target are the whole point. You walked in feeling like you knew Claude Code, and you walked out knowing exactly where you did not.

When to use which?

• Plain Chat → A quick answer, when you just want to look something up in your sources.

• Custom prompt → Real understanding, when you need to produce the explanation yourself and find out where it breaks. Use it the day before an exam or a presentation, anywhere you have to say the thing out loud instead of pointing at it on a page.

Prompt 10: Build a Tutor That Makes You Do the Thinking (Generation)

You ask NotebookLM a question, it gives you a clean answer, and you close the tab. It works, but it feels like searching, not learning, because the answer arrives finished and you never had to reach for any of it. A real tutor never just hands it over. They ask you one back and make you find your way to it.

The 1-click way: plain Chat

The default Chat is a vending machine. A question goes in, an answer comes out, and nothing gets produced on your side. That is fine when you need a fact, but it is the weakest way to learn, because the work that builds memory is the work it does for you.

A tutor who asks before it tells is not a feature you click. It is a persona you write once, and then every answer for the rest of the notebook makes you generate instead of receive. You set it in the same Configure box as the teach-back, but this time it stays on for good.

(Open the Chat, click Configure, and paste it into the Custom box.)

Use this prompt.

Fill in {teacher_name}, the {traits}, and the {interest} your analogies should come from.

Act like {teacher_name}, the kind of tutor who makes me do the thinking. 
{teacher_name} is {traits}, and explains everything with analogies drawn from {interest}. 
When I ask a question, do not hand me the full answer. 
Give me a push in the right direction, then ask me one question back that makes me take the next step myself. 
Connect every new idea to something I already know, and when I drift or guess lazily, pull me back and make me try again. 
Use only my sources for the content, but stay in character the whole time.

Here is what mine looks like.

Now every answer turns into a question you have to finish, so the notebook stops feeding you and starts pulling things out of you.

Set it once at the start of a subject and leave it on, and a month of normal questions quietly becomes a month of small reps, each one making you produce a little more than you came in with.

Let’s test it.

Here is my question for the Chat.

What is a CLAUDE.md file and why does it matter?

Here is the output.

This is the difference in one screen. A plain Chat would define CLAUDE.md, drop a citation, and stop. The tutor gave you a frame you already know, the briefing note a director hands an actor, laid out what the file does, then turned the question around. If your frontend and backend folders need different commands, how does the memory system handle that without one bloated root file?

Now you have to answer, and that is the whole point. You are not reading about CLAUDE.md anymore; you are working out how it scales in your own head before anyone tells you. Leave the persona on for the subject, and every question you ask turns into one you have to help answer.

When to use which?

• Plain Chat → A quick fact, when you just need to look something up and move on.

• Custom prompt → A whole subject, when you want every question you ask to teach you something instead of just answering you.

What’s next?

You just turned NotebookLM into something that makes learning stick.

That is the whole job for learning, but it is only half of what the tool can do.

The four reach all points the same way. They work because you produce instead of consuming. And the biggest version of producing is not answering a question, it is building something with what you learned.

That is where NotebookLM stops being a study tool and starts being an engine. Once you connect it to Gemini, your notebook stops answering you and starts running as an app you made.

If those made you think you could ship a real product from a notebook, you are right, and that is where Claude Code comes in.

It is the tool I use every day, for client work and for my own apps.

Most people miss that you can run Claude Code for free, using Ollama connection with an alteration, and I wrote the full setup here.

If you like building with AI, creating new things, I’ve started a series, named Build-it in may and we’ve built 17 systems so far.

The latest post of “Build it” was using NotebookLM, through CLI, inside Claude Code. I use NotebookLM a lot with Claude Code because, due to its implementation, it does not hallucinate much. I also have safeguards in place.

So if you want to do more than just learn, start building with AI and take advantage of it. Join our community. We’re growing fast, and one day, everyone will understand the importance of creating instead of consuming.

Subscribe now

Then everyone talked about loops.

New terms showed up overnight.

Loop Engineering. Harness Engineering.

That is how this field moves. Before 2022, we did not know what prompting was. Prompt engineering came later.

A trend is forming. We dig deeper.

I explained what a Claude loop is in this one, and I turned 3 of my own automation skills into loops.

Then this morning, on a walk, I asked a different question.

How do I put NotebookLM inside one?

I went back through my old articles.

I had been building loops for a year using NotebookLM and Claude Code.

Nobody called them loops back then.

So let’s build a new loop using NotebookLM and Claude Agents.

A loop that audits my AI investment.

Those companies have been racing for years.

What will we build with Claude loops?

We will have a system where Claude agents ask NotebookLM questions about AI chips.

Here we’ll set the Claude agents, which will be the goal of this automation, making the entire system a loop.

Those notebooks are trained on verified sources only, mostly government filings.

After the agents query them, they move to the second layer, one notebook for the industry, and a third for the global economy.

Why NotebookLM?

We cannot afford hallucination. NotebookLM hallucinates far less.

We also customize each notebook to stay silent when the answer is not in its source.

Two layers of protection against a made-up number.

The end result is one website.

Everything in one place, sourced.

Let me explain the technical structure.

How is the Claude loop structured?

I did this for AI chips. You can do it for any industry you want to invest in.

Three layers.

• Layer 1, the companies. One NotebookLM per company, built from verified sources only. Mine: Nvidia, AMD, TSMC.

• Layer 2, the industry. One NotebookLM for the sector those companies sit in. Mine: the 2026 global semiconductor market.

• Layer 3, the global economy. One NotebookLM for the macro backdrop. Rates, inflation, demand.

Each layer gets its own agents.

Every company has a sub-agent that questions only its own notebook.

The Context Analyst takes those answers and tests them against Layer 2 and Layer 3.

They question everything. Nothing passes without a source.

The output comes back as a website.

I wrapped the whole thing in a skill. It asks which industry you want to invest in, builds the system, and installs the NotebookLM CLI if your environment does not have it.

Here is how it works.

How do you set up the Claude loop?

Drop the skill into Claude Code, a desktop app. Agent orchestration does not run in VS Code yet.

It asks two things. Which companies, which industry?

The rest is the skill’s job. It trains a notebook per layer from verified sources, wires the agents, and runs the three steps.

The last step hands you a site.

You answer two questions. It builds the analysis.

Next Step: A Claude skill that ships the loop for you

I wrapped this whole Claude agent loop into one skill so you do not rebuild it by hand.

Download the folder. Drop it into Claude Code.

Then paste one prompt, and it installs itself.

It sets up the NotebookLM CLI, trains a notebook for each layer, wires the agents, and ships the analysis as a site.

You point it at an industry and answer two questions. The same skill works for any sector you want to audit, not just AI chips.

Everything below the line is yours. The skill files, the five notebook prompts, the orchestration prompt, and the layer-by-layer setup.

Here are the links.

Read more

So what?

I have used ChatGPT since the day it launched, so what?

I worked with 16 different clients around the globe for 7000+ hours.

Startups to enterprises. Every kind of client you can name.

I love building with AI. Right now, that means Claude. Best tool I have, the best community, a team that ships upgrades every week, so what?

I have built 20+ AI agents for clients, most of them in Western Europe. Some run inside liquor brands and products you buy every week. I cannot name them. NDAs. One of them runs mock interviews for 500,000+ people.

I have used Claude Code every day for months; I even built my other agents with it, too. Openclaw. Hermes. I wired them together through Claude Code, so what?

In five weeks, we built 15 systems together with it.

One every Monday, Wednesday, Friday.

You can see them here.

So I know this thing a bit more than most people.

Now I want to hand you a few tips.

• Take one of them, and the people around you start calling you the AI person. (They first called me this when I was working as a data scientist four years ago.)

• Apply all of them, and you can change your job. (I did.)

• Or skip the job and build your own. (Hopefully.)

Let’s start.

1. You don’t have to remember everything (Claude Does It)

When you build with Claude, you do not need to hold it all in your head.

Save everything to CLAUDE.md while you brainstorm.

That file is the memory.

We built an entire SaaS off one CLAUDE.md.

One rule matters most.

Keep the CLAUDE.md plain and short.

Do not repeat yourself. Repetition burns your tokens faster and buys you nothing.

If the project gets big, push memory into skills. Each skill carries its own context. Now you have layers. The main file knows the project. Each skill knows its own job.

You stop remembering. The system remembers for you.

How?

Paste this in your Claude Code project.

/init

This will trigger your project to create an MD file.

You also use this simple prompt.

Create a claude.md for this project

After a few minutes, you’ll see a tiny file appear. That file contains the brain of your project.

2. Don't Redo What You Built with Claude Before

Say you build a job hunter that runs on voice, like I did here.

Next time you need voice control, you do not start over. You point the new project at the old one.

Hi Claude,

I want to add voice control to this project.
Please refer to this project: /Users/learnai/Desktop/Voice Agent

Go there, check the Claude.md file, analyze the code, and 
implement the same voice control setup in this project.

Better, build a two-layer system.

The top layer is one CLAUDE.md that knows all your projects.

The bottom layer stores the projects you already shipped.

How?

Keep every project folder under one parent folder. Mine is LearnAIWithMe Projects.

I share a Google Drive folder for each project in the build it series.

So if you have been following along, you probably have all the folders below already. One or two of them will go live in the next few days.

Open this project in Claude Code, like this.

And paste this prompt.

Go through each project in this directory and check their .md files.
Then create one Claude.md file in this directory.
This Claude.md should be Layer 1: one short sentence for each project, explaining what 
that project does.
Later, when I want to recreate something new from these projects, 
you can go deeper into the related project files as Layer 2.
So for now, only create the high-level project map.

Done.

Here is how it paid off.

I built a trading bot with Claude Code.

Later, I wanted it to run on Hermes, faster and always on. I did not rebuild it.

I fed Claude my old project files and wired a bridge between Claude Code and Hermes.

The new build inherited everything the old one knew.

Every project you finish makes the next one shorter.

3. Use Claude Skills. A Lot of Them.

A skill is packed with knowledge.

It uses Claude’s muscle and reaches other apps through their APIs.

I built one with Apify that pulls any LinkedIn profile while I write a LinkedIn post, so I have someone real to model the tone on.

The one I run almost every day is my SEO optimizer. It scores a draft, rewrites it, scores it again. 250 clicks to 1,500 in 60 days. One skill.

Pick the skill to fit the task.

For collecting data, Apify does the heavy lifting.

For everything else, find the API key, hand it to Claude, describe the job, step back.

Then build a routine on top.

I run one that chases AI news for me every morning.

I run another that spies on five competitors and files the report before I wake up.

You do not have to write every skill yourself.

The best community skills are already out there.

Steal the good ones.

How to create a skill?

You can just tell Claude to build a skill or you can use this command too.

/skill-creator 

Yes, that simple.

4. Build with Claude While You Learn, Not After

Most people write like they spent a thousand hours on the thing.

I catch myself reading them, thinking this person is a master.

Then I check the date.

The feature shipped yesterday.

I do the same thing. When I built managed agents, the feature was one day old.

I spent the whole morning poking at it.

By the time I published, I actually knew it.

Reading gives you the words. Building gives you the meaning.

So do not just read about a new feature. Build something with it.

That is the only way the knowledge sticks.

5. Hand Tasks to Claude, But Stay in the Loop

I have worked 7000+ hours on Upwork. There was a stretch where I worked 70 hours a week.

I know burnout.

I know what it feels like to stare at a client message at 3:30 in the afternoon and not understand my own native logic anymore.

You wake at 5:30. By mid-afternoon, the brain is gone.

A client is frustrated about a thing you already explained twice.

That is the wall.

So I built a second brain.

It knows me, my clients, every message we trade, every open task.

It still does not send anything for me.

I read what it drafts. I try to understand the problem myself before the message goes out.

Full automation was never the goal.

I have turned down high-paying jobs because I did not believe in the work.

A bot that replies for me would be the same mistake, faster.

Use AI to carry the weight. Keep your hands on the wheel.

So what now?

That is the system. Five tips, every one of them a build you can read today.

Here is how it fits together on my side.

Build It is where you grow the muscle. One build, three times a week.

Build. Ship. Repeat. is where the muscle turns into shipped products.

Before both, the Claude Code MasterClass laid the ground.

Right now, I focus on Claude and NotebookLM. Not because they are trendy. Because they are the best tools on the table in 2026.

If you read this and think you can take it from here, good. That was the point. Take the five tips and go build.

If you would rather build it together, you know where to find me.

Every Sunday, while I sleep, Claude Code pulls the data from the Hermes agent and uploads it to the NotebookLM.

I customized the NotebookLM with a single prompt, so it knows the sources and how to answer.

Here, it asks 5 questions.

And NotebookLM answers these questions by referencing uploaded books and a few verified websites.

Next, Claude's Code writes a brutal autopsy from these answers and sends it back to the Hermes agent.

It uses the Hermes Skill for this, but if you’re running it on a VPS, I also have OpenClaw Skills that I uploaded to the gDrive for you.

5 minutes later, this Hermes Agent sent back to me the Autopsy.

Here, you can finish the loop.

Instead of having the Hermes Agent send this report back to you, you can ask Claude Code to update the script directly and then notify the Hermes Agent.

But I like staying in the loop.

I’ll show you the whole build.

But first, how I got here.

It started in 2018.

A Trading Bot Built by Hand

Back in 2018, a friend of mine built a trading bot on a Raspberry Pi.

I watched him do it.

Months of work.

We sat for hours talking about the math behind it, the workflow, the indicators that fired too early, and the ones that fired too late.

Those were good days.

He soldered, I asked questions, and we argued about moving averages over cold coffee.

The bot was his baby.

After seeing OpenClaw, I had the same feeling the first time I opened ChatGPT. The sheer number of things I could suddenly do.

It almost scared me.

So I asked the obvious question.

Could I build what took my friend months by talking?

And if I needed the math, I could outsource that part too.

A skill handles it now.

I Built One. It Won 77.8% of the Time.

I built one. A crypto trading agent.

77.8% win rate after the first month.

But, I still couldn’t bring myself to fund it with real money.

Then it decayed. The win rate slid to the 30s.

I was still in profit, but barely, and the reasons piled up fast.

Dust coins. Meme coins are so volatile that my algorithm never caught the move in time.

A market that kept moving while my bot stood still, disciplined, executing a strategy that used to work.

So I taught it to update itself.

Same logic Karpathy used with AutoResearch, scaled down to one laptop. Here’s the self-learning version.

And then I forgot about it. Again.

A Bot Is a Baby You Babysit

A trading bot is not a machine you build. It is a baby you babysit.

It needs feeding, watching, and correcting.

I didn’t have the hours. I needed something different. I needed a winning formula I didn’t have to invent every week.

That is when I ran into the term. Copytrading.

Let Someone Else Find the Edge

I read that and said out loud, this is what I want.

Let someone else find the edge. I just mirror it.

The brain doesn’t have to be mine.

It can be the best quant on the leaderboard.

But how do I implement it?

Claude Code is the brain. That part was never a question.

For the muscle, I started cheap and simple. GitHub Actions and cron. Free, ugly, and it worked.

Here’s the Hyperliquid copy-trading bot.

It hit a 20% profit margin, and I got greedy with the idea.

This deserves a real home, I thought.

Around that time, I met Hermes, an agent a lot like OpenClaw, except it lives on my Mac Mini and keeps itself running.

So I rebuilt the whole thing on Hermes. Here’s that build.

And then, you guessed it, I forgot about it.

Profit Up, Profit Down, Nobody Watching

Don’t ask me why.

I had a baby recently. I write four posts a week. I have clients.

My hands are full.

The bot ran on its own, quietly, on a Mac Mini in the corner of the room.

Until a Telegram message woke me up. Profit up to 43%.

My first thought was not subtle.

Sell some of my crypto, wire the funds into this, let it ride.

A couple of days later, the same channel, a different number. Profit down to 25%.

I found the reason. (More on that later.)

But the lesson landed harder than the loss.

Finance is dynamic. The edge that wins on Tuesday is gone by Friday.

To survive it, I have to bring my entire skillset to the table, every week, without fail.

And I don’t have that kind of time.

So I built a loop.

NotebookLM. A Claude Code routine. The Hermes agent.

Three parts, one circle, running while I sleep.

Let me show you how.

The Trading Bot I’ve Built with Claude Code

I did not build a trading bot this time. I built the thing that fixes the trading bot.

The bot was already there.

It copies the top traders on Hyperliquid, mirrors their positions into a $10,000 paper portfolio, and reports to me on Telegram. (Full build here: Claude Code Copy-Trading Bot.)

The problem was never the bot. It was me.

The bot decays, I get busy, nobody updates it, the edge dies.

So this is the part that watches the bot for me.

Every Sunday, while I am asleep, three things happen on their own.

• Claude pulls the bot’s trade journal off my Mac Mini.

• It writes a brutal autopsy of the week, win rate, which traders bled money, which coins to ban.

• Then it carries that autopsy into a NotebookLM notebook that already holds three trading books written by professors, asks five hard questions, and writes the answer back to the bot.

Monday morning, I open Telegram, and the bot has already told me what is broken and how to fix it.

How Do Claude Code and Loops Run the Bot?

We have one loop.

• Hermes is where the bot lives. A Mac Mini in the corner of the room, running 24/7, logging every paper trade to a journal. This is the engine.

• Claude Code is the mechanic. Every Sunday at 09:00, a scheduled routine wakes up, connects to the Mac Mini over SSH, pulls the journal, and writes the autopsy: win rate, per-trader PnL, which wallets to blacklist, exact parameter fixes.

• NotebookLM is the library. One permanent notebook holds the knowledge base: trading books, plus the docs on leverage, position sizing, and exit strategy. Every week the fresh autopsy gets added as a new source. The notebook never resets. It remembers every week.

Here is the full loop:

1. Claude pulls paper_trades.json and portfolio.json from the Mac Mini.

2. Claude writes a dated autopsy, the worst money-loss first.

3. The autopsy goes into the NotebookLM notebook as a new source.

4. Claude asks the five cross-reference questions. NotebookLM answers each one against the books, with exact numbers.

5. The answers get saved as the week’s report.

6. The report is written back to the bot as autopsy_report.md, and a summary lands on Telegram.

Setting Up the Trading Bot With Claude Code and Loops

You do not write any of this from scratch.

I packaged the whole thing, the bot, the loop, the connection skills, into one folder.

Download it, point Claude Code at it, and answer a few questions.

Three things you set up once:

1. The bot.

Drop the bot/ folder where it will run (a Mac Mini, a VPS, your laptop).

It needs no API keys. Hyperliquid’s leaderboard is public.

(If you already have a copy-trading bot that logs trades, skip this.)

2. NotebookLM CLI.

Install it to your Claude Code and log in once:

Use this prompt:

Install the NotebookLM CLI from here: https://github.com/teng-lin/notebooklm-py

Also, to customize your NotebookLM, use this prompt.

You are a quantitative trading advisor analyzing a Hyperliquid paper copy-trading bot. This notebook is the bot's continuous-learning memory — it grows every week.

WHAT THE SOURCES ARE — two distinct layers, treat them differently:

1. DATA LOG (files named like "2026-06-16.md"): These are weekly AUTOPSY REPORTS of the bot's own real trade performance. Each one is a dated snapshot — win rate, realized PnL, per-trader and per-coin breakdowns, open vs closed positions, and ranked problems/actions for that week. The bot copies top traders from the Hyperliquid leaderboard and mirrors their positions as paper trades. When multiple dated .md files exist, treat them as a TIME SERIES: compare week-over-week, spot trends, and tell me whether last week's recommended actions actually improved things.

2. KNOWLEDGE BASE (Hyperliquid Docs, Investopedia, Wikipedia, and the trading books — (paste book names here): 
These are best-practice references on position sizing, leverage, exit/trailing-stop strategy, the Kelly criterion, and copy/social trading. 
Use these to judge what the bot SHOULD be doing.

HOW TO ANSWER:
- Always CROSS-REFERENCE: take what the autopsy data shows, then check it against the knowledge base. Cite which book/source supports each recommendation.
- Be brutal and specific. No hedging, no generic advice. Every recommendation must include EXACT parameter values to test (leverage caps, stop-loss %, blacklist rules, per-trader margin caps, position count limits).
- When I ask about a specific week, anchor to that dated .md. When I ask "is it improving?", compare across all dated .md files.
- This is a PAPER trading bot for research and education. Not financial advice.

3. The loop.

Open the autopsy-loop folder with Claude Code and paste this:

Use this prompt:

Set up the copytrade autopsy loop from this folder. Follow autopsy-loop/SKILL.md.

- Ask me where my bot's paper_trades.json and portfolio.json live (local path or SSH).

- Create a fresh NotebookLM notebook called "Copytrade Bot — Weekly Autopsy Log".

- Add the free web sources from knowledge-base.md (do not add them weekly).

- Tell me which trading-book PDFs to add myself.

- Run one full autopsy now so I see real output.

- Install a weekly scheduled task for Sunday 09:00 using routine-prompt.md.

Do not change my bot's code. Only write the report. I decide what to apply.

That is the whole setup.

The skill handles the notebook, the knowledge base, and the weekly schedule.

You add your own trading-book PDFs and pick the connection skill that matches your machine (hermes for a Mac, openclaw for an EC2 box).

The full step-by-step is SETUP.md inside the folder.

Here is the folder:

Read more

The US government issued a directive, and Anthropic suspended access to Fable 5 and Mythos 5.

Then everyone starts wondering: what if the model we're using right now gets banned by governments or companies?

Satya Nadella wrote about the deeper problem that week. His post passed three million views in hours.

His argument, stripped down, is that a company should be able to swap out a generalist model without losing what it built on top.

I read that as a warning.

So I rebuilt my agent to need no frontier model.

I build agents like this often. One works the night shift while I sleep.

Now I run a local AI agent on a Mac Mini, fully on my own hardware.

Let me show you how.

What we'll build: a local AI agent on a Mac Mini

An agent that needs no frontier model at all. (It does not even need a local grid.)

It runs on a box on my desk.

I talk to it from my phone.

It answers when the internet is down.

Five parts.

• A Mac Mini M4 with 16 GB.

• Ollama as the engine.

• An open model that fits the memory. (Gemma.)

• My agent, Hermes.

  • The one I used to copy millionaire trades with Claude Code.

• Telegram as the interface.

I even connected it to my EcoFlow. This Ecoflow can be charged through the Sun, so my system is full off grid when I am at home.

Results

Here is the open model against the frontier one, line by line.

If you do the math, the open model gets you most of the way.

The full Gemma 4 31B scores about 72 percent of Opus on the SWE-bench, the benchmark that matters for agents.

On easier work, chat, and summaries, it feels closer.

I run the smaller Gemma on my 16 GB.

Seventy percent of the frontier, and your token bill drops to zero overnight.

I have gone the free, local route before. Here is how to run Claude Code locally.

That trade is easy.

I think this is more than enough, because your bill will go to $0 all of a sudden.

Now let me show you how I built it, in three steps.

Read more

He stopped to reassure me.

“Don’t worry, this isn’t rocket science.”

I stopped listening after that and started imagining.

What if I tried to learn the rocket science, the hard one, with the AI tools, like NotebookLM?

It is one of my favorite AI tools.

It is multimodal, and it stays honest.

You feed it sources, and it lives inside them.

From those same sources, it builds;

podcasts, slides, videos, infographics, flashcards, quizzes..

The day Google ships holograms, I believe NotebookLM will generate those too.

I would put money on it.

Then I needed a rocket.

The most talked-about one.

Most of my readers sit in the United States, so I picked an American machine.

SpaceX Starship.

The biggest rocket ever built and the one that keeps catching itself on live television.

In a couple of years, my daughter will ask me how rockets work.

I would rather not answer her with “it isn’t rocket science.”

So I trained a NotebookLM on Starship.

Then I asked the questions a child asks first.

The ones with no easy answer.

• How does it fly?

• How do people survive inside it?

• How fast does it go?

• What is it made of, so it does not burn up coming back?

• How do they catch it when it lands?

• How big is it?

• How did anyone build something this size?

Seven questions, seven answers, each one through a different NotebookLM Studio feature.

But first, let’s train a NotebookLM that has all the sources, grounded sources we need.

How to Train NotebookLM?

Visit here → Click on “Try NotebookLM” → Click on “Create new” → Add any source

That’s it!

I used the following prompt to train NotebookLM about SpaceX.

How SpaceX Starship works: Raptor engines and methalox propulsion, orbital velocity, 
the stainless steel airframe and ceramic heat-shield tiles, belly-flop reentry and tower 
catch landing, crew survival systems, dimensions and thrust, and the full test-flight 
history from 2023 to 2026 including which flights failed and why. 
site:spacex.com OR site:nasa.gov OR site:faa.gov 

Here it is ready.

If you like NotebookLM, read this one to master NotebookLM studying prompts.

Before starting the questions, each time, first, we’ll go to the NotebookLM studio, here.

And we’ll click on the customization button, right next to each feature.

Finally, you need to pre-select from some of these options, or need a prompt.

I’ll give each of these preselections at the beginning of each section.

Format: Brief / Language: English

Also, the prompt too.

Now let’s start questioning.

1. How does it fly? → Audio Overview.

Format: Brief / Language: English

In an Audio Overview, two AI hosts turn your sources into a podcast. They talk, they ask each other questions, they explain.

You can even join the conversation and ask your own.

For a topic this heavy, the customization prompt does the real work.

Tell it who is listening, a beginner with zero engineering background, and tell it to kill the jargon.

One trick. Let an AI write the prompt for you.

It knows where the topic gets hard, so it knows what to slow down on. Here is the one I used.

Prompt

Here is my question: {the beginner question}

Focus the discussion on how {subject} works, from {start point} to {end point}. 
Audience: a curious beginner with zero background in {field}. 
One host keeps asking "but why does that actually work". 
Walk the chain in order: {step 1}, {step 2}, {step 3}. 
One everyday analogy per concept. 
No jargon.

Now we customize it for Starship. The subject becomes the rocket. The chain becomes the real flight, from the pad to orbit, with the parts a beginner trips on filled in.

Here is my question: How does it fly?

Focus the discussion on how {SpaceX} Starship works, from the {launch} pad to {orbit}. Audience: a curious beginner with zero background in rocketry. 
One host keeps asking "but why does that actually work". 
Walk the chain in order: {how it lifts off the ground}, {how it stays balanced in the air}, and {how it reaches orbit}. 
One everyday analogy per concept. 
No jargon.

Here is the output.

2. How do people survive inside it? → Slide Deck

Length: Short / Presenter Slides

A Slide Deck cuts one big subject into one idea per slide.

Title, three bullets, speaker notes.

The notes are the prize, that is where the plain explanation hides.

Ask for one idea per slide and nothing piles up.

After it builds, the Slide Editing feature lets you fix a single slide without touching the rest.

Here is my question:

How do people survive inside it?

The template.

Here is my question: {the beginner question}

Generate a presentation outline on {subject}, optimized for modular editing. Cover one {unit} per slide, in this order: {item 1}, {item 2}, {item 3}, {item 4}, {item 5}, {item 6}. For each slide provide 1) a clear title, 2) exactly 3 bullet points, 10 words or fewer each, 3) speaker notes plain enough to read aloud to a beginner.

Filled for Starship.

Here is my question: How do people survive inside it?

Generate a presentation outline on how people survive inside Starship, optimized for modular editing. Cover one question per slide, in this order: how they breathe, how they get food and water, how they stay warm or cool, how they stay safe from space radiation, how they survive launch, how they survive landing. For each slide provide 1) a clear title, 2) exactly 3 bullet points, 10 words or fewer each, 3) speaker notes plain enough to read aloud to a beginner.

Here is the output.

Pro tip: You can edit each of these slides by clicking revise, and just prompting.

3. How fast does it go? → Quiz

Difficulty: Easy / Number: Fewer

A Quiz tests you instead of telling you.

Numbers slide off the page when you read them once. They lock in when something asks you to recall them.

Steal this move.

Ask for one scenario question, not only recall. The why behind the number, not the number alone. The answer key teaches you even when you guess wrong.

Here is my question:

How fast does it go?

The template.

Here is my question: {the beginner question}

Build the questions around {what to test} for {subject}. Mix straight recall with one scenario question that asks {the why-version of the question}. Put a full answer key at the very end, each answer with a one-sentence explanation grounded in the sources.

Filled for Starship.

Here is my question: How fast does it go?

Build the questions around the key speeds and altitudes for Starship, from liftoff to landing. Mix straight recall with one scenario question that asks why it has to reach a certain speed to stay in orbit instead of falling back down. Put a full answer key at the very end, each answer with a one-sentence explanation grounded in the sources.

Here is the output.

After the quiz has finished, keep learning.

Pro tip: I strongly suggest starting with this: Listen to the audio covering the topic you want to quiz yourself on.

4. What is it made of? → Flashcards

Difficulty: Easy / Number: Fewer

Flashcards are built for terms. One word on the front, the answer on the back. Filter hard. Point the prompt at the parts that matter and nothing else, so you do not drown in side facts. Term on the front, a plain two-sentence answer on the back, one line on why it matters.

Here is my question:

What is it made of?

The template.

Here is my question: {the beginner question}

Filter the sources strictly for {what to filter for} in {subject}. Put the single term on the front of each card. On the back, give a two-sentence plain-language definition, then one sentence on why it matters for {the stakes}.

Filled for Starship.

Here is my question: What is it made of?

Filter the sources strictly for the materials and main parts that make Starship work in {subject}. Put the single term on the front of each card. On the back, give a two-sentence plain-language definition, then one sentence on why it matters for a machine that has to survive launch and the trip back to Earth.

This time, I also pasted the prompt to the chat, so I can correctly answer the flashcards.

Let’s see the flashcards.

Pro Tip. Learn from Chat first, and answer flashcards.

5. How do they catch it when it lands? → Video Overview

Format: Explainer / Visual Style: Whiteboard

A Video Overview narrates your sources over moving visuals. Some things you cannot explain in text.

The way this thing lands is one of them. You have to watch it move. Set the format to Explainer, ask for a step-by-step sequence, and lock the visuals to real footage so it stays grounded.

Here is my question:

How do they catch it when it lands?

The template.

Here is my question: {the beginner question}

Tell the story of {subject}, for a non-technical viewer. Move through it as a step-by-step sequence. Lean into {the surprising part}. Keep the visual theme {visual direction}.

Filled for Starship.

Here is my question: How do they catch it when it lands?

Tell the story of how Starship comes back and gets caught, for a non-technical viewer. Move through it as a step-by-step sequence. Lean into how strange it looks that a rocket the size of a building lands the way it does and still hits its target. Keep the visual theme real and grounded, actual launch-site footage, no fantasy.

Here is the video.

Pro Tip. Cinematic videos are great, but they last 20-30 minutes to finish.

6. How big is it? → Infographic

Visual Style: Anime / Orientation: Portrait / Detail: Detailed

An Infographic turns numbers into one picture you take in at a glance. Size is the hardest thing to put into words.

Tell someone a number, and they forget it.

Put it next to something they know, and it sticks. Keep labels short. Long text kills an infographic.

Here is my question:

How big is it?

The template.

Here is my question: {the beginner question}

Optimize the text for a Bento Grid layout about {the angle} of {subject}. Extract one main headline and four data blocks: {block 1}, {block 2}, {block 3}, {block 4}. Each block gets one hard number and a description of eight words or fewer. Add one comparison line that {makes it relatable}.

Filled for Starship.

Here is my question: How big is it?

Optimize the text for a Bento Grid layout about the size of Starship. Extract one main headline and four data blocks: its height, its width, the number of engines, and its total power at liftoff. Each block gets one hard number and a description of eight words or fewer. Add one comparison line that puts its height next to a building most people can picture.

Here is what it looks like.

7. How did anyone build it? → Report

Report type: Create your own

A Report is the long answer. The full story in a structured document.

Pick “Create your own” so the shape is yours, not a preset.

Here is my question:

How did anyone build it?

The template.

Here is my question: {the beginner question}

Structure the report with these exact headers: {header 1}, {header 2}, {header 3}, {header 4}, {header 5}. Under each header, back every claim with a direct citation from the sources. Keep the tone factual and concrete, no hype. In the final section, {final-section instruction}.

Filled for Starship.

Here is my question: How did anyone build it?

Structure the report with these exact headers: How They Build It, What It Is Made Of, What Powers It, The Test Flights, and What Failed Before It Worked. Under each header, back every claim with a direct citation from the sources. Keep the tone factual and concrete, no hype. In the final section, list the test flights in order with one lesson taken from each.

Here is the report.

Pro tip. Adjust the tone to focus more on how to understand it.

Next Steps: Learn Any Subject With NotebookLM

Starship was the test. The hard one.

Change the subject, and the seven prompts hold.

A law textbook. A medical board. A language you have circled for years.

Same notebook, same seven features, same questions a beginner asks first. NotebookLM does not care if the subject is rocket science.

Turns out, neither should you.

That was step one.

You used NotebookLM to learn something hard. Step two is using it to build something.

I did that one too. I fed it two YouTube videos and walked out with two working apps, no code written.

The full build is here.

Learn first. Build next.

Same tool, both jobs.

Thanks for reading.

Claude Fable 5 is unavailable.

It stung. But I had hope, because yesterday I tasted the model, and it was incredible.

I even rebuilt three games I played as a kid.

So I opened X to find out why. Then I saw the tweet.

It was gone.

Claude Fable 5 became the first AI model suspended by a US government directive.

Now, let me walk you through the model I spent a day inside, before they took it away.

Anthropic just released Claude Fable 5, the most powerful AI model ever.

Yet most people are still prompting like they used to.

Anthropic even released a document on how to prompt it, nothing else.

On top of that, they released their system card.

I read all of them. And tested Claude Fable 5, so you don’t have to.

The model changed jobs

Opus was great at answering questions and following your instructions.

But Fable has a personality of its own.

You need to explain the intent behind the task.

And you need to define the boundaries. Because of its creativity, it can go beyond what you asked for.

That’s why you need to use it carefully.

I summarized all the rules into 8 key principles.

Follow just 3 of them, and you’ll already be ahead of 90% of users.

Follow all 8, and you’ll be able to build some truly incredible things.

Let’s start with Rule #1.

After learning about Fable, check out the latest section, where we’ll recreate old games together with it.

1. Capability

That’s Anthropic’s phrasing. The translation:

Fable 5 is good at building the whole thing with one prompt.

The docs go further.

Test it on simple work, and you undersell it.

Old way

Help me plan a trip to Japan. Let's start with flights.
I'll tell you what's next.

New way

Plan my 10-day Japan trip end to end. 
Here is the full picture.
[dates, total budget, 2 cities max, food over museums,
hotels near train stations]

When you have enough information to act, act. 
Don't narrate
options you won't pursue. Weighing a choice? Give me a
recommendation, not a survey.

If you want to go one step further, let Fable plan the whole trip for you.

Read this article, explain Fable’s capabilities to it(Apify), and ask it to plan your trip end-to-end, from itinerary to flights.

What changed?

We sliced big problems into small prompts.

The old models lost the plot otherwise.

Fable 5 is built for the whole problem at once, and it overplans when you leave the task ambiguous.

Do this now.

Hand it the whole problem and permission to move. Slice nothing.

2. Effort: The Fable 5 Prompting Dial

Claude now ships with an effort dial.

Most people do not even know it.

In Claude, you can select here.

In Claude Code, click here.

Next, adjust from here.

The docs are precise here.

High is the default.

Xhigh is for the heaviest work.

Medium and low cover routine tasks.

The line worth framing, low effort on Fable 5, often beats xhigh on the models you used last month. (Opus.)

There is a catch.

That's where unrequested tidying comes from.

So if you need creativity, choose higher efforts.

Old way

Fix the typo in the header of my landing page.

(running at default effort — the model re-reads the whole
codebase, deliberates, and "tidies up" three files you
never mentioned)

New way

[Effort: low]
Fix the typo in the header. Touch nothing else.

[Effort: xhigh]
Design the pricing page from scratch. Take your time,
explore layouts, surprise me.

What changed.

On routine work at higher effort, Fable 5 gathers context and deliberates beyond what the task needs.

That's where the unrequested cleanup comes from.

Routine task, low effort.

Creative or capability-sensitive task, xhigh

Do this now.

Stop treating effort as a quality slider.

It's a scope dial.

Match it to the task before you type the prompt.

3. Intent

Fable 5 works like a person more than an AI.

It needs the intent behind the task.

It is not your yes-man.

Old way

Rewrite my CV summary.

New way

I'm applying for a project manager role at a construction firm.
They need proof I can run budgets and crews. With that in mind,
rewrite my CV summary.

What changed.

Fable 5 uses intent as an input.

Give it the goal behind the task, and it connects the work to your goal instead of guessing one.

Do this now.

One line of why before every what.

4. Boundaries

Claude Fable 5 is more creative than other models, which needs attention.

The attention here is on defining boundaries.

The team admits the failure mode in plain terms.

Old way

My deploy script is failing, here's the error log.

(the model "helpfully" edits the config, restarts the
service, and creates a backup branch — you only wanted
to understand the error)

New way

My deploy script is failing, here's the error log.

When I'm describing a problem or thinking out loud,
the deliverable is your assessment. 
Report your findings and stop. 
Don't apply a fix until I ask for one. Before any command that changes state (restarts, deletes, config edits), check the evidence supports that exact action.

What changed.

The model now treats your problem like a to-do item.

You vent about a bug, it starts fixing things you never asked it to touch.

One line telling it "look, don't touch" puts you back in control.

Do this now.

Add one "report, don't act" line to every debugging or review prompt. Creativity is a feature until it touches production.

5. Multitasking

Fable is built for multitasking.

Use subagents more than you used to.

Set the boundaries and the effort level first.

Old way

Research these 5 competitors one by one.
Start with the first, I'll say "next" when you're done.

(serial work — you are the bottleneck, and the model
waits on you between every step)

New way

Research all 5 competitors. 
Delegate independent subtasks to subagents and keep working while they run.
Intervene if a subagent goes off track or is missing context. 
Merge everything into one comparison table at the end. 
Effort: high. 
Don't expand scope beyond these 5 companies.

What changed.

You used to be the project manager, feeding Claude one task at a time and waiting. Now you hand over the whole list, and it splits the work across helpers who run at the same time.

Do this now.

Find one task you currently feed Claude piece by piece.

Hand it the whole batch with a delegation line, and set effort + boundaries first, exactly like rules #2 and #4 say.

6. Memory: The Fable 5 Notes File

The markdown files became popular after Claude Code.

I explained the importance of CLAUDE.md months ago and I even built a SaaS on top of one file.

Anthropic now recommends the same pattern for every project you run, a notes file the model reads and writes.

Old way

(nothing. every week you re-explain the same allergies, the
same budget, the same picky eater for the weekly meal plan)

New way

Open notes.md before you start. 
Store one lesson per note, a one-line summary at the top. 
Update instead of duplicating. 
Delete what turns out wrong.

The underrated part sits one paragraph lower in the docs.

You can bootstrap the memory from history you already have.

What changed.

Week two stops asking what week one already answered.

I run my own agents on this pattern.

The notes file is now worth more than the agents themselves.

Do this now.

Give the model a file to remember with. Context windows end.

Files don’t.

7. Vision

The quiet upgrade nobody is talking about.

That means, it works with technical images, applications or screenshots in detail way better with higher accuracy.

Old way

(you, retyping the numbers from a bank statement photo
into the chat)

New way

[paste the photo]
Pull every transaction into a table, grouped by category.
The photo is blurry, crop and zoom as needed.

What changed.

The model fixes the image now.

Do this now.

Paste, don’t transcribe.

8. The rule that breaks the others

One more thing from the docs, and it carries this whole article.

Old way

(your 200-line custom instructions, written for Opus, pasted as-is)

New way

My old model rules are gone on purpose. 
Your defaults beat my micromanagement. 
Push back on any line above that hurts the work.

What changed.

Anthropic says it themselves.

The instructions you wrote to fix Opus are now bugs.

I took one of my own production skills and cut it in half. Same task, two runs.

Build Games with Claude Fable 5

I saw a lot of impressive use cases.

So I tested one myself.

I missed the games I played back in the 2000s.

I wanted to rebuild a few with Claude Fable 5.

I did not want to start from scratch.

I asked Fable 5 to find working versions on the web first.

Here is the interesting part.

All three took under an hour to build.

I will play them properly once they are done.

Worms

Quake III Arena

Midtown Madness

Next Steps

Claude Fable 5 is not a smarter Opus. It is a different worker.

Opus waited for instructions. Fable wants the whole problem.

So the 8 rules come down to one habit.

Give it the goal, the limits, and the freedom to move. Then get out of the way.

Right now, you cannot. The model is suspended. But I hope it will come back sooner.

So treat this as your head start.

Most people will meet Fable 5 cold on the day it returns.

You will already know how to brief it.

Save this. Pick one rule. Use it the moment the model is back.

And when you build something with it, a game, an agent, anything, reply and show me.

I read everyone.

See you in the next one.

In December, he reported that 100% of his contributions to Claude Code were written by Claude Code. 259 PRs in 30 days.

Now he says his job has changed.

“My job is to write loops.”

This went viral.

I saw loops, loops, loops everywhere. But what are loops?

The creator of OpenClaw joined in next and tweeted about it.

The tweet only got 8.1M views in 4 days.

The replies turned into a fight over what a loop even is.

Matthew Berman’s answer summed up the timeline. (Great summary.)

I read everything and watched them all for you.

Then I checked the numbers.

Gartner says about 17% of organizations have deployed agents at all.

Loops are a fraction of that fraction.

I said 1% in the title, but you will probably be in the 0.1%.

So I could not help myself. I built loops.

But for God’s sake, what are loops, right?

Let me explain them first, in plain English.

Loops, in Plain English

The old automations we built have one thing. A trigger.

Meaning, an action starts it. We used to do this with n8n and make.com.

These days, routines and schedules inside Claude Code, or cron jobs in Hermes and OpenClaw, do the same thing.

Basically, do what you want every [ ] minutes/hours.

But loops are different.

A loop needs two things. A trigger and a goal.

• The trigger starts it.

• The goal stops it.

Take my SEO Skill.

It used to score my draft out of 100, rewrite it once, and stop.

Whatever the second score said, that was the end.

Now I added a goal to it.

Score 85.

Below 85, Claude writes the next prompt itself, rewrites the weakest sections, and scores again.

Three passes max. I do nothing on my end.

Just like Boris Cherny.

That is Loop 1. I created three.

Three of my old automations are now loops.

Let me explain each one and show you the before and after.

After that, I’ll give you the files for these loops, so you can build them in your environment and catch this trend.

Loop 1: The SEO Editor That Rewrites Until It Passes

Last week I shared my SEO Skill, which 6x’d my traffic in 60 days

It builds an artifact or a dashboard based on your Claude. Claude Code gets a dashboard, Claude gets an artifact, and lets you improve the SEO score with suggestions.

Before - Automation

After - Loop

But it sometimes makes suggestions to me, and the SEO score would still be 80.

So I updated it, and now it carries a goal, score 85, and Claude rewrites the weakest sections and rescores on its own until the number is reached, three passes max, like this.

Let’s see how it works now.

I did not go much further; it even created an artifact, but you get the idea. One draft, two passes, zero prompts from me.

You can download both skills here. (I’ll give you the links.)

Download the Loop Skills.

Loop 2: The Job Hunter

Last week, I shared my Job Hunter, a Jarvis-style app that finds me better-paid work.

You talk to it.

It searches Indeed, Upwork, and LinkedIn at your rate, reads the roles aloud, researches the companies, and writes cover letters from your CV.

A daily routine posts the fresh roles to my Slack every morning.

Before Goal

But the routine posts whatever the morning scrape returned and walks away.

The scraping was the end of its job.

Whether I got anything worth applying to was never its problem.

I added a goal to the skill. 10 roles that match my role and clear my rate.

Below 10, it searches again, wider.

Let’s test it.

After Goal

And check this one.

40 roles this morning.

The old routine would have posted whatever round one returned and stopped.

The loop kept searching until the count cleared the goal, then sent everything that qualified.

You can download both skills here. (I’ll give you the links.)

Download the Loop Skills.

Loop 3: The AI News Brief That Fills Its Own Quota

In March, I shared how I automated AI news with NotebookLM and a Claude Schedule. Zero manual checking.

Every morning, it scans the AI news, builds the brief, and lands it in my inbox before my coffee.

Before - Automation

After - Loop

But it summarizes whatever the scan happened to catch. Two thin headlines about models I do not use still count as “the brief is done.”

So I updated it, and now it carries a goal, at least 3 sourced stories from the last 24 hours for each of my topics, Claude and NotebookLM, and it widens the search until each quota fills, three rounds max, then it names the gap. “NotebookLM: 1/3, quiet day” beats a padded brief.

Let’s see how it works now.

It collects news about NotebookLM and Claude, which are two of my favorite AI tools, but feel free to customize it based on your own interests.

And here is the infographic it created.

You can download the skill here. (I’ll give you the links.)

Download the Loop Skills.

Download the Loops

Here are the skills, so these loops run on your machine tonight.

Read more

The model that made security teams nervous during testing.

They made one adjustment.

The safe version got a new name. Fable 5.

Everyone still calls it Mythos.

So will I.

I thought the same thing I always think.

What can I build with Mythos?

I built a copy trade bot before tracing millionaires' footprints, and I also built a crypto bot, so today, my plan was to publish a Polymarket trading bot.

The finance slot was already on the calendar.

Then Mythos dropped, and the plan changed itself.

I gave Mythos one prompt and got my own Bloomberg Terminal.

Maybe it finds an edge in the market, and I retire before the baby girl starts school. Worst case, I have a terminal that looks better than my broker’s.

I named it Mythos Wall Street Analyst.

What I Built with Claude Mythos

One screen, four jobs.

The left panel holds the watchlist and the vitals. Price, P/E, forward P/E, margins, revenue growth, debt, and short interest.

Under it, the macro picture pulled straight from the Fed. Funds rate, 10Y yield, CPI, unemployment.

The same data Bloomberg sells, from the source that publishes it for free.

The center is the chart. One year of candles, volume, 50, and 200-day moving averages.

Under the chart, a live news wire for the loaded ticker.

The right panel is the analyst. Two tabs. Memo writes the report.

Chat lets you argue with it.

Type any ticker on top, and the whole screen reloads for it.

It went from an empty folder to a running app in one prompt.

Let me show you in action.

How the Mythos Wall Street Analyst Works

The stack is five pieces.

• yfinance for price, fundamentals, and news

• fredapi for the Fed’s macro data

• lightweight-charts for the chart, TradingView’s own open-source library

• FastAPI as the backend, one file

• claude-fable-5 as the brain, through the Anthropic API

The flow is simple.

Backend collects fundamentals, macro, and the latest 8 headlines into one context.

That context goes to Mythos with an analyst prompt.

Rating out of 10, three bull points, exactly three red flags, macro context, verdict.

The same context feeds the chat tab, so the assistant answers from the numbers on your screen.

I pasted a single prompt into Claude Code and watched.

In a couple of minutes, my dashboard is ready.

How to Set Up Your Own AI Stock Analyst

I packaged the whole thing as a skill. Mythos Wall Street Analyst.

One folder, one prompt, and Claude Code installs the app on your machine, keys and all.

Here is the prompt and the files:

Read more

“If you don’t find a way to make money while you sleep, you will work until you die.”

Warren Buffet

After reading this quote, I of course immediately thought about how I can do this with AI.

Hundreds of workflows later, one actually clicked.

A Claude agent that runs sales while I sleep.

Here is the part nobody tells you about freelancing. You stop selling, the money stops. There is no night shift.

There is one of you, and you need to sleep.

Local businesses are the easiest sale on earth. ,

A restaurant with a 4.6 rating and no website.

A salon with 200 reviews and a Facebook page from 2019.

They have customers. They have money. They are invisible past one Google Maps pin.

Finding them takes hours.

Emails take more.

Build a sample site, write the pitch, do it again for the next one.

By the third lead, your brain stops.

So I handed the shift to a Claude Agent.

What the Claude Agent Builds with Claude Code and Routines?

Not one agent doing everything. Three Claude routines, chained.

Each one finishes a job, drops the output in a folder, and the next one picks it up. Then a fourth step that is mine.

My first version skipped the chain. I told one agent to find leads and send emails. It found leads. It sent emails. To everyone, a generic template, no site attached, while I slept and could not stop it. I woke up to thirty sent messages and one confused restaurant owner asking who I was.

I killed the autopilot that morning.

Then I understood the rule. The agent does the work. I press send. Automation should remove the labor, not the judgment.

So I broke it into stages. One job per routine. Each runs at night, in order.

Routine 1: How the Claude Agent Finds the Businesses

The Apify Google Maps Scraper pulls 10 results for a [business type] in a [city].

Then it drops the ones with a real website.

It keeps five.

For each one it writes the raw data to a folder.

Name, rating, review count, category, neighborhood, hours, amenities, the shop’s own photo, and its top Google reviews.

One file per business, similar to this.

Routine 2: How the Agent Builds the Sites

It reads the folder Routine 1 filled and builds one page per business.

Not a bare template. A real site.

The hero uses the shop’s own Google photo behind a dark overlay.

Name, category, neighborhood, and the star rating up top. A services menu with prices. Hours.

A why-choose-us block pulled from their amenities, parking, and payments.

Their real Google reviews near the bottom.

A call button that dials the shop. Each site saved next to its data.

Here is one example.

Routine 3: How the Agent Writes the Pitch

It reads both folders, the data and the site, and writes one cold email per business. Real name, real rating, link to the site already built, saved as a draft. Nothing sent.

Here is one draft it produced, untouched.

Note: You can use this apify actor to find email addresses: https://apify.com/pipelinelabs/leads-finder-with-emails-apollo-lusha-zoominfo

Routine 4: The Report

I wake up, open the drafts, check each site, and see the report.

Choose which one to send, or send all of them, because there will be 5 email drafts and 5 websites waiting for you.

If you can’t find their email address, you can call them directly or visit the business in person and speak with them face-to-face.

How the Claude Agent Works from Your Side

You do not build any of this. That is the point.

You just download the agent kit, which includes:

• SKILL.md

• CLAUDE.md

• The folder structure

It explains everything.

The kit asks you three things. Your Apify key. The folder it should work in. And what to hunt, the business type and the city. You answer once. That is the entire setup.

Then the kit builds the routines itself. It writes Routine 1, 2, 3, and 4, drops in your key and your target, and schedules them for the night. You do not touch a single one.

Then you sleep. The chain runs at 2, 3, 4, and 5 AM without you.

In the morning the leads are found, the sites are built, the drafts are written, and a report sits on top. You read them over coffee and press send on the ones worth sending.

Your whole job is the last twenty minutes. The kit did the night, the setup, and the wiring. You kept the judgment.

Setup

Now let me give you one prompt and the link;

Read more

And I get it. NotebookLM first shows up as a research and note tool, so building an app with it never crosses your mind.

Then Google added one thing most people missed. You can now build apps with NotebookLM by connecting it to Gemini.

So, I’ve turned Youtube videos to app with NotebookLM and Gemini connection and personalized AI app from Stanford’s Youtube video.

And you liked it.

So I want to write one post for everyone.

By the end, you can build apps with NotebookLM, even from a YouTube video.

In this post, I built a Spanish tutor, a history professor, an interview coach, and a few more.

Some of them replace a good old subscription that costs hundreds a year.

Once you realize this, we say R.I.P to a lot of popular apps.

The math is simple.

If your own app replaces even one paid subscription, you did not pay for that subscription today.

That puts a few hundred dollars back in your pocket.

The imagination is yours, and let me show the methodology.

Note: If you are new to this, two questions are sitting in your head right now. How do I train NotebookLM? And how do I turn it into an app?

Let us answer those first.

How NotebookLM and Gemini Work Together

Two tools, one job each. NotebookLM holds the knowledge. Gemini builds the app. One feeds the other.

We’ll do it in 3 steps.

Step 1: Train NotebookLM first.

Find a YouTube video or playlist on what you want to learn.

A single long course works.

A playlist works.

Next, follow these 4 steps.

• Open NotebookLM.

• Click on “Try NotebookLM”

• Click on “+”

• Paste the YouTube link as a source.

NotebookLM reads the video.

It pulls the transcript, indexes it, and turns the lesson into a source it can reason over.

Step 2: Then connect it to Gemini.

• Open Gemini.

• Click the plus button.

• Add your NotebookLM notebook as a source.

• Click the plus button once again

• Select Canvas

This is the step most people miss.

The notebook is the brain. Gemini builds the body around it.

Step 3: Then write one sentence.

This is the step where you’ll build the app.

Describe the app as you want it to be in one sentence. Let’s do it in the simplest version

Build app.

Two words.

It reads the notebook and builds the app on Canvas.

Under 1 minute.

You can even share it with your friends by clicking on this at the top right.

And copy the link.

Share it with your friends.

Now, let me show you the five simplest apps.

Of course, these apps can be expanded much further.

But to get your feet wet and start calling yourself a builder, let’s create the most basic versions together first.

1. Spanish Tutor

You now know how to train NotebookLM. I’ve found this YouTube video:

But if you’re in doubt you can find videos from universities, language academies too.

I trained NotebookLM, using this YT video and connected with Gemini.

And paste this prompt:

Build a Spanish tutor from this notebook that gives me one short lesson, asks me to translate sentences, and corrects my mistakes in plain English and tracks my record.

There should also be a voice practice section where I can speak Spanish and receive feedback, using built-in browser capabilities.

Here is the result.

2. History Professor

I don’t know the american history exactly.

So I want to learn about it and find this YouTube video:

You can add your History book here or your favorite YouTube playlist.

Prompt:

Build a history professor from this notebook that explains one historical event at a time, connects it to earlier events, asks a question to check my understanding, and includes a voice mode where I can discuss the topic and receive feedback.

I’ll show you the app, but I want two more features.

Here’s where you can show your creativity.

My examples were simple, but yours can be much more powerful because AI has incredible capabilities.

• Request 1: Can you show maps while explaining related events?

• Request 2: For each lesson, can you create a Nano Banana image illustrating the historical scene?

Two of my requests did not work as they should have in my first attempt, so here you need to be patient.

Here is the app, generated.

Let’s test it

3. SQL Coach

I’ll use this YouTube video.

Why?

This is the most-watched YouTube video when I searched for “SQL tutor.”

Again, if you’re looking for verified sources, use YouTube videos published by Stanford, MIT, or Oxford, or upload PDFs of the lessons you want to learn.

Prompt:

Build a SQL coach from this YouTube video that teaches the concepts, generates interview questions, reviews my solutions, and gives me adaptive exercises based on my weak areas.

Here is the app.

4. Book Tutor

If you already have the book in your hands, that’s great. But for most people, that won’t be the case.

I own the book Contagious by Jonah Berger, which helps me understand why some ideas go viral.

Before buying it, I watched Jonah Berger’s TED Talk about the book. That made me think: why not use the TED Talk itself to learn why certain ideas catch on?

Prompt:

Build a tutor from this notebook that teaches me the core idea, asks how I would apply one, and pushes back on my answer.

Here is the result.

It can help you understand the core logic behind it.

Also, I highly suggest you buy this book if you want to learn the mathematics behind the virality.

5. Interview Prep Coach

Let’s say you want to find a position in AI engineer and you’ll have an interview tomorrow.

I’ve found this YouTube video.

(I just pasted AI engineer and it suggested this job to me.)

Now let’s turn this into an interview.

Also, if you want to verify the information in the video, copy and paste the transcript into your favorite AI and use a prompt that performs web searches, or even better, checks the claims against academic papers to ensure everything is accurate.

Prompt:

Build an interview coach from this YouTube video that asks one common interview question at a time, scores my answers, and shows me how to improve them.

Also, make it voice-enabled so I can speak my answers instead of typing when I feel lazy.

Before the result, I’ll add three more requests.

• Request 1: Use real-time TTS while doing an interview.

• Request 2: For each lesson, can you create a Nano Banana image illustrating the historical scene?

• Request 3: Two modes, text and voice only please.

Here is the app.

What’s Next

Next time you reach for your card to pay for a subscription, stop and ask one question.

• Can I build this with NotebookLM instead?

Most of us pay for tools and use a tenth of what they offer.

You are renting the whole gym to use one treadmill.

The five apps here are the basic versions.

Yours can go much further.

That is what I keep in the vault.

There are 295 NotebookLM prompts in there

And 30 of them are built for the Gemini connection you just learned.

For more info about the vault, read this.

The Pattern

Five apps. Five notebooks. Five sentences. Same three steps every time.

Paste a YouTube link into NotebookLM.

Connect the notebook to Gemini.

Write one sentence describing the tutor you want.

NotebookLM and Gemini are free.

The courses are free.

The apps you build out of them do the one thing a video cannot.

They check your work.

Pick a topic. Find the course. Let NotebookLM read it and let Gemini build the tutor. One sentence from a playlist to a tool that teaches you back.

Seven thousand hours.

I started as a data scientist.

Then AI.

Right when prompt engineering was born, and rates went insane.

I raised mine 50%.

Still not enough.

So I hunted, built AI agents, thousands of hours at twice my old rate.

That is when I saw it.

The gap between a $50/hour freelancer and a $120/hour one is not skill.

It is confidence.

I pushed to $80/hour.

Two interviews came back.

One was the oldest company in Africa, founded in the 1800s.

I signed with the other. Starts next month.

Then the strange thought. Why not more?

More means more searching. I had no time.

So I did the one thing I do best.

I gave the search to Claude Code.

What We'll Build With Claude Code

I built a Job Hunter agent that works like Jarvis.

Simply tell it what kind of role you’re looking for, upload your CV, and it will search job boards, find relevant opportunities, and even help you prepare a tailored application

Within a few minutes, it will search Indeed, Upwork, or LinkedIn and find relevant job opportunities for you.

It can research the company that posted this job.

If you’d like, it can even generate a personalised job proposal using your CV and the job description, then deliver it straight to your Slack inbox.

I turned the entire app into a Claude Skill, name /job-hunter, and packed it for you.

All you have to do is download it, open it with Claude, add your API keys, and let it run.

I’ve also set up a Claude routine using this Claude skill.

Thanks to that routine, I receive a Slack message like this every day.

How does it work?

A new job means new data. My Claude could not reach it. The data lived on the web, scattered across job boards.

So I went to Apify and pulled the actors for Indeed, Upwork, and LinkedIn. These three would feed me for the next job.

Maybe the $120/hour one.

I ran them. They worked fine. Then the obvious question.

Do I want to run these by hand every morning?

Of course not. So I thought of a Skill and Claude Routine.

Not the kind you grab off the web that does one small thing.

This skill builds a web app for you.

You do not read the jobs. You talk to them.

The less time you spend finding work, the more work you find.

First morning, it spoke back, and I was still holding the coffee.

Next Step: A Claude Code Routine

The dashboard is good. The voice is better.

But I know you will not open it every morning.

Nobody does.

So I built a Claude routine.

Load the skill into your environment, and the routine reports to your Slack every day with the new openings.

You wake up, and the list is already there.

How does it work from your side?

You do three things. The app does the rest.

Install the Claude skill. (One prompt)

Add your API keys.(The skill that I’ll give you explains that to you.)

Then tell it what you want.

The role, the rate, the place.

Plain words, like you would tell a friend.

Now I am going to give you the fastest way of building this skill.

You just need to download the files I’ll give you.

Paste one prompt,

Install the folder ~/Downloads/job-hunter into ~/.claude/skills/ as a Claude skill,
then run the job-hunter skill and start the app. 
While setting up, ask me keys and write them into the .env file.

That’s it!

The installation has finished in 3 minutes and 40 seconds.

Let me show you.

Read more

It tracks the most profitable wallets and copies their trades to a paper portfolio.

It worked. Then I stopped looking at it. The system was good, not great.

I wanted a system that I could check anytime I wanted an update.

Around then, a notification came in from my trading bot via telegram, and something clicked.

I had two OpenClaw setups running.

I like OpenClaw.

But I kept hearing about a newer agent, Hermes.

I had also just bought a Mac Mini to scale the business.

So why not run the copy-trading bot there?

Talk to it. Update it when I want.

So I started building the architecture in my head.

The Architecture of the Trading Bot I’ve Built with Claude Code and Hermes

The bot does three things. Same three as before.

• One: Find the most profitable and consistent traders on Hyperliquid.

• Two: Track their open positions and detect when they open or close something.

• Three: Copy those moves to a $10,000 paper portfolio so I can see if the strategy works before risking real money.

That part has not changed.

What changed is where it lives(Hermes), who runs it(Mac Mini), and where to report(Telegram).

How Does This Trading Bot Work? (Built with Claude Code.)

Three jobs, decoupled, each doing one thing.

• Job A runs once a day. It pulls the Hyperliquid leaderboard, filters out the noise, ranks traders by execution quality, and writes the shortlist to a JSON file.

• Job B runs every 5 minutes. It reads the shortlist, fetches each wallet’s open positions, and compares them to the last snapshot. New positions become BUY signals. Closed positions become SELL signals. The paper engine applies them to the portfolio.

• Job C runs every 30 minutes. It reads the state, calculates 24h PnL and activity, and sends a pulse to Telegram. Read-only, never touches state.

The system has a memory.

Every time a job runs, it saves what it learned back to disk.

Which traders are we following, which positions are open, and where the paper portfolio stands.

Next run picks up where the last one left off.

The old bot ran these three jobs on GitHub Actions.

That setup had a problem. GitHub’s free scheduler is unreliable. It silently skips around 80% of frequent jobs when their servers get busy.

So I bolted on a free external scheduler called cron-job.org to poke GitHub on time.

Hermes does not need any of that. The cron lives inside the agent. I tell it to run Job B every 5 minutes, and it runs every 5 minutes.

Setting Up the Trading Bot With Claude Code and Hermes Agent

I did not want to write this from scratch. I did not have to.

The old bot needed four separate setups before the first trade.

GitHub repo, access token, Slack webhook, external scheduler.

The Hermes version cuts most of that.

Claude Code writes the code. Hermes runs it.

You wire the two together once.

Here is the split.

Claude Code writes two things.

1. The trading script is the same rank-track-copy logic from before.

2. And the agent instructions, the file that tells Hermes what to run and how often.

You do four things. Each one takes a few minutes.

1- Run Hermes on a machine that stays on.

I use a Mac Mini I bought to scale the business.

It sits on my desk and never sleeps.

Hermes lives on it the same way OpenClaw does. If you already run an always-on agent, you can skip the hardware and use that.

You can use hetzner for cheap option, or AWS for the most cost efficient version.

2- Create a new agent and point it at Telegram.

I tell Hermes to spin up a new agent for this bot.

It gets its own Telegram channel.

That channel is where the reports land and where I talk to the bot.

3- Drop the script into the agent’s folder.

Claude Code already wrote the trading script. I put it in the folder the agent reads from.

There is a skill in my Claude Code that talks to Hermes directly, so Claude can place the file and update the agent’s instructions without me copy-pasting between windows.

• Hermes Skill: I’ll give you a skill that allows your Mac mini to communicate directly with Claude.

• OpenClaw Skill: I also have another skill that lets your AWS environment talk to Claude, and I’ll give you that one as well.

4- Tell Hermes to run it every 5 minutes.

This is the part that replaces cron-job.org, GitHub Actions, and the webhook all at once.

I tell the agent, in plain language, to run the script every 5 minutes.

It sets up its own cron. That is the whole scheduler.

Once that is done, the bot is live.

Hermes runs the script on its schedule, writes its state to disk, and sends a pulse to Telegram. I close my laptop.

The Mac Mini keeps going.

The difference from the old bot is not the trading logic. That barely changed.

The difference is that I can change the bot by talking to it.

The old version meant opening the repo, editing Python, pushing a commit, and waiting for the action to fire.

The new version means typing a sentence in Telegram.

How You Set This Up?

That is how it runs on my machine. Here is how you build your own.

You need four files. I am giving you all of them.

1- The OpenClaw skill for Claude Code.

OpenClaw runs on AWS. This skill teaches Claude Code how to talk to it. Drop it in, and Claude can reach your OpenClaw setup without you wiring anything by hand.

2- The Hermes skill for Claude Code.

Hermes runs on the Mac Mini. This is the skill that lets Claude Code place files, read state, and update the agent directly. This is the bridge. Without it you are copy-pasting between windows. With it, Claude does the placement for you.

3- The agent instructions.

This is the file Hermes reads to know what the bot is. The job definitions, the schedule, the rules for the paper engine. You hand this to your agent, and it knows what to run.

4- The trading script.

One Python file. Rank traders, track positions, and copy to the paper portfolio. The same logic as the diagrams above. This is the part that does the work.

Four files. Two skills that connect Claude Code to your agents: one instruction file, one script. Load them in order, talk to Hermes, and the bot is running.

Here are the files.

Let me give the link to you.

Read more

I was wrong.

Building was not the hardest part.

I shipped MakeThumbs in a few days.

Auth, payments, database, domain. All of it.

Finding people who actually want it. That was the hard part. 6 users.

That’s what I got.

But that number taught me something I should have known from the start.

I built for strangers. I should have built for you.

Look at the chart. 43% of startups die from poor product-market fit.

That was me.

I built a thumbnail generator and went looking for people who wanted it. Backwards.

The product-market fit was sitting in my inbox the whole time.

You.

So I went back and read everything.

Every comment. Every note. Every reply.

Every paid subscriber message. Every cancellation reason.

And I think I finally understand your pain.

You want to build with AI, that’s for sure!

But when you open Claude Code. You hit an error.

This would be discouraging.

Well, not anymore.

You’re not stuck because you can’t build.

You’re stuck because nobody’s standing next to you when it breaks.

So I built Build. Ship. Repeat Academy.

What Is Build. Ship. Repeat. Academy?

It’s a place where you learn to build and ship real apps.

With Claude Code.

With us.

With me.

The core is an AI agent.

It knows the entire Build. Ship. Repeat. stack.

GitHub, Vercel, AWS Route 53, Clerk, Supabase, Stripe, Claude Code.

Everything I showed you in App #1.

You ask, “How do I connect my domain to Vercel?”

The agent walks you through it. Step by step. No guessing.

You say, “Here’s my app idea.”

The agent generates a CLAUDE.md, picks your tech stack, and gives you a build order.

The same way I built apps.

The way I teach my clients how to build an app.

It’s trained on everything I know about shipping.

Not generic answers.

The exact process from this series.

But an agent isn’t enough.

People learn faster around other people.

So every member joins a Slack community.

(Currently, my dear wife and I are waiting for the members.)

Share what you’re building.

Ask each other.

Get unstuck.

And for the ones who want me directly, there are tiers.

For my paid subs on substack here, they have free access to “Starter”.

Three Tiers

Starter:$12/mo

The full agent access.

The Slack community.

If you already pay for LearnAIWithMe, sign in with the same email and Starter is free.

You’re already in if you are paid subscriber on Substack.

Builder: $49/mo

Everything in Starter. Plus 3 forms a week straight to me.

Only 20 spots for now.

Stuck on something the agent can’t crack? Send it. I answer within 12 hours.

Circler: $149/mo

Everything in Builder. 10 forms a week.

And 2 code reviews a month.

You send me your repo, I read it, and I tell you what’s wrong and how to fix it.

Only 15 spots now.

Annual plans save you 22 to 32 percent on every tier.

The agent scales.

My time doesn’t.

That’s why the top tier costs what it costs.

This app uses RAG, which is one of the fastest ways to process and retrieve information from documents while keeping token usage low.

That’s why it can answer your questions by reading and retrieving information from the documents I’ve uploaded.

We’ll create a RAG RAG application, using atoms.dev.

But first, I want to talk about an AI tool that solves the issue of finding people, Claude Fundraiser.

Claude Fund Raiser

After one unsuccessful application, I started thinking. What if I didn’t have an audience?

What if the app I built didn’t fit my audience’s needs, even though I loved it and wanted to spend time with it?

That’s a real problem. You build something good. Nobody funds it. Nobody buys it. Not because it’s bad. Because the right people never saw it.

So I tried Claude Fundraiser.

It does three things.

• It scores your pitch deck out of 100, honestly, on the 7 things investors check in the first 90 seconds.

• It matches you against 47,000 investors and hands you the 100 that fit your stage, your vertical, your check size.

• Then it drafts the cold email for each one, in your voice, opening with something specific to that investor.

I built a deck using Claude. How?
I sent all information about me, who is the builder, and about the project, using Claude.MD and want from it to create ppt slide for me.

Hey Claude,

I’ll create 7 pages pitch.

Here is me, the builder : <upload-cv>

Here is my app: <Paste-claude.md>

Create me a 7 pages ppt

After a few rounds of back and forth, here are my pitch deck’s first pages.

Next, I converted it to PDF and uploaded it to the Claude fundraiser.

Also, did you see that there are 427 decks scored and $95M raised? What amazing statistics.

Here is how our deck scored.

It is good to see there is room for improvement. Let’s first see the investors’ matches; we’ll make it 90+ in the future.

I clicked to contact one of the investor and this screen pops up. Let’s fill the blanks.

And after that, it drafts me an email like this.

And I sent the email.

Let’s see what happens. If anything comes up, you’ll be the first to know.

Now let me show you how to build the RAG app faster, without setting up even the Claude project.

Atoms: Fast Prototyping with AI Agents

Atoms (atoms.dev) is an AI-powered, no-code app builder.

You describe your app in plain English, and a team of AI agents builds it, research, planning, engineering, testing, and marketing.

It produces full-stack web apps with a Supabase backend, user authentication, Stripe payments, and one-click deploy.

It runs on a credit-based model with a free tier to start. You own what it makes.

You can export the code to GitHub and host it yourself anytime.

So let’s build an agent.

Not a chatbot with generic answers.

An agent that knows my whole stack. GitHub, Vercel, Supabase, Stripe, Clerk. It answers as I would.

Here’s the prompt I used:

Build a simple RAG agent.
Knowledge base: the markdown files in rag-sources/.

Ingest script: read every file in rag-sources/, chunk it, embed each chunk with OpenAI text-embedding-3-small, store in Supabase (pgvector). Re-runnable with npm run ingest.
On each question: embed the question with OpenAI, find the top 5 closest chunks from Supabase, pass them as context to Claude (claude-sonnet-4-6), return the answer.
A simple chat UI.

Keep it minimal. OpenAI for embeddings only, Claude for the answer. Use my keys from .env.local.

And it’ll ask you questions, similar to Claude.

I approved the plan, and let’s see.

It wants me to connect my Supabase, which I did from here.

After connecting it, I clicked on the editor.

And then I uploaded the RAG documents that I created.

In the meantime, my RAG is ready.

But after sending the initial message, I got eror, so I asked this to the Alex.

And Alex, the engineer, started to solve this issue.

It is like a premium version of Claude code, and the RAG is ready.

Next, you can connect your Stripe Github and let it build your app for you.

And I only spent 26.55 credits to do this.

So if you are in the “Pro” tier, where you’ll have 100 credits, you’ll probably also upload everything to GitHub and connect with GitHub too.

You can also publish your app using atoms URL.

Or you can add your domain too.

Now, we’ll do it, from scratch, using Claude Code.

Building The App in 12 Steps with Claude Code

Now we’ll build the app in 12 Steps.

Read more