Big Idea

The argument in one line.

Compiling an expert's public writing and talks into a linked wiki, then extracting quote-backed rules, turns Claude into an agent that teaches and reasons like that expert instead of just writing code.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code regularly and want it to actually explain its reasoning instead of just handing you a working answer.
You've got a go-to teacher, author, or coach whose explanations click for you, and you wish Claude explained things the same way.
You ship AI-written code to clients and need a way to catch confident-but-wrong answers before they go out the door.
You're curious how to turn a public figure's blogs, lectures, and social posts into a structured, queryable knowledge base.

SKIP IF…

You want a voice or personality clone of a public figure, not a reasoning and teaching framework built from their ideas.
You're not willing to run multi-step Claude Code prompts and wire up a wiki, a subagent, a skill, and a verification hook.

TL;DR

The full version, fast.

Nate Herk shows how to turn Andrej Karpathy's public writing, lectures, and posts into a Claude Code agent that teaches like him rather than just writing code. The process has four steps: crawl everything Karpathy has published (blogs, YouTube transcripts, GitHub, X posts) into a raw folder, compile that raw material into an interconnected Obsidian wiki using Karpathy's own wiki-building method, extract seven rules from the wiki with each one backed by an exact quote and source, then turn those rules into a Claude Code subagent and a skill. A final hook forces the agent to run and test its own code before it's allowed to answer, so it can't just claim something works.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:18

01 · Karpathy's brain

Cold open and premise: not a voice clone, a Claude agent built from Karpathy's own thinking patterns.

00:18 – 01:07

02 · Who is he?

Karpathy's background: OpenAI founding member, five years running AI/computer vision at Tesla, Eureka Labs founder, now on Anthropic's pre-training team.

01:07 – 02:47

03 · Why bother?

The problem with asking Claude to explain things cold: it over-explains, invents details, and ships code you can't fix. The fix is borrowing a real expert's judgment.

02:47 – 03:50

04 · 700K words

Crawling Karpathy's blogs, lecture captions, GitHub repos, and X posts with free tools (YouTube Transcript API, yt-dlp) plus a cheap paid API for X, run as parallel agents.

03:50 – 05:37

05 · His own wiki

Compiling the raw folder into a linked Obsidian wiki using Karpathy's own publicly posted wiki-building method: an index, a log, backlinks, one page per concept.

05:37 – 06:42

06 · 7 rules

Extracting seven rules from the wiki, each required to appear in at least two sources and backed by an exact quote: build it or you don't understand it, first order term first, predict then run then compare, show the broken version first, prove it don't claim it, say what you assumed, simpler wins.

06:42 – 07:38

07 · Mini Karpathy

Turning the seven rules into a Claude Code subagent plus a /karpathy-teach skill that grades any answer against the rule checklist before showing it.

07:38 – 08:48

08 · Run it first

Adding a verification hook that blocks the agent from answering until it has run and tested its own code, demonstrated live on a byte-pair tokenizer build.

08:48 – 10:45

09 · Would it ship?

Testing the agent as a client-readiness reviewer, a terminal-specific crash it predicts and catches, the /karpathy-ingest update loop, and the closing thesis on outsourcing thinking vs. understanding.

Atomic Insights

Lines worth screenshotting.

An agent built from 700,000 words of one expert's blogs, lectures, and posts can be crawled into a raw folder in under an hour by running one agent per source in parallel.
Compiling raw source material into a wiki, with an index, backlinks, and one page per concept, beats dumping notes into Claude because it turns isolated facts into a queryable relationship map.
A rule only counts if it shows up in at least two separate sources, like a blog post and a lecture, which filters out one-off opinions from genuine patterns.
Every extracted rule must link back to an exact quote and its source, so the agent can't fabricate what the expert actually believes.
A subagent is a separate Claude instance with its own instructions and context window, so handing it a task doesn't drag the main conversation's context along with it.
A Claude Code hook can block an agent from answering until it has actually run and tested the code it wrote, closing the gap between 'this works' and 'I tested this works'.
Predicting the expected output before running code, then comparing it to the real result, catches the failure mode where code runs but silently performs worse than expected.
A script that worked in testing crashed in production over an emoji rendering issue in a different terminal, proving 'it works' is only true in the exact setting it was tested in.
Feeding one new blog post or transcript back into the wiki automatically updates every linked page, the index, and the rule set, so the knowledge base compounds without manual re-linking.
The same four-step process (crawl, compile to wiki, extract quoted rules, build subagent) works on any public expert, not just one with 700,000 words of material.

