12:15Austin Marchese · Tutorial
Stop Prompting Claude. Start Loop Engineering.
A 12-minute framework for replacing one-shot prompts with self-running loops that verify their own work.
June 19thThe argument in one line.
A truly self-improving Claude system is not one that runs without you — it is one that buckets every proposed change by risk level so AI handles the easy calls autonomously while you sign off only on the decisions that could break things.
Read if. Skip if.
READ IF YOU ARE…
- You already use Claude Code daily and want the system to compound rather than reset every session.
- You have accumulated conversation history, email, meeting notes, or other personal data and want to turn it into an AI context layer.
- You have tried building automation with Claude but ended up with drift — the system optimising in a direction you did not intend.
- You want recurring improvement suggestions without having to manually audit your entire setup each week.
SKIP IF…
- You are brand new to Claude Code — the framework assumes you already have sessions and skills to pull from.
- You want a fully autonomous setup that requires zero check-ins; the framework explicitly requires periodic human review to work well.
The full version, fast.
Most people who try to build self-improving AI systems either do too little (one static prompt) or too much (full automation that drifts). The B.U.I.L.D. Framework sits in the middle: build a knowledge base and skill library, bulk-ingest everything you have already created, then create four data pipelines that continuously feed new material. An improve-system skill analyzes the data and sorts proposed changes into three buckets — auto-approve, needs sign-off, and needs context — so the system evolves every week without going off the rails. The final step is mindset: run it slowly, stay the leader, compress feedback loops, and bias toward action over whiteboard planning.
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 →Where the time goes.
00:00 – 00:20
01 · Cold open + framework promise
Hook: obsession with self-improving systems; promises five-step B.U.I.L.D. framework drawn from Karpathy, Anthropic, and personal coaching experience.
00:20 – 01:59
02 · Step 1: BASE
Create a Claude project with raw/ and wiki/ folders (Karpathy LLM knowledge base concept); add CLAUDE.md; build the add-new-resource utility skill.
01:59 – 04:26
03 · Step 2: UPLOAD
Three data sources: Claude session history, personal ecosystem data (computer files + email export), and a recorded life story/goals interview with Claude.
04:26 – 09:01
04 · Step 3: INFLOW
Skill-driven ingestion for: sync-claude-sessions, sync-ecosystem-data (Granola MCP, Slack, YouTube), sync-curated-content (newsletter alias inbox), and periodic voice dumps.
09:01 – 14:46
05 · Step 4: LOOP
The improve-system skill reads ingested data and proposes changes in three tiers: auto-approve, needs sign-off, and needs more context. Routines schedule ingestion and review on Tuesdays/Fridays. Workout analogy explains why full automation leads to system drift.
14:46 – 16:46
06 · Step 5: DRIVE
Four rules: slow is smooth, you are the leader, compress feedback loops, bias to action. Brian Armstrong quote. CTA to loop engineering video.
Lines worth screenshotting.
- Your own Claude session history is the highest-signal training data you can feed a self-improving system — it is literally you doing real work.
- A knowledge base without recurring data pipelines evaporates; the lake metaphor is the point — you need rivers, not just a one-time fill.
- Fully automated improvement loops optimise for the wrong thing unless a human periodically signs off on high-stakes changes.
- Bucketing improvements into auto-approve / needs sign-off / needs context is what makes self-improvement sustainable over months.
- Skills are the atoms — every recurring pipeline and every automation loop should call a tested skill, not inline logic, so updates propagate automatically.
- Orchestration skills that chain utility skills together are what let you schedule complex routines in a single call.
- Data capture matters more than the connection method — if you cannot wire up a source today, capture the raw file and connect it later.
- A voice dump at the end of each day is one of the highest-ROI data inputs for a personal AI system.
- Less is more in curated content pipelines — high-signal newsletters beat a flood of low-quality ingestion.
- The only genuinely wrong choice when building an AI system is overthinking the setup instead of running it.
- Routines should reference skills, not inline instructions, so updating the skill automatically updates every routine that calls it.
- Separating data ingestion routines from improvement routines means you instantly know which stage failed when something breaks.
- The human review step is not optional overhead — it is what keeps a self-improving system from becoming a self-degrading one.
- Action produces information — the system sharpens through reps, not whiteboard sessions.
Five steps that make an AI system compound.
WHAT TO LEARN
The difference between a Claude setup that stagnates and one that improves over time comes down to whether it has a data lake, recurring rivers feeding that lake, and a bucketed review mechanism that keeps you in control of the high-stakes calls.
- A knowledge base with a raw/ and wiki/ folder gives Claude a table of contents instead of forcing it to read everything — search time drops and retrieval improves.
- Your own Claude session history is the most relevant data you can ingest because it captures how you actually think and what you actually ask.
- Data pipelines that run on a schedule are only reliable when they call tested skills — the skill is the stable unit, and the routine just triggers it.
- A fully automated improvement loop drifts over time because the system optimises metrics it can observe, not outcomes you actually want — periodic human sign-off is the correction mechanism.
- Bucketing proposed changes by risk level (auto-approve vs. sign-off vs. needs context) is what makes weekly review feasible instead of an all-or-nothing audit.
- Orchestration skills that chain utility skills together let you schedule a complex multi-step routine as a single command — when a utility skill changes, the orchestration updates automatically.
- Curated content pipelines benefit from a strict high-signal filter — ingesting too much dilutes the system's ability to surface useful patterns from your own data.
- Voice dumps at the end of a workday are an underrated data source because they capture tacit knowledge and lessons that never make it into written files or session history.
Terms worth knowing.
- Knowledge base (raw/ + wiki/)
- A two-folder project structure where raw/ holds unmodified source files and wiki/ holds AI-readable index entries that point back into raw/, acting as a table of contents so Claude can retrieve relevant information without reading everything.
- Skill (Claude Code)
- A markdown file that gives Claude a fixed procedure for a repeatable task — equivalent to a standard operating procedure the AI follows every time, removing the need for back-and-forth each run.
- Orchestration skill
- A higher-level skill that calls multiple utility skills in sequence, bundling a multi-step workflow into a single slash command.
- Skill-driven data ingestion
- A pattern where each recurring data pipeline is backed by a tested skill before being wired into any automation routine, ensuring the logic is validated before it runs unsupervised.
- Bucketing strategy
- A three-tier system for classifying AI-proposed improvements: auto-approve (low-risk), needs sign-off (high-stakes, written to a review file), and needs more context (ambiguous, also written to review file).
- Routine (Claude Code desktop)
- A scheduled task inside the Claude Code desktop app that runs a skill or prompt on a set cadence with direct access to the local file system.
- Google Takeout / Outlook Export
- Native export features from Google and Microsoft that produce a downloadable archive of a user's email history, usable as raw material for analyzing writing style and workflow patterns.
- Granola MCP
- An MCP integration for the Granola meeting-notes app that lets Claude pull full call transcripts into a project automatically, without an AI bot visibly joining the call.
Things they pointed at.
03:20toolOutlook Export
08:30toolHex
08:30toolWhisper Flow
02:30channelAndrej Karpathy LLM knowledge base concept
Lines you could clip.
05:01
“There's really no better training data than your own conversation history with Claude.”
10:07
“What if the system only ever trains chest? Six months from now, your chest is huge and your legs are toothpicks.”
12:36
“We're having AI make the easy calls and I prefer making the hard ones.”
16:09
“Action produces information.”
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.
metaphoranalogystory
00:00I've been obsessed with building my own self-improving system with clawed code. And after studying Andrea Cararpathy, the anthropic team, and running my own system, I've identified a five-step build framework that lets anyone create a self-improving system with clawed code. Today, I'm walking through all five steps, exactly how to implement them, and the lessons I've learned from teaching hundreds of people the same system.
00:20Step one is base. Create the framework for improving. Before you do anything, you need to create a project.
00:24This is where you store all the data so you can enhance it over time. To create this project, there are two parts. one, a knowledge base where you store the data, and two, the skills that let you work 10 times faster. So, part one, the knowledge base.
00:37Andrea Carpathy went viral for his concept called LLM knowledge base. I have videos on my channel diving deep into this, but the concept is fairly simple. You have a raw folder, which includes any raw resources you ingest.
00:48For example, this could be a call transcript you record. And then you have a wiki folder, which references files in your raw folder to help AI know where to look.
00:55Think of this like a table of contents in a book so AI can locate information without reading the entire book. Here's a prompt which will help you set this up from scratch or in an existing project that you're currently working on. And to enforce this, we'll update the claw.md file to explain how it's all set up.
01:10This file essentially serves as a consistent reminder to Claude about the framework. Part two is skills for repetitive tasks. If you're doing the same thing twice with Claude, you should create a skill.
01:20And a skill is your way of telling Claude exactly how to handle a task. It's the same process every single time, so you don't have to go back and forth. The first skill that I set up with every person I work with is add new resource.
01:30This tells Claude exactly how to add a new file into the system. It will take a raw file, ingest it into RAW, and then Claude will analyze it and update or create any wiki entries that should reference it. These utility skills will come into play later when I go through orchestration skills, which call multiple utility skills together to create a bigger output. to set up both parts, both the knowledge and the skills.
01:51Here is a single prompt that combines the two. This prompt will help you create the project which will set the foundation for the entire system. Now you have the project set up, but step two is about creating your own data lake.
02:01Step two, upload identify your data plus bulk ingest. Before creating a self-improving system, you need to ingest everything you've already done. We want to work smarter, not harder.
02:10So let's look at all of our historical training data that's already exists and bring that all together in one place. To do this, we're going to look in three places. Place one is your AI inputs.
02:19This is the data you generate just by using AI. So this is your conversation history. And in my eyes, this is the most relevant training data that you'll ever find because it's literally you inside the terminal asking the AI ecosystem questions.
02:32And the beauty of this is that Claude already saves all of its session history locally. So there's a file that you can analyze historical conversations with. Here's a prompt that you can run that will analyze your session history for you and provide your project with clear learnings and skill suggestions.
02:47The key part here is the phrase suggest ways we can improve my system. The second place is personal ecosystem data.
02:53Everywhere you interact online, you create your own data footprint. So this is the process of grabbing as much data from those footprints as possible and bringing it into the system. Now, there are a lot of ways that you can do this, but two specific ways to do this that apply to everyone watching this video is the first, which is use Claude to mine your own computer.
03:11Open Claude code and say, "Analyze my computer and identify any files you think would be helpful to ingest into the system." This will surface any information you already have on your machine that will be valuable for the system you're building. And the second is to pull your email history.
03:24If you use Google, there's a feature called Google Takeout. If you use Outlook, there's a feature called Outlook export. You can then take this export and bring it into claw to analyze your writing style and any potential places to use AI that you're not already using it.
03:36And if you are concerned with data privacy, okay, just skip this part. This prompt will help you ingest these two data sets. The third place to look is your life story and project goals.
03:45This one is simple and most people don't think to do it. Just sit down and record yourself talking about your life, your project goals, and what you want to accomplish. Then upload that recording to Claude and say, "Analyze this recording and interview me to fill in anything I may have missed." And once finalized, add this as training data to my project.
04:01Claude will then interview you and by the end you have a file that you can bring anywhere with you that gives context to AI that it probably didn't already have. Here is a prompt that will run the entire bulk ingest in one session. At this point, we've set up our system.
04:15We've ingested historical data and created custom skills based on what we actually do, not hypothetical skills. Now, this next step is the most important thing to get right so that we can create a self-improving system. Step three is inflow.
04:27This is about setting up your data pipelines. . In step two, we filled the lake up.
04:33But the problem is if there's no new water keeping the lake full, it will evaporate and no longer be useful. So in this step, we create data pipelines which will act as . And these rivers will automatically flow into the lake and you won't have to think about it.
04:47The way we'll do this is what I call skill driven data ingestion. For each pipeline, we first need to set up a skill that is well tested that we know processes raw data. exactly how we want it.
04:57In step four, we'll use this to create our automated improvement loops. But you can't do that without this because this is a step where 99% of people get it wrong. There are four different types of data pipelines that you want to set up.
05:09Pipeline one is your own inputs. Like I said earlier, there's really no better training data than your own conversation history with Claude. And we process that as part of the initial data dump, but we need to continuously process this to get learnings from our conversation history.
05:22So to do this, we're going to create a skill called sync claude sessions. The skill is pretty simple. It'll take your past conversation history, bring it into your project, and then ingest it into a process folder.
05:33Here's a prompt that will create this synccloud session skill, and with every one of these prompts, when you do create these skills, it's super important that you actually test the skill. Make sure it works on your machine, please. The second pipeline that you'll set up is your personal ecosystem data capture.
05:47Again, a lot like the bulk upload, you need to figure out the places where you're creating data on a recurring basis. So, for me, I hop on client and team calls. I write Slack messages.
05:57And I post videos on YouTube. I'm really a simple man. So, to set this up for myself, here's how I would do it.
06:03First, for meetings, I would use Granola because it records in the background without an AI bot sitting on the call, which feels a little too intrusive for me. And I use their MCP to pull the full transcripts from that call and then ingest it into my project. For Slack, I can set up a direct Slack connection and claw it to pull chat history.
06:19For YouTube, I post videos publicly with transcripts enabled so I can reference the final product to see what was actually said and pull that into my system. The most important thing when you're thinking about all of these different nodes for data capture is make sure that you're actually capturing the content. If you can't figure out the connection today, that doesn't matter as long as the raw information is there and eventually you'll figure out the connection.
06:40Now, I went through the three of those pretty quickly, but on screen this will showcase three unique ways to connect to external data sources. Now, this may sound complicated, but you can just lean on Claude to help with this connection.
06:51Here's a prompt that will create a sync ecosystem data skill based on whatever you're trying to connect. This will go through each connection source, pull anything that's new, and then process it into our actual project. Pipeline number three is your curated content pipeline.
07:05This is data from external resources that can help you create a better output. For example, this could be a book, a blog, or a YouTube video. Now, there are a lot of ways to do this, but my favorite is using newsletters because no matter what niche you're in, there is somebody writing a newsletter with a ton of valuable information about your specific topic.
07:23And the best part is everyone watching this has an email. So, if you don't want to get flooded with topic specific newsletters, what you can do is add an alias domain. So, whatever your normal email is, let's say it's Brad, shout out all the Brads out there, you would do brad plusnewsletter@gmail.com where the plus newsletter creates an email alias that lets you easily filter for emails to that specific location.
07:45So, for example, if you're looking for AI best practices, you would click the link below which has my email newsletter which has a ton of juice and then you would ingest that into your pipeline and you would get better insight in how to best use AI. And if needed, you can create that alias domain to help you with filtering.
08:01Now, the skill that will power all of this is sync curated content. This will pull newsletters from alias inbox, extract the key claims from each one, and then process it into our wiki. This is specific for email, but it's similar for other resources.
08:13You just need to configure it based on where you want to gather the information. Now, when you're gathering the information, be careful not to just pump it with everything.
08:21At the end of the day, less is more here. Be very selective with what you're ingesting because you only want high signal resources. Pipeline number four is periodic data dumps.
08:30Similar to the life story step earlier, I try and end my day or my weeks talking through any lessons that I learned. And this is just me downloading my lived experience into Claude to help get more context about what I'm doing. So, I'll just rant into Claude code using Hex or Whisper Flow, which are voicetoext tools.
08:46And then I'll run the add new resource skill, which we already created to ingest this information. Now, putting that all together, here is a single prompt that will create all three of these sync skills that I've mentioned. This helps create a constant stream of data into the data lake that you're creating.
09:01Now, one question you may be asking is, how do we make it so that it automatically improves over time? And we'll get to that in the next step. But before we get to that, if this is your first video of mine, welcome to the channel.
09:11But if it's your second or more, here is our anti-slop agreement. The visuals, the testing, the hours of research that went into this video. This is entirely built for humans, not for these AI robot scrapers.
09:21So, all that I ask is you subscribe as part of this agreement to help this content reach more people. Also, every video I give away a Claude Max subscription. This video's winner is Gregory Horn, who's building an AI native video studio for his Hermes agent.
09:34Now, for this video, comment below with what you're building to enter. Now, to step four, which is where most people get self-improving wrong, and I'm going to show you why. Step four, loop.
09:43Determine and set up the improvement loop. Most people think self-improving means the system runs entirely on its own without any human input. And yes, that is possible, and I'm going to show you how you can do that.
09:54But I do want to explain the downside of this. Let me give you a workout analogy that might hit home a little too hard for some people. Imagine a system that was automatically improving your fitness.
10:05So there's scenario one, a fully automated system. This system will work out for you. You don't have to lift a finger and you get jacked without any effort.
10:12Now it sounds amazing, but what if the system only ever trains chest? 6 months from now, your chest is huge and your legs are toothpicks. The system thought it was improving you, but it was actually breaking you. Now scenario two, augmented.
10:24You get a workout plan, but before it runs it for you, you sign off on what the workout is. Then it does the workout without you lifting a finger. Both these scenarios handle the heavy lifting, but the first one just removes your judgment, which in some cases, unless you love working out only chest, you just can't afford to lose this.
10:41So, when should you automate and when should you review? Now, I'll cover that, but first, how do we actually analyze the ingested data and propose improvements? I like having a single skill called improve system.
10:51Here's a prompt to set it up, which once set up will categorize any improvement that you do into three buckets. Bucket one, auto approve. This is lowrisk stuff like data bloat, missed linkages, obvious fixes, and improvements.
11:02This is what we'll have Claude automatically apply as part of the skill. It puts it in a change log, and you don't see any of these changes unless you want to. Bucket number two is need signoff.
11:12This is higher stake stuff like editing a skill or creating a new skill. anything where the wrong choice could degrade the output quality of your system. These will get written to output/re with the date MD.
11:22And within the file itself, there will be a checkbox with one of three options. Approve, reject, or approve and don't ask again. Bucket number three is more context required.
11:31This is stuff that's analyzed, but the skill can't decide on its own how to handle it. Essentially, it's just things that you need to provide more information on. And both buckets two and bucket three, what needs approval and what needs more context, get added to the same file so you can review it all at once.
11:46On screen, you can see what an example review file looks like as the system suggest improvements which I use in Obsidian to view it. And now you may be asking, what if I want to automatically approve everything?
11:56And you can. You can just adjust the skill accordingly. But I do want you to be aware of the spectrum and the pros and cons of it.
12:02On one end of the spectrum, you have full automation. This is where you auto approve anything. and it requires the least amount of work, but it's the most likely to lead to system drift.
12:11And then on the other end is review every change. This is safe, but it's too much work and you're likely just not going to do it. The bucketing strategy, which is what I just went through, is exactly where I sit and it's in the middle of the spectrum.
12:23AI handles the low stake work on its own and you only handle what is considered high stakes calls. And over the time, the system will learn what is high stakes and what isn't. We're having AI make the easy calls and I prefer making the hard ones.
12:35So, at this point, we understand the trade-offs and we've decided to go with a bucketed approach. But how do we begin and start automating the entire thing?
12:42We're going to use Claude Code's desktop app to create routines. Routine one is data ingestion. Routines are how you schedule things to run inside the desktop app.
12:51We're going to set up local routines because this gives it direct access to your file system so you can easily edit and manage files without worrying about version control. To get to this, you can go to routines and then click the dropown and then select local. To help simplify all the data ingestion into a single routine, I create a skill called slash data ingestion.
13:10This is an orchestration skill that runs the three skills that we created earlier. Sync cloud sessions, sync ecosystem data, and sync curated content skills.
13:17Using this prompt, which will create it, I then create a new routine and have it run this data ingestion skill on Tuesdays and then another one for Fridays at 9:00 a.m. And the actual routine is super simple. I just have it reference the skill I've already created.
13:31The key to any successful routine is you want to reference skills so that it's easy to update. And so if you update the skill directly through claude code, it'll automatically update the routine. The second routine we'll create is system improvements.
13:44I then do the same thing for the slashimprove system skill. This will run at the end of the day on Tuesday and on Fridays where it will review the data ingested earlier in the day and suggest improvements.
13:54The reason I've separated these two is I feel like they're two distinct processes and I think of routines as an individual process. So rather than bucketing I have individual and that way if something fails I know which part of the process failed. And the third routine is human review.
14:08This is your human process and this is so important because you are driving the system and we've already created a very simple way to do this where you just have to check boxes on what you actually want to be improved and what you don't want to be improved. If you want, you can make a/human improved system skill which will help you walk through the process or notify you through Slack if you are getting lazy or have forgot to provide feedback.
14:31The important part here is that you are part of the process because this is your system and you need to own it. So far, we've covered the first four steps and how this will transform how you work. But the reality is that you are the one putting this thing together, which is why the fifth step matters the most.
14:46Step five, drive. Run it. Don't overengineer it.
14:49This step is the mindset you need to actually run the system you just built. From firsthand experience, you can have all the skills and knowledge, but if you don't apply these four strategies, you are absolutely cooked. The first is slow is smooth, smooth is fast.
15:03Don't try and do everything at once. Move slow, move methodical. Everything in this video is teed up for you.
15:09Just go one step at a time and don't be discouraged. Two is you're the leader. The system serves you.
15:14If a piece of the system isn't actively making you better, just get rid of it. You don't have to have it.
15:19If you added a skill and you don't like it, just delete it. You don't have to wait for someone's permission to do something. Just do it.
15:25Three, compress your feedback loops. Self-improving systems are valuable because they compress feedback loops. But the loops only learn if you're actually using the tools.
15:33And even though it's automatically improving, don't wait for it to automatically improve. If a skill didn't work the way you wanted and you already went back and forth with Claude to actually fix the final output, just say based on this conversation, improve this skill. you are pushing the system forward.
15:47So, continuously do it. Four, it is not that serious. Bias to action.
15:50People always ask me, "What tools should I use? Should I make it raw/inputs? Should I make it raw/ sessions folder?
15:56Should I run these things at 6:00 a.m. or 9:00 a.m.?" The honest answer for any of those smaller things, it just doesn't matter. The only choice that's genuinely wrong is overthinking it.
16:06AI is really good, so just use it and build things. These systems sharpen through reps, not whiteboard sessions. One of my favorite quotes of all time is from Brian Armstrong, the CEO of Coinbase.
16:16He said, "Action produces information." If you're not sure if something works, just do it and you'll learn faster and you'll have more confidence about the answer because you've already done it and you've seen it through. And that's exactly what we're doing with the build framework here. It's all about action over analysis.
16:32So, just start doing. Now, if you like this video, you'll love this video where I dive into loop engineering, a process that you can use in parallel with what we discussed here to make your self-improving system go from good to great.
16:45I'll see you in the next one. Peace.
The Hook
The bait, then the rug-pull.
Most productivity systems decay. The inputs stop, the data goes stale, and six months later you are back to blank context every session. Austin Marchese's B.U.I.L.D. Framework is a structural answer to that decay: five concrete steps that wire your own data — sessions, meetings, email, voice — into a Claude project that proposes its own improvements on a recurring schedule.
Named ideas worth stealing.
00:03acronym
B.U.I.L.D. Framework
- Base (knowledge base + skills)
- Upload (bulk ingest historical data)
- Inflow (recurring data pipelines)
- Loop (bucketed improvement skill)
- Drive (mindset and execution)
Five-step sequential framework for building a self-improving Claude Code system, from initial project setup through ongoing automated improvement loops.
Steal forAny AI-powered workflow that needs to compound over time rather than reset each session.
10:49model
Three-Bucket Improvement System
- Auto-approve (low-risk, applied immediately with changelog entry)
- Needs sign-off (skill edits, structural changes — written to review file with checkbox)
- Needs more context (ambiguous — also written to review file)
Risk-tiered classification for AI-proposed system improvements that balances automation speed against human oversight.
Steal forAny AI agent that proposes changes to a system it is also managing — prevents drift without requiring manual review of every suggestion.
05:00concept
Skill-Driven Data Ingestion
Before wiring any data source into an automated routine, first build and test a skill that processes that data correctly. The skill becomes the stable unit that the routine calls.
Steal forAny automation pipeline that needs to be maintainable — keeps logic in one place rather than baked into the schedule.
How they asked for the click.
VERBAL ASK
16:09next-video
“If you like this video, you'll love this video where I dive into loop engineering.”
Soft sell with a genuine value bridge — the next video is framed as an enhancement to the system just taught, not a generic subscribe ask.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
Visual structure at a glance.
