14:07AI LABS · Tutorial
Anthropic Just Revealed The Best Claude Code Setup
A 14-minute breakdown of the five-layer harness that determines whether Claude Code succeeds or fails as your codebase grows.
May 21stThe argument in one line.
Knowledge bases built around one person's workflow become a liability at scale, and OKF is the standardization layer that makes agent-readable knowledge portable, token-efficient, and navigable by anyone who pulls the repo.
Read if. Skip if.
READ IF YOU ARE…
- You run a second brain in Claude Code, ChatGPT, or any agentic setup and keep hitting wrong-folder drops, duplicate files, or ballooning token usage.
- You manage a team knowledge base in Git and want new members -- or AI agents -- to onboard without a manual orientation.
- You've tried RAG for agent memory and found it rebuilds answers from scratch instead of accumulating anything.
- You already use Andrej Karpathy's LLM-wiki pattern and want a formalized spec with tooling around it.
SKIP IF…
- You're still setting up your first knowledge base -- understand the basics before worrying about format.
- Your knowledge base is small (fewer than ~50 files) -- OKF's overhead won't pay off yet.
The full version, fast.
Second brains built around one person's workflow break down once they grow large or get shared across a team -- Claude navigates by keyword-matching file names, which wastes tokens and causes wrong-folder drops the bigger the tree gets. OKF formalizes the LLM-wiki pattern from Andrej Karpathy into a portable standard: markdown files with YAML front matter, per-folder index.md files the agent reads first, and one concept per file. AI Labs tested it on their own Git-tracked second brain, built a custom markdown-to-OKF Claude skill (the official tooling only covers BigQuery), and confirmed faster retrieval and lower token usage once a navigation section was added to CLAUDE.md.
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:32
01 · Intro
Hook on Claude OS / second brain hype and the problem they share
00:32 – 02:15
02 · The Problem With Second Brains
How Claude searches by keyword, why large nested bases cause wrong-folder drops and token waste, why sharing a personal second brain is hard
02:15 – 05:12
03 · What Open Knowledge Format Is
OKF origin in Karpathy LLM-wiki pattern, RAG vs wiki tradeoff, OKF as next standardization in MCP/skills/design.md family
05:12 – 06:37
04 · How OKF Works
Concepts, bundles, index.md navigation, YAML front matter, minimalism and producer/consumer independence principles
06:37 – 07:34
05 · Sponsor: Mobbin
Mobbin MCP server connecting AI coding tools to 621K+ real shipped app screens
07:34 – 11:53
06 · Testing It On Our Second Brain
Built markdown-to-OKF Claude skill (BigQuery-free), converted 334 docs, ran visualization tool, updated CLAUDE.md navigation instructions, confirmed lower tokens and faster retrieval
Lines worth screenshotting.
- Claude navigates a knowledge base by keyword-matching file names and content -- on a large nested tree, this means many failed reads before landing on the right file.
- RAG rebuilds the answer from scratch on every query and accumulates nothing; a markdown wiki lets an agent carry context forward as it explores.
- OKF's core mechanic is the index.md: the agent reads it first, loads only the YAML metadata of candidate files, and opens the full document only when the description matches.
- One concept, one file is the constraint that preserves retrieval efficiency -- the moment a file mixes two topics, the agent must load the whole thing to check relevance.
- The official OKF enrichment agent only works with BigQuery -- for a general markdown knowledge base you need to build the conversion yourself.
- Adding a navigation section to CLAUDE.md explaining the OKF structure is required; without it Claude defaults to keyword search and ignores the index files entirely.
- OKF is tool-agnostic by design -- the same bundle works across Claude Code, ChatGPT, and any other agent that can read a filesystem.
- OKF follows the same standardization arc as MCP (tool access), skills (reusable instructions), and design.md (design intent) -- each time the ecosystem hit a coordination problem, a spec solved it.
- Google may be positioning OKF as the structured-knowledge layer for agentic search, the same way llms.txt gave models a faster entry point to website content.
- The semantic judgment OKF needs from an agent is small -- choosing a type, writing a one-line description, assigning tags -- the rest is deterministic scripting.
- A knowledge base that both a human and an AI can navigate without instruction is a competitive advantage for any team that uses agents heavily.
- Sharing a second brain over GitHub only works if the structure is self-documenting -- OKF's index.md files are that documentation.
One format that makes any knowledge base agent-ready.
WHAT TO LEARN
An unorganized knowledge base costs tokens every time an agent searches -- OKF is the formatting discipline that makes the cost predictable and retrieval fast.
- Claude navigates by keyword-matching file names and content -- on a large nested knowledge base this means many failed reads before landing on the right file, and the cost compounds as the base grows.
- RAG rebuilds the answer from scratch on every query and accumulates nothing -- a markdown wiki lets an agent carry context forward as it explores a session.
- OKF's core mechanic is the index.md: the agent reads it first, loads only the YAML metadata of candidate files, and opens the full document only when the description matches -- most searches never touch a file body.
- One concept, one file is the constraint that preserves this efficiency -- the moment a file mixes two topics, the agent must load the whole thing to check relevance.
- The official OKF enrichment agent only works with BigQuery -- for a general markdown knowledge base you need to build the conversion yourself, or find a community-built skill.
- Adding a navigation section to CLAUDE.md explaining the OKF structure is required -- without it the agent defaults to keyword search and ignores the index files entirely.
- OKF is tool-agnostic by design -- the same bundle works across Claude Code, ChatGPT, and any other agent that can read a filesystem, which means the investment transfers as your tooling changes.
Terms worth knowing.
- Open Knowledge Format (OKF)
- A Google-released open spec for structuring markdown knowledge bases so that AI agents and humans can navigate them without prior orientation. Built on markdown files, YAML front matter, and per-folder index files.
- LLM-wiki pattern
- A knowledge-base approach proposed by Andrej Karpathy where an LLM incrementally builds and maintains a structured collection of interlinked markdown files instead of re-deriving answers from raw documents on each query.
- RAG (Retrieval-Augmented Generation)
- A technique that converts documents to vector embeddings and retrieves relevant chunks at query time. Accurate for known questions but accumulates no memory -- each query starts from scratch.
- OKF concept
- The atomic unit in OKF -- a single markdown file that covers exactly one topic, identified by a YAML front-matter block with at minimum a type field.
- OKF bundle
- The complete packaged knowledge base -- a directory of concept files and index.md files that can be shared as a tarball, a Git repo, or any file container.
- index.md
- The mandatory entry-point file in each OKF folder. An agent reads this first to understand what the folder contains before deciding which files to open.
- YAML front matter
- A small structured block at the top of each OKF concept file (delimited by ---) that stores type, title, description, tags, and timestamp so an agent can assess relevance without reading the full body.
- Enrichment agent
- One of OKF's two reference implementations: an agent that walks a BigQuery dataset, drafts an OKF concept document for every table or view, then runs a second LLM pass to enrich each concept with citations and join paths.
- Producer/consumer independence
- An OKF design principle stating that the knowledge format is decoupled from whoever creates it (a human, a script, a pipeline) and whoever reads it (an agent, a browser, another LLM).
- llms.txt
- A proposed standard (Jeremy Howard, 2024) for adding a file to a website that gives models structured context about the site's content -- an earlier attempt at the same standardization instinct OKF formalizes for internal knowledge bases.
Things they pointed at.
02:50linkAndrej Karpathy's LLM-wiki pattern
Lines you could clip.
00:00
“When someone sets up a second brain, they build it for their own use and structure it the way they think works best. There's no standard way of doing it, which makes these systems hard to navigate and keeps them from being shareable.”
05:15
“The main principle OKF is built on is minimalism. The idea is that each concept should represent only one thing... because the moment a concept mixes topics, the agent loses the ability to load the exact information it needs.”
11:03
“The main advantages you will get are two things: lower token usage and faster retrieval times.”
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.
metaphoranalogy
00:00You've probably heard all the hype around second brains and Claude OS. People have been using Claude code to set up their entire systems, running it like an operating system instead of just a coding agent. But these systems come with their own problems.
00:12When someone sets up a second brain, they build it for their own use and structure it the way they think works best. There's no standard way of doing it, which makes these systems hard to navigate and keeps them from being shareable. To solve this, Google just released the open knowledge format where Google is giving their own way on how to build such operating systems with AI.
00:32If this is your first time here, we're a software company, and this is our channel AI Labs, where we show you how to optimize your own processes with AI the same way we've done with ours. And in this video, we're gonna tell you what this format is, how it solves the problem, and why it actually matters for your workflows.
00:48But before we get into what Google did, let's first understand the real issue. In our previous videos, we've talked about maintaining a second brain, and we manage one for ourselves too where we keep all our strategies, research, and guidelines. Its version controlled with git and pushed to GitHub, and everyone on our team has access to it.
01:05So whenever new people join us, they can just pull it and get context on how we work. And like we mentioned before, this second brain is controlled by a Claude dot m d file. That file basically guides the agent on how to navigate around the brain.
01:17We've also got dedicated Claude dot m d files in each folder, so the agent has specific instructions for working in that directory. But even though Claude is pretty good at getting context from files, it still messes up a lot. It happened to us so many times where it would put a file in the wrong place, and then we'd have to remind it where it actually goes.
01:34And after that, it would just create a new folder for it simply because it doesn't know similar info already exists in another folder under a different name. The real problem is that Claude doesn't know the info it needs already exists in the knowledge base. It only finds things when it actively searches for them.
01:50So unless you tell it to look in a certain file, it won't even know that file is there. This isn't really obvious in smaller knowledge bases, but it becomes a lot more visible once you're working with a big one. The way Claude searches is by matching keywords against the file content, and it uses the file names as a guide too.
02:05So if you ask it to search through a really nested folder structure, it has to make a bunch of attempts before it lands on the right file. This not only waste time, but it consumes a lot of tokens as well. So Google just launched open knowledge format, and the problem it fixes is standardization.
02:20And this is something we've already seen happen across agents a bunch of times. When there was a need to let agents talk to external resources beyond what they had in the terminal, they introduced MCPs, and it became a protocol that every agent adopted.
02:33In the same way, packaging reusable instructions came in the form of skills. And just like MCPs, they spread across every agent.
02:40And when there was a need to standardize how you communicate design intent, Google launched the design.md standard two. So just like there's always a need to standardize things, there was a need to standardize knowledge too, and that's exactly what open knowledge format does.
02:53Now this idea isn't really new. It's based on the LLM wiki pattern which Andre Karpathy came up with, and it got really popular a while ago. Before he came up with this, people were relying on the rag approach where you convert all your huge documents into vector format.
03:07And vectors do help because they basically put everything into a form that models can understand. From there, the system matches the meaning of your query against the existing data and returns the most relevant matches. But Karpathy pointed out that this causes issues.
03:20Whenever you ask a question, the agent is basically . It hands you an answer, but it's not building up any knowledge over time. So he suggested using markdown files to build knowledge bases instead because that way the agent can actually gather context as it goes.
03:35His approach used in models ability to navigate a file system. And after he shared the idea, a lot of people started building second brains of their own. But the problem was that each one was designed around its creator's personal workflow.
03:47The person who organized it knew what was in each folder and could navigate it easily with the agent. But a new person would have a hard time because they'd have to spend time letting the agent explore the folders and figure out what the knowledge base actually holds. OKF solves this by creating a standard way of organizing files so that not just an agent, but a human can also understand what's inside the knowledge base.
04:09It makes knowledge shareable by packaging it into a bundle. And this bundle can contain markdown files which hold the actual information about whatever you're building the knowledge base for. Each file also includes YAML front matter, which is basically a small block at the top of the file that describes what's inside it so the agent knows what that file holds.
04:27So OKF doesn't really introduce anything new. Instead, it gives you a standard format that anyone can produce and read, and it makes knowledge portable across different systems. When we first heard about it and went through it, one thought came to mind.
04:39Since Google is trying to turn web search into a genetic search, this could also be an attempt to support that shift. Right now websites are adding LLMs dot TXT files because they hold information about the website that's specifically tailored for models and that gives those agentic systems context about the site. So instead of relying only on llms.txt, websites might eventually start adding OKF bundles too.
05:01That would let agents query their content more efficiently and maybe give better search results based on that structured info. Right now, it's only meant for internal use, but this is something that could end up happening. So to understand how it helps, let's see how OKF works under the hood.
05:16This system takes everything that's a part of your knowledge base and represents it as objects called concepts. It could be your data, markdown documents, YAML files, or literally anything else that goes into it. The structure works like this.
05:28All the information you want to organize gets placed inside folders named after the topic, and each one only holds content about that one topic. And within every folder, there's an index dot m d file. This one's the most important because it's what the agent reads first.
05:41It gives the agent context on what's inside that folder. Each concept document has a small YAML block that includes a name and a description that lets the agent know exactly what it is and what's inside the document. And just like skills have a similar YAML block, this serves the exact same purpose.
05:56It feeds the agent context bit by bit, so it only loads the exact thing it needs by reading these descriptions first and then pulling in the relevant content. The main principle OKF is built on is minimalism. The idea is that each concept should represent only one thing, and the type field inside the document tells you what that thing is.
06:13It shouldn't hold multiple unrelated things. Because the moment a concept mixes topics, the agent loses the ability to load the exact information it needs. Another principle of OKF is separating the knowledge base from whoever's consuming it.
06:26Whether it's an agent, a human, a team member, or anything else, the knowledge itself stays independent. It's not also tied to any specific platform, which is what makes it usable with pretty much anything. But before we see this system in action, let's have a word by our sponsor, Mobin.
06:40If you've used tools like Cursor, Lovable, or Claude Code to build a UI, you've probably noticed they all spit out the same thing, the same hero section, card layout, and same generic onboarding. It looks like AI slop, and the reason is simple. These tools have never actually seen what good design looks like, but Mobin has.
06:57Mobin just launched an MCP server that connects your AI tools directly to their library of over 621,000 real app screens and 142,000 flows from shipped products like Revolut, Uber, and Wise.
07:11So here's how I used it. I was building a checkout flow and asked my agent to reference how the best apps handle it. The key part, it's not copying screens.
07:18Mobin gives the agent the real flows, states, and hierarchy behind those designs before it writes any code, so it builds from proven patterns instead of guessing. Setup takes under a minute, and it works across Claude, cursor, v zero, and more. Try Mobin MCP using the link in the pinned comment.
07:35So we wanted to see how this system actually performs in a real setup. And since we were already maintaining a second brain that's shared across our team through GitHub, we tested OKF on it. But we didn't want to touch the main branch in case it didn't work out.
07:47So we created a new branch, which is basically a separate copy of the project and made all our changes there. So OKF basically ships with three things. The first one is an enrichment agent.
07:57It takes the data that's sitting in BigQuery, which is basically Google's big database for storing data, converts it into OKF concept documents, and then runs an LLM pass to check them. Then there's an HTML visualization tool that turns an OKF bundle into an interactive graph view that's easier to explore.
08:14And it comes with examples of what properly formatted OKF data should look like, which the agent can use as a reference. Now since we weren't working with BigQuery, we didn't need that first part. It would have needed setting up a whole project around it on Google Cloud, which we didn't need since our project was already tracked with Git.
08:31But the tool it ships with for turning data into the OKF format is designed only for BigQuery. So as a workaround, we created a skill called markdown to OKF. What this skill does is convert any folder of markdown files into an open knowledge format bundle following the spec.
08:45And the way it's designed, code does most of the work. Only a small part is handled by an agent for the judgment based stuff. It follows a script first approach, and that's because doing the work through code puts less load on the agent and uses fewer tokens.
08:58The skill has a script that converts markdown into the OKF format. It also includes evals to test the conversion so it performs reliably, and these evals are basically prompts that the agent runs against the output to make sure everything was converted correctly. So we then switched to our new branch and asked it to do the conversion.
09:15It ran all the scripts and converted the files using the instructions, and this created an index dot m d file with links to all the sub folders by referencing them. If you've used Obsidian before, you'll know this is really similar to how it connects different pages, and this is also what Obsidian uses to build its graph view.
09:32And the index dot m d doesn't just exist at the root level, it also exists inside each sub folder. Each one lists everything inside that folder so the agent knows what content is available there. Now like we mentioned, OKF ships with a visualization tool.
09:45So we ran it on our bundle using the visualize command in the terminal, and it generated an HTML document representing the entire knowledge base, and you can just open it in a browser. It lays out all the nodes along with the connections between files, which gives you an interactive way of understanding the whole system and how everything connects.
10:03So with all our documents converted into the OKF structure, we tested how it performed when searching. But when we first asked it to look for a file, it just defaulted to the way it normally searches by matching patterns. And that's because OKF isn't a widely adopted standard yet and only came out recently, so Claude didn't really know it existed.
10:20To fix that, we added a section in the Claude dot m d file explaining how to navigate the system, what role each file plays, and how the structure should be used. Once that was in place, we asked it to navigate to a certain file. And this time, it started going through the index dot m d files we'd created.
10:36And it was able to give results way faster than searching through the entire knowledge base the way Claude would normally do here. It also used fewer tokens because it loaded the YAML metadata first. So it got an understanding of what each file held before deciding whether it actually needed to open it.
10:50So the main advantages you'll get are two things, lower token usage and faster retrieval times. It really is a quicker way to pull information with less chance of the errors we talked about earlier. And because the structure is documented in the claud.md file, it won't forget where files belong.
11:06On top of that, it knows what each file does because it's spelled out in the index dot m d files. Right now, models are already pretty capable on their own with pattern matching and running their own terminal commands. So until it becomes an open standard that agents support out of the box, this is more of an optimization than something you really need.
11:23Now the skills we created can be found in AI Labs pro, which is our community. That's where you'll get the resources, the starter packs, and more along with a place to interact with a bunch of like minded nerds including our team. So if you found value in what we do and want to support the channel, this is the best way to do it.
11:39The link's in the description. Description. That brings us to the end of this video.
11:42If you'd like to support the channel and help us keep making videos like this, you can do so by using the super thanks button below. As always, thank you for watching, and I'll see you in the next one.
The Hook
The bait, then the rug-pull.
Every team building on Claude Code eventually hits the same wall: a knowledge base that made sense when one person built it becomes a token sink and a navigation maze the moment it grows or gets shared. Google's Open Knowledge Format is the spec that fixes this -- and AI Labs ran it against their own second brain to find out if the promises hold.
Named ideas worth stealing.
02:15model
Open Knowledge Format (OKF)
- concept files (one topic per file)
- index.md (folder entry point)
- YAML front matter (type/title/description/tags)
- bundle (the full directory)
A portable standard for agent-readable markdown knowledge bases. Agent reads index.md first, loads only YAML metadata before deciding to open a file.
Steal forAny team knowledge base, second brain, or documentation tree that an AI agent needs to navigate
03:00concept
RAG vs. LLM-Wiki
- RAG: vectors, rebuilds answer each query, no accumulation
- LLM-Wiki: markdown filesystem, agent builds context as it navigates, knowledge compounds
Karpathy's insight: an agent navigating a structured markdown file system accumulates knowledge across a session; RAG does not.
Steal forChoosing the right memory strategy for any long-running agent workflow
06:04list
OKF Three Principles
- Minimally opinionated -- only requires a type field
- Producer/consumer independence -- format decoupled from tooling at both ends
- Portability -- just markdown + YAML + files, no SDK or runtime
The design philosophy behind OKF that keeps it interoperable across tools and teams.
Steal forDesigning any cross-tool standard or shared format
How they asked for the click.
VERBAL ASK
11:03product
“The skills we created can be found in AI Labs Pro, which is our community. That's where you'll get the resources, the starter packs, and more along with a place to interact with a bunch of like-minded nerds including our team.”
Soft community pitch after demo payoff, plus a secondary super-thanks CTA -- low friction, well-timed after proof-of-value
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