Takeaway

Seven quote-backed rules teach like Karpathy, not just code like him.

QUOTE-BACKED RULES

Turning a public expert's writing and talks into a linked wiki, then extracting seven quote-backed rules, is how you get an AI agent that explains its reasoning instead of just handing you code.

03Why bother?

Asking Claude to explain something straight out of the box risks over-explaining, inventing details, and leaving you more confused than when you started.
Code you can't explain or fix when it breaks is the direct cost of skipping the 'why' when AI writes it for a client.
The ceiling on what you can build with AI is the expertise baked into the system prompting it, not the model itself, so borrowing a real expert's judgment raises that ceiling.

04700K words

Public material scattered across blogs, lecture captions, GitHub repos, and social posts can be pulled together with two free tools plus one cheap paid one, for about a dollar total.
Running one crawl agent per source in parallel turns a multi-hour research job into roughly 45 minutes to an hour.
A raw dump of even hundreds of thousands of words is still just a pile of text: pointing Claude at it unstructured makes it as hard to use as finding one line in a haystack.

05His own wiki

Compiling raw sources into a linked wiki, with an index, backlinks, and dedicated pages for principles and methods, turns isolated notes into a queryable relationship map.
Every rule traces back to the sources that support it, and every source links to the rules it backs, so the structure itself becomes the evidence trail.
The compiling method itself came from the expert's own public advice on building personal knowledge bases, not an invented process.

067 rules

A rule only earns a place in the final set if it shows up in at least two separate places, like a blog post and a lecture, which filters out one-off opinions.
Every rule has to be backed by an exact quote and its source, so the agent can't assert something the expert never actually said.
The seven rules that surfaced: build it or you don't understand it, first order term first, predict then run then compare, show the broken version first, prove it don't claim it, say what you assumed, and simpler wins.

07Mini Karpathy

A subagent is a separate Claude instance with its own instructions and context window, so delegating a task to it doesn't drag the rest of your conversation along.
Pairing the subagent with a callable skill lets you grade any answer against the same rule checklist before you see it, instead of trusting the output on faith.
The agent is instructed to read the wiki's index page first and cap itself at five wiki pages per task, which keeps it from drowning in its own knowledge base.

08Run it first

A verification hook can block the agent from finishing its turn until it has actually run the code it wrote, closing the gap between claiming something works and proving it.
Predicting the expected output before running code, then comparing it to what actually happened, catches the common failure where code runs but quietly performs worse than intended.
Testing a byte-pair tokenizer this way produced a full trace of what was built, what was predicted, what actually ran, and which rule justified each step, instead of a code block with a bare 'this works' claim.

09Would it ship?

Asking 'would the client accept this, and what would they want deleted' turns a code review into an editorial pass instead of a pass/fail check.
A script that passed its own test still crashed in a different terminal because of an emoji character, proving 'it works' is only true in the exact environment it was tested in.
Feeding the agent one new link with a slash command updates the source page and every page it touches automatically, so the knowledge base compounds without manual re-linking.
The same four-step process works on any public expert, not just one with 700,000 words of material, including a sales teacher, an author, or a coach you already pay.

Glossary

Terms worth knowing.

Subagent: A separate Claude instance with its own instructions, memory, and context window, used to hand off a task without pulling the full context of the main conversation into it.
LLM wiki: A set of linked markdown pages, built by an LLM from raw source material, that includes an index, backlinks, and one page per concept so related ideas can be queried together instead of searched as a flat pile of notes.
Claude Code hook: A script that runs automatically at a point in an agent's turn, here used to block the agent from finishing its answer until it has actually run and tested the code it wrote.
Byte pair tokenizer: The component that converts raw text into the numeric tokens a language model actually processes, used in the video as a test case for the agent to build and explain.
First order term: The single most important piece of a problem, isolated and solved first before any additional complexity gets added on top of it.

Resources

Things they pointed at.

02:54toolYouTube Transcript API

03:15toolyt-dlp

03:15tooltwitterapi.io

03:50linkKarpathy's LLM-wiki gist

04:20toolObsidian

02:20linkFree AI OS Template (Nate Herk) ↗

Quotables

Lines you could clip.

01:45

“Building this agent here is going to fix AI's worst habit, which is sounding right instead of being right.”

Sharp, contrarian framing of a common AI complaint, works as a standalone hook.→ TikTok hook↗ Tweet quote

01:53

“The quality of what you build with AI comes down to the expertise that's in the system, and you're not going to be an expert on everything.”

Clear thesis statement that reframes the whole video's premise in one line.→ IG reel cold open↗ Tweet quote

09:05

“Saying that it works was only true in one specific setting or terminal.”

Concrete gotcha that proves the stakes of unverified AI code in one sentence.→ newsletter pull-quote↗ Tweet quote

10:05

“You can outsource your thinking, but you cannot outsource your understanding.”

Memorable closing line, directly quoting Karpathy, strong standalone statement.→ TikTok hook↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphor

So this isn't the Claude that you know. I just turned one of the biggest minds in AI into a Claude agent. Andre Garpathy is one of Anthropic's lead engineers, a co -founder of OpenAI, and the person that everyone says explains AI better than anyone alive.

And today, I'm going to show you the exact four steps to turn his thoughts into your own Claude agent, so let's get into it. Okay, so real quick. Who is this guy?

He was a founding member of OpenAI back in 2015. Then he ran AI at Tesla for about five years, leading the computer vision team behind Autopilot. Then he left to do education full -time and started Eureka Labs.

And as of May of this year, he's at Anthropic on the pre -training team, which is the team that trains clawed models before they're released to the public. And on the side, he has put out so many different YouTube videos and courses on building with AI. So what we're building today is not a voice clone of André Carpathie.

It's not an impression of him. It's an agent that condenses the way the best AI teacher, Andre Garpathy, explains things and it teaches you the same way.

So it follows seven rules that all come from his own writing and his blogs and his lectures. Stuff like build the smallest version first, predict what's going to happen before you run it, show the broken version, and never hand over code that you haven't run yourself. So this is more than just a clone of a person.

It's more about cloning the way that his brain... thinks. So now I bet you guys are wondering, why would you actually build this?

Let's think about what happens when you ask Claude to explain something that you don't understand. It might over -explain. It might make stuff up along the way.

And you actually just end up feeling like you learned nothing and feeling more overwhelmed. And if you're building something for a client, that's how you end up shipping code that you can't fix or explain when it breaks. And Andre Kapathy has run into this exact same thing.

Back in August of last year, he actually posted publicly that he tried to get Claude Code to teach him alongside the code that it was writing. And in his words, it didn't work at all. because it really just wants to write code a lot more than it wants to explain anything along the way.

So building this agent here is going to fix AI's worst habit, which is sounding right instead of being right. And the bigger reason is honestly this. The quality of what you build with AI comes down to the expertise that's in the system, and you're not going to be an expert on everything.

You know, I'm not a machine learning researcher. I'm not a machine learning expert. But I can certainly go have agents pull in everything that a real expert has said, compile it into something that Cloud can actually use, and then I can just talk to it until I understand it.

And then once I understand it, a little bit better i have all that knowledge already in my project and i can wire that knowledge into my own skills and my own agents and my own workflows which is exactly what we're doing today with carpathy and what's really cool is once you've done this with carpathy you can do this with pretty much anyone you can do this with your favorite you know sales teacher or an author you really like or a coach that you're already paying for and it's basically just the same four steps in the same way that we build this sort of like second brain now real quick before we get into the build i've got this completely free aios kit for you guys to help you build and scale your operating systems if you combine this sort of setup with things like Karpathy's brain.

It's just going to be a huge unlock and it's how I'm able to move so fast. So the link for that will be down in the description, but let's get into the build. Okay, so I'm going to do this inside of Cloud Code and there are going to be six prompts to run here and I'll show all of them on screen so you can just kind of take a screenshot and paste them into your own Cloud Code.

So first, Cloud needs everything. that's inside of Andre Karpathy's head. Things like his blogs, his lecture transcripts, his GitHub repos, his posts on X.

All of that is going to be just basically free and public. But Cloud Code might not be able to just grab all of that for free because it might be behind some sort of like paywall or software wall. So what I did for YouTube is I had it pull captions with two free Python packages.

YouTube transcript API. and ytdlp and then for x i'm using a api called twitterapi .io which is a paid api but i've pulled basically every post that he's made since 2023 and it was about a dollar it's not a very expensive api at all so here is the prompt for the crawl it basically says where to get everything which tool to use for each source and i told it to run one agent per source so they all go at once in parallel so it doesn't take forever i told it to write down what it got so that you can actually check it and this took me about 45 minutes to an hour for all these agents to run and grab everything and what we end up with is one raw folder with one subfolder per source and over 700 000 words straight from andre carpathy himself now you could just stop here and point claude at that folder but all of these you know messy words it doesn't really fit into claude's head in the right way where it actually can filter through it in a good fashion right like it's going to be too messy it's like finding a needle in a haystack so what we're going to do is what carpathy told everyone to do back in april he posted about how he has an llm compile his raw sources into a wiki the raw files don't get touched but the llm base

reads through all of them and then links them together with pages, keeps an index, keeps a log, and now you're able to actually query against it in a way that makes more sense because there's like relationships. And you put that whole idea in a gist, and that's what I'm going to paste into the coding agent. The link to the gist is in the description of this video.

So what we're doing is kind of funny. We're storing Karpathy's brain inside of Karpathy's own LLM wiki memory system. And if you guys have been following me for a while, you know that I've made quite a few videos on this topic, and I've got a bunch of different LLM wikis set up in my own AI OS.

Alright, so here's prompt two to set up the wiki. You're going to paste in the gist, and then you're going to tell Claude to use it on the raw folder, which is just everything that... Claude previously just extracted for you.

And what comes out is a wiki inside of Obsidian. Now, Obsidian is just kind of the visual layer on top of it, which is what I'm showing you guys here. And you don't need Obsidian to get this to work.

But if you want to look at it visually, Obsidian works. You can see down here, we have the sources. We have one page per thing he wrote or said.

We have topics on what he knows. We have principles. We have the rules.

We have methods. We have how he explains. We have how he debugs.

We have basically just, like I said, the way his brain works. And whenever you see one of these purple links, that is the wiki connecting one page to another or one method. to another every rule links back to the source that it came from or sources that it came from every source links to the rules that it supports so instead of just having a dump of notes like we had earlier we now have like this interconnected web or sort of like relationship map and every time that something new goes in you ingest a new blog or a new idea the llm will once again ingest it and link it to a bunch of other concepts now this next step is what makes it think like him instead of just knowing what he said in the past so here's the prompt for setting up the rules it basically pulls his rules out of the wiki and every rule has to connect with an exact quote from him and where it came from because we don't want Claude to just make things up.

So what we got here were seven rules. Number one is build it or you don't understand it. Number two is first order term first.

Basically find the one piece that matters, show it working, and then add just one thing at a time. And pretty much this whole course is built in that way. Number three is to predict, then run, then compare.

He'll say the number he expects before he runs the cell because in his words, most of the time it will train but silently work a bit worse. Number four, is to show the wrong version first.

He leaves his own bugs in the recording on purpose. Number five is prove it, don't claim it. Number six is say what you assumed.

His number one complaint about cloud code is that the models make wrong assumptions on your behalf and then just run along them without checking. And number seven is that simpler wins. And what's cool is you can check any of these.

You can click the quote and it will open up the page that it came from with the timestamp or with the exact source. And if there is no source, the agent has to say explicitly that it's inferring based on things that Karpathy has said. Now these rules need to live somewhere.

the agent can actually read them. So here's prompt four, and it has Claude turn them into two files for us. That first file is a subagent.

And in case you don't know what that is, it's a separate Claude with its own instructions and its own memory and context window. So that if you want to hand off a task to a subagent, it doesn't drag your whole conversation along with it. And you can see here inside of the subagent file, we can see the seven rules.

We can also see how it talks and we can see the loop that it runs on every single task. So this is basically like a little mini Carpathi agent. Now, the second one is a skill.

So you can see here that when I type slash carpathy -teach, and then whatever I'm stuck on, it goes into the agent with the rules. And then it grades the answer against a checklist, one line per rule, and then it will actually show me everything.

So those are the two things we have, a carpathy agent and a carpathy skill. Okay, now here's another thing that's really important when we're setting this up. We want the agent to make sure that it's running its code before it answers you.

And that's why building this inside of Cloud Code works so well, because it can already write and run code. And it's a step that we have to make sure that the agent can't skip based on carpathy's own rules. So here's prompt five.

It's basically adding a run gate. It adds a hook. which is a little script that runs right when the agent tries to finish its turn so if it wrote code and it never ran it the hook will basically block the answer and it will send it back with one message saying hey you have to run this before you say it works so we're kind of just baking in like a verification loop and you obviously don't have to code or write this hook yourself you just ask for it with this prompt so now it will run it will test and it will fix and then only after all that will you actually see the final thing and then the last step of course is just to test it so a few different prompts that we use to test it i asked it here to build something real and teach me how it works, which was a byte pair tokenizer, which is the thing that turns text into numbers before a large language model ever sees it.

And watch what it does here. The first thing, it writes down what done means before it touches any code. And then it builds the smallest version that works on a tiny input.

And before it runs it, it tells me what it expects to see. Then it runs it and shows me the real output. And then it shows me a version that breaks and why, and then it fixes it.

And then at the bottom, it lists basically everything it ran, what came out, what it changed, and which rule it was following for each of those moves. So instead of getting just a block of code back and then the agent saying, hey, this works, I basically got walked through it one piece at a time, and now I can understand a lot better what just happened.

Now, another thing you can test is its review. So before something goes to a client, I can ask it one question, which is, would the client accept this? And what would he want to delete?

Or, you know, questions like that. And here's a script that Claude wrote for me that I can use as an example. This script pulls YouTube comments, and it ran fine when Claude tested it.

The agent reads it. it predicts it'll crash on an emoji under a normal windows terminal it runs it that way and then it crashes before writing any files so saying that it works was only true in one specific setting or terminal so here you can see that claude was able to go through and cut a bunch of stuff that wasn't earning its place and was able to give me an analysis on how we actually fix this and clean it up and review it before we can actually like ship it and then it proves the trim version catches the same questions by running both of them side by side and actually showing me and then the other thing i wanted to bring up is that this thing will just keep learning back in july carpathy posted about how he rambles at the model by voice for 10 minutes, and then he lets the model clean up all that text.

So I can run slash carpathy dash ingest with any sort of link. It will then check the raw folder. It'll write a source page for the post, and then it will update every page that post touches.

It added a new behavior here to rule six. So now the agent knows to ask me a couple of questions when my request is thin instead of just guessing. And a rule that was sitting on the bench with one source behind it got its second source and became a real rule.

And then because it understands how this wiki works, it'll update the index. It'll update the hot page. update the log, so the brain just got better from me adding one link, and I never had to touch the wiki by hand or manually set up these relationships or links.

And that, of course, was his rule too. Okay, so zooming out, we had four steps. We gave Claude everything inside of someone's head, Karpathy's head, and we compiled it into a wiki.

We turned that into his rules with a quote for each one. We make it run before it talks, and we make it test on things that are real. And the line that I'd want to leave you guys with today is one of my favorite quotes, and something that he himself has said this year, which is that you can outsource your thinking, but you cannot outsource your understanding.

You are not going to be the expert at everything, and that's fine. But you can certainly pull in the expert and build on top of him or her.

But anyways, that is going to do it for this one. So if you guys enjoyed the video or you learned something new, please give it a like. It definitely helps me out a ton.

And as always, I appreciate you guys making it to the end of the video. I'll see you on the next one. Thanks, everyone.

The Hook

The bait, then the rug-pull.

Nate Herk opens with a dare: this isn't the Claude you know. He's turned Andrej Karpathy, OpenAI co-founder, former Tesla AI lead, and the person he calls the best AI teacher alive, into a Claude Code agent built from over 700,000 words of Karpathy's own writing and talks.

Frameworks

Named ideas worth stealing.

00:12list

The 4-Step Expert Cloning Process

Crawl everything the expert has published (blogs, lecture transcripts, GitHub, social posts)
Compile the raw material into an interconnected wiki with an index and backlinks
Extract rules from the wiki, each backed by an exact quote and source
Turn the rules into a Claude Code subagent and skill, gated by a hook that forces verification before every answer

The repeatable structure the whole video is built around, demonstrated once on Andrej Karpathy but framed as portable to any public expert.

Steal forbuilding a reasoning agent from any teacher, author, or coach whose material is public

05:38list

Karpathy's 7 Rules

Build it or you don't understand it
First order term first
Predict, then run, then compare
Show the broken version first
Prove it, don't claim it
Say what you assumed
Simpler wins

The quote-backed rule set extracted from Karpathy's wiki, each rule required to appear in at least two separate sources before making the cut.

Steal forany agent persona that needs a checkable, source-linked rule set instead of a vague prompt

CTA Breakdown

How they asked for the click.

VERBAL ASK

02:20link

“I've got this completely free aios kit for you guys... the link for that will be down in the description”

Soft mid-roll plug for his own free template, framed as a complement to the Karpathy-wiki workflow rather than a hard sell, placed right before 'let's get into the build.'

MENTIONED ON CAMERA

02:20linkFree AI OS Template (Nate Herk) ↗

FROM THE DESCRIPTION

PRIMARY CTAWhere the creator wants you to go next.

AFFILIATECommission earned if you click.

OTHER LINKSAlso linked in the description.

Storyboard