YT YouTube2Text

YouTube2Text → Transcripts → Full Guide - Build Your Own AI Second Brain with Claude Code

Full Guide - Build Your Own AI Second Brain with Claude Code — Transcript

by Cole Medin · 5,302 words · 741 segments · language it · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00I've been building my second brain with
0:01Claude code for the last 3 months and
0:04it's gotten to the point where it saves
0:05me at least a dozen hours of work and I
0:08promise you I'm not exaggerating for the
0:11sake of this video. So right now, I want
0:13to show you all of the components of my
0:16second brain, talk about the skills and
0:17the use cases, the things that I'm
0:19automating. I've been running a very
0:22similar business for the last year and a
0:24half and so I know how long it takes for
0:26me to do a lot of these things that I've
0:28started to automate with the help of my
0:30second brain and there is a stark
0:32contrast for a lot of parts of the
0:34business with how long it took back then
0:37and how long it takes now. So I don't
0:39use my second brain to work less, but it
0:43takes things off my plate so I can move
0:44my business forward faster, focusing
0:47more on the high-leverage tasks. That's
0:49the main goal of building a second brain
0:51is to release some of your capacity so
0:54you can dedicate it to things that
0:56matter more. So I'm here in my Slack,
0:58which is one of the places where to my
1:00second brain just like I would a friend
1:02or co-worker. So a lot of examples here
1:04are things I do with my second brain. I
1:06have it help me ideate for my content,
1:09creating YouTube scripts based on my
1:11tone of voice and my content calendar,
1:13managing my inbox, helping me research
1:16and keep up with all the craziness in
1:17the AI industry right now, but also
1:19specific to my interests. It even helps
1:22me with image generation and diagram
1:23generation, like creating thumbnails,
1:25managing my habits to keep me on track
1:28every single day with the things I want
1:29to accomplish. I use my second brain to
1:31help me ideate, research and keep my
1:34business and my entire life very
1:36organized. And my second brain, which I
1:39built on top of Claude code and
1:40Obsidian, has been the biggest deal for
1:43my business since I started using Claude
1:46code itself. And the best part about
1:48this entire architecture, which I'll
1:49cover with you, is that everything
1:51compounds on itself. As you use your
1:53second brain more and more, it becomes
1:55more in tune with you, anticipating your
1:58needs. It builds up examples of how you
2:00communicate and work that it references
2:02later. The entire application evolves
2:04over time and you build this entire
2:06knowledge base. That's why I integrate
2:07with Obsidian because it's where I store
2:09all of my knowledge and have my agent
2:11evolve it over time. Every single
2:13document that you see here in my
2:15Obsidian graph is a part of my second
2:17brain. It builds up an index over time
2:19of all of my emails, all of my
2:21announcements and YouTube scripts. It
2:24literally is a brain that is expanding
2:27over time as I use it. All right, so
2:29here's what we're going to go through
2:30today. First, I'm going to address the
2:32elephant in the room. Why build your own
2:34AI second brain in the first place when
2:36we have things like Openclaw out there?
2:38Then we'll get into the architecture.
2:39I'll show you exactly what goes into
2:41each one of the components here, how we
2:43build in skills and use cases for our
2:45second brain, how we make it evolve
2:47itself over time. And then once you
2:49understand the core architecture of the
2:51second brain, then we're going to get
2:53into something special that I have for
2:55you here. This is a GitHub repo that
2:56I'll link to in the description. We're
2:58going to go through this Claude code
3:00skill that will walk you through
3:01creating your PRD for your second brain.
3:04So I'm not giving away all the code for
3:05my second brain, but the point is for
3:07you to build your own in the first place
3:08and this is how you start. And so at the
3:11end of the video, I'll go through this
3:13live with you, creating that document
3:15that outlines the full scope of work to
3:17create your second brain in phases to
3:19break it down nice and simple for you.
3:21All right, so I'm going to dive right
3:23into answering the big question here.
3:24Why do we care about building our own
3:26second brain when we can just run
3:27Openclaw? And so to start, I need to
3:30explain to you the lethal trifecta. And
3:33this is actually really important to
3:34understand just for agents in general.
3:36So the idea behind the lethal trifecta
3:38is we have a huge uptick in concern for
3:42our AI agent if all three of the
3:44criteria are met because this means that
3:46our agent is going to be very
3:47susceptible to security risks like
3:50prompt injection. You've probably heard
3:52about that a lot if you've set up
3:54Openclaw and done research on it
3:55yourself. And so we have private data
3:58access, untrusted content and an
4:00exfiltration vector. Let me explain each
4:02of the three of these really quick.
4:03They're super important. So first of
4:05all, we have private data access. If
4:07your agent has access to something like
4:09an email or calendar, that is step
4:11number one for the trifecta and for our
4:14second brains, this always applies.
4:16Otherwise, it wouldn't really be that
4:17helpful to us. And then the second
4:20pillar here is untrusted content. If
4:22there's any kind of input that can come
4:24into our AI agent that isn't from us,
4:27things like incoming emails or even web
4:29page content, all of those could
4:31theoretically contain malicious
4:33instructions for a prompt injection
4:35attack. And then last but not least, we
4:38have the exfiltration vector. It doesn't
4:40really matter if your agent can access
4:42private info and receive incoming
4:44information if there's no way to send
4:47your sensitive data out to the malicious
4:49attacker, your agent is going to be a
4:51lot harder to compromise.
4:54However, for our second brains, yeah,
4:56it's always going to have the ability to
4:57send a message or post to an API
4:59endpoint. We're giving so much power to
5:02our tools, especially something like
5:03Openclaw like I'll talk about in a
5:05second here.
5:06And so the argument with the lethal
5:07trifecta is really all three of these
5:10need to be in place. Like if there's a
5:11way to send sensitive information to a
5:15malicious user
5:17and then access our private information.
5:19But there isn't really a way to receive
5:21a prompt injection attack. Like we can't
5:23receive any other inputs, then there's
5:26not really a risk here. Like if only
5:27these two things apply, there's a lot
5:29less of a security concern. Or if there
5:32is untrusted content coming in and we do
5:34have an exfiltration vector, but there's
5:36no private information for the agent to
5:37access, then again, the risk for our
5:40agent goes down significantly. But like
5:43I already said, all three of these are
5:44always going to apply to our second
5:46brains. They have all three by default.
5:48It's really hard to make a useful second
5:51brain without being exposed to the
5:53lethal trifecta.
5:55Okay, so cool. What's the point you're
5:56trying to make here? Well, hear me out
5:58on this. If we are really forced to be
6:00exposed to the lethal trifecta with our
6:03second brain cuz that's the only way
6:04that it's useful, then what it means is
6:06we have to be very careful about our
6:08implementation cuz we want to limit each
6:10one of these pillars as much as
6:12possible. And honestly, Openclaw and
6:15other solutions that are already out
6:17there, they don't do a very good job
6:20limiting especially the private data
6:22access and the exfiltration vectors.
6:24They've been doing like Openclaw's been
6:25doing a lot of work recently on handling
6:27prompt injection attacks and I have to
6:29hand it to them. Some of the security
6:31risks and other things that were a big
6:33deal at first have been addressed. And
6:35so Openclaw is something that is
6:37constantly evolving, but there still are
6:39a lot of security issues and the main
6:41problem, even outside of the, you know,
6:44issues in the code base itself, is that
6:46it is a massive code base that you don't
6:48understand. You're running something
6:50that it's hard for you to adjust
6:52yourself. It's hard for you to
6:54understand. You're giving so much
6:55control to an AI agent and you don't
6:57really know in what ways you're actually
6:59giving control. Like you don't have
7:01understanding of how the lethal trifecta
7:04is really affecting you. And so when you
7:06build your own, you actually get to
7:08control what you build. You define the
7:10permissions up front. You create the
7:12foundation so you get to layer on the
7:14capabilities as you evolve your second
7:16brain versus just running something that
7:18works and does way too much out of the
7:20box right away. And yes, it does mean
7:23that it is more work for us to create
7:25our own second brain and not just use
7:26something out of the box. But in the
7:28end, you're going to create something
7:29that is customized to exactly what you
7:32need and it's going to be a lot simpler,
7:34following the classic advice we've
7:36always had for building AI agents. You
7:38just want to work with simple composable
7:41patterns. And yeah, for a lot of the
7:43second brain that I'll show you here,
7:44it's just Claude code with skills that
7:46drives most of the capability here. It's
7:48a beautiful thing. And then for a lot of
7:51the rest of the architecture that I'll
7:52cover with you in just a second here,
7:54the beautiful thing here is we're not
7:56just building it from scratch. As much
7:59as I just dissed Openclaw for being a
8:02security risk, it is a beautifully
8:05crafted application. Like don't get me
8:07wrong, Openclaw is very impressive and
8:09there's a reason that it really took the
8:11internet by storm. And so we're not
8:13going to ignore it, but we're also not
8:14going to run it directly. Instead, what
8:17we're going to do is take inspiration
8:19from Openclaw. So literally as I built
8:21my second brain on top of Claude code, I
8:24pointed it to the Openclaw GitHub
8:26repository cuz it's fully open source
8:28and I said, "Look here and see how they
8:30implement the memory layer with the
8:31soul.md and the user.md. I want you to
8:34see how they implement the heartbeat for
8:36the proactive part of the agent." And it
8:38took a lot of inspiration from that code
8:40base and brought the things that I liked
8:42about it into my own version, but I
8:44still get to maintain control and build
8:46up the exact permissions and
8:48capabilities I'm giving to my agent over
8:49time. That is the big unlock here. So we
8:52build it ourselves, but we take
8:54inspiration from what's already out
8:55there so that we can stand on the
8:57shoulder of giants. So with that, let's
8:59actually get into the architecture now.
9:00I'll show you at a high level how I
9:02built each one of these components. Now,
9:04it would take a very long time to build
9:06the entire thing from scratch with you.
9:08That's also why I have the template as a
9:10starting point. But if you do want to
9:12see me build this entire second brain
9:15from scratch, I'm running a special
9:174-hour workshop in the Dynamis community
9:19this Friday, April 3rd at 11:00 a.m.
9:22Central Time where I will take this
9:24starter template that I'm showing you
9:25right now and show you what it looks
9:27like to build everything live, taking
9:29inspiration from solutions like
9:31Openclaw. So by the end of it, you'll
9:32have your own working second brain with
9:34everything I'm about to cover with you.
9:36So check that out if you are interested.
9:38Otherwise, let's go ahead and get right
9:39into the architecture here. So the first
9:42big thing that I took inspiration from
9:44with Openclaw is the memory layer. So if
9:47you've seen Openclaw before, you'll
9:49recognize some of these files like the
9:51soul.md, the user.md, the memory.md.
9:55That architecture is genius and it's so
9:57simple. As part of the power of our
9:59second brain is that we're managing
10:01things with just markdown documents,
10:03which is also why Obsidian is such a
10:05powerful tool to use alongside Claude
10:08Code for your second brain. So, I talk
10:10to my brain with Claude Code, but then
10:13Obsidian is my canvas to view things
10:15like the diagrams that it generates for
10:17me like we're looking at right here, all
10:19of my different documents, so I can like
10:21load up the user.md like we're looking
10:23at right here. So, as it evolves this
10:25over time, I can watch this and even,
10:27you know, correct some things that I
10:28need to. And so, within my memory folder
10:32that I have right here in my Obsidian
10:33vault, I have everything that we're
10:35going to get into here. Actually, quite
10:37a few things. I manage my entire life
10:39with my second brain now. So, we have
10:41the user.md that I just showed you, the
10:43memory.md, so keeping track of all my
10:45key decisions that I'm making every
10:47single day. Like these are some of the
10:48key decisions that I made as I was first
10:50building my custom second brain. And
10:53then we have the soul.md, so this is the
10:55personality that I give to my second
10:57brain. And again, just taking this
10:58directly from Open Claw cuz I love this
11:01approach. There's no security issues
11:03with this part of Open Claw, so I'm just
11:05leaning right into it.
11:07And all of these core files that we have
11:09in our memory layer inspired by Open
11:11Claw, we're bringing them right into the
11:14context of our Claude Code up front
11:16through a session start hook. So, we
11:18automatically load the soul, user, and
11:20memory.mds into the context of our
11:23Claude Code. And hooks are actually a
11:25pretty important part of our Claude Code
11:27second brain beyond this as well because
11:29we also have a pre-compact hook. So,
11:31whenever our conversation is getting
11:33really, really long, we have to do a
11:34memory compaction or move on to another
11:36conversation, we need to make sure that
11:38we save this conversation to our daily
11:41log because we want our second brain to
11:44learn from every single conversation.
11:47So, we build up this quite long daily
11:50log every single day. And then we have
11:52this daily reflection process. So, this
11:54happens through just a cron job. I run
11:56this once a day. This uses the Claude
11:58Agent SDK under the hood, and it just
12:00goes through this promotion process cuz
12:02we have this super long raw daily log
12:05from all of our conversations. We have
12:06to figure out what do we care about
12:09remembering all of the time, right? Like
12:11what should we promote to the memory.md
12:13file that is always loaded into the
12:15context of our Claude Code. So, it
12:17extracts things like key decisions,
12:19lessons learned, important facts. This
12:21is one of the most important parts that
12:23of our system that allows our agent to
12:26evolve over time.
12:28And then we do the same thing whenever
12:29we end a conversation as well. I mean,
12:31especially cuz we aren't always
12:32compacting, right? Whenever we end a
12:34Claude Code session, we have the hook
12:36here that does the same thing. So, daily
12:38log is where we dump everything, and
12:40then we do our promotion process to, you
12:42know, this core file. This is probably
12:45the most important file for the entire
12:47second brain. And then another important
12:49thing here is the memory.md because it
12:51is a more concise version of our daily
12:53logs, it doesn't always have all the
12:55information we'd want to search back
12:57through. And so, we also do allow our
12:59agent to perform rag. So, we index all
13:03of our daily logs into a SQLite
13:05database, and you could do Postgres as
13:07well, doesn't really matter, but we
13:08index it there so our agent can search
13:10through all of the daily logs. If we
13:12want to find something really specific
13:14that might not have been quite important
13:16enough to make its way into the
13:17memory.md, but we still might want to
13:19reference that in a later conversation.
13:22So, when our agent performs rag, it has
13:24access to all of the documents that you
13:26see here in the Obsidian graph view,
13:29everything in our daily logs folder. I
13:31mean, take a look at this. I have a file
13:33for every single day since I've been
13:36running my second brain. Okay, so I
13:38started with the memory layer because it
13:40really is the core part of our second
13:42brain. But we also need to give arms to
13:44our second brain. They need to be able
13:46to do things on our behalf, and that is
13:49where skills come in. And Claude Code
13:52plus skills is all we need for our
13:54capabilities. Again, going back to our
13:56other diagram here, we want to focus on
13:58simple composable patterns. That's how
14:00you want to build agents all of the
14:02time, and that's all we need. We don't
14:04need other applications running to our
14:05second brain. We don't even need MCP
14:07servers. I literally use my skills for
14:09everything. And so, I'll show you inside
14:12the belly of the beast right here. This
14:13is my repo for my own second brain. It's
14:16pretty messy cuz this is where I do my
14:17work every single day. But if we look in
14:19the .claude/skills directory, take a
14:21look at this. There are so many skills
14:23that I'm using. I'm using all of these
14:24at least on a weekly basis. I've covered
14:27a lot of them on my channel before like
14:29the Excalidraw diagram skill. Link to
14:31the video for that right here. I love
14:34using this all of the time to generate
14:36diagrams like the one that you're
14:37looking at right here. And the thing is,
14:39for the Excalidraw diagram skill, all of
14:41the skills that I have for generating
14:43PowerPoints and helping me create
14:45YouTube scripts, like all of these, the
14:46memory layer is powering them, right?
14:49Like the skill is going to create a very
14:51generic diagram or a very generic
14:53YouTube script unless it is able to
14:55access the memory here, understanding
14:57how I've scripted similar videos in the
14:59past or just like going back to my
15:01memory.md or my user.md. So, the skills
15:05are made very specific to me through,
15:07you know, some of the prompting in the
15:08skill itself, but especially because
15:10every single conversation, the memory is
15:12powering all the capabilities that I
15:14leverage through my skills. And then one
15:16of the core skills that I have for my
15:18second brain is one that explains all of
15:21my direct integrations and exactly how
15:23to use the APIs that I've set up for to
15:26work with my services like Gmail, Asana,
15:29Circle where I have my Dynamis AI
15:31community, Slack. Wherever I am doing
15:33work, my second brain has access to it
15:36as well. And I have a skill that
15:37explains all the capabilities that it
15:39has right here. Now, the important thing
15:41that makes this different than what you
15:44would have with Open Claw by default is
15:46I'm very careful through my Python API
15:49layer the different capabilities that I
15:51give it access to through these
15:53different APIs. And so, it can only read
15:56my Slack. It can't actually post
15:58messages. It can't create things in
16:00Google Docs. It can't manage my
16:02calendar, but it can tell me events that
16:03I have. But sometimes where necessary, I
16:06do give it right access. Like it can
16:08create Gmail drafts, it just can't send
16:11emails. I can have it manage Asana
16:12tasks, but only in certain projects. And
16:14so, because this is my own second brain,
16:16I have full control. I can [snorts] be
16:18very, very nitpicky about the
16:20permissions that I'm actually giving it,
16:22and I can evolve it over time if I want,
16:24but I'm starting with sort of like a
16:25zero-trust mindset. Like let's start
16:27with just read-only, and then add in
16:29capabilities and be very controlled
16:31about that. And for all of my direct
16:33integrations, I've implemented them with
16:35a very common pattern. And what that
16:37means is I can have my second brain
16:39evolve itself creating new integrations
16:42by just one-shotting them with Claude
16:43Code. It is so easy because it can
16:45reference existing integrations and its
16:48memory of how it's built things in the
16:49past to basically do the whole planning
16:52part of the AI coding workflow itself.
16:55And that's also how I built my chat
16:57interface. So, Slack is created in a way
17:00where I could just copy this for any
17:01other platform I want to integrate like
17:03Telegram or Discord. And so, being able
17:06to have your second brain reference
17:07itself as well as other solutions like
17:10Open Claw just means that it's very It's
17:13just incredibly easy to build on top of
17:16your second brain. All right, so the
17:18last thing that I want to cover with my
17:19second brain before I get into the
17:21template for you is the heartbeat. And
17:23this really brings everything together
17:25because it's where we build the
17:26proactive nature of our second brain. It
17:28can start to anticipate our needs and do
17:31things on our behalf that we want it to
17:33without us having to even ask it. And
17:36so, we have all of these direct
17:37integrations with these services like
17:40Gmail and my my task management, but I
17:43don't always want to be the one to
17:44prompt it to do things for me. Like what
17:46if I wanted to automatically draft
17:48replies to a bunch of my emails? That's
17:51where the heartbeat comes in. So, it's
17:53going to gather information through all
17:56of the APIs with the direct
17:57integrations. So, we have this
17:59deterministic part before we even go
18:00into Claude Code where we're gathering a
18:03context around my life that's happening
18:05right now. And then we send all of that
18:07pertinent information into Claude Code.
18:09So, we're using the Agent SDK because
18:11we're invoking Claude Code
18:12programmatically. I'm not prompting it
18:14myself. So, I have a preconfigured
18:16prompt where it's that plus all of the
18:18information from the APIs that's sent
18:21into Claude Code so it can reason about
18:22like, "Okay, let me draft these replies.
18:24Let me handle this pull request in
18:26GitHub. Like what do I need to help code
18:27with right now?" It thinks about all
18:29that. It acts on that. And then it sends
18:31a notification to me in Slack to keep me
18:33in the loop for everything that I got
18:35going on in my life and the ways that
18:36it's helping me proactively. And so, I
18:38do have to blur a lot of this here
18:39because it's pretty sensitive
18:40information, but just showing you an
18:42example of what it looks like for my
18:43second brain to be sending me these
18:45alerts. And then if I want to, I can
18:46always reply to one of these in a thread
18:48in Slack to continue the conversation
18:51for something that it did for me. So,
18:52this is just a starting point, but it is
18:55a beautiful starting point. The
18:56heartbeat is the thing that saves me the
18:57most time out of everything in the
18:59second brain.
19:01All right, so now that you know how my
19:03second brain works, I want to help you
19:05build it. Now, like I said at the start
19:08of the video, I'm not just going to give
19:10my entire code base away cuz it also
19:12defeats the purpose of you building your
19:14own. Otherwise, I'm just going to be
19:15building another Open Claw. I want you
19:18to create the foundation for yourself,
19:20but still give you a starting point. And
19:22I thought long and hard about how to do
19:24that. How do I help you scope out the
19:26work without giving you a template and
19:28just another Open Claw? And so, what
19:30I've come up with here is a system. So,
19:32I have this requirements document that
19:34you can fill out, and then you can feed
19:36this in as context to your coding agent
19:38to create the PRD. This is your initial
19:42scope of work. It'll have all the phases
19:44to build everything in the second brain
19:46that I've gone over with you. And
19:48everything that you're looking at right
19:49here is in the GitHub repo that I'll
19:50link to in the description. So, you just
19:52clone the repository, find this my
19:54second brain requirements markdown
19:56document, and then you can edit
19:58everything here. So, you fill in all the
19:59blanks to describe exactly what you want
20:01your second brain to help you with, the
20:03level of permission and proactivity that
20:05you want. And then once you have this
20:07filled out, then you open your Claude
20:09code or code extra open coder whatever,
20:11and you run this skill, the create
20:13second brain PRD. You just have to give
20:16the path to your filled in requirements.
20:17So, right click, copy relative path,
20:19paste it in, and then boom, that is all
20:21you have to do. And I'll show you a live
20:22example of this in just a second here.
20:24But this will produce a requirements
20:26document that has all of the phases to
20:29build out everything that I've covered
20:31with you with my second brain. And so
20:33you're using what I built as a starting
20:34point, but because it's a PRD and not a
20:36code base, it's very easy to edit
20:39everything. tweak it to your heart's
20:40content to really customize it to you
20:42before you actually write a single line
20:44of code. And to make this even easier
20:46for you, I have an example of the
20:48requirements that's already filled out
20:50that you can use as a reference if you'd
20:52like. And this is what I'm going to show
20:53you right now. So, I just made up a
20:55random person here. You just share some
20:56information about you so it knows your
20:58name and your time zone and things like
20:59that. You check off the platforms that
21:02you want your second brain to integrate
21:03with. So, wherever you do your work, you
21:05want your second brain to live as well.
21:07And then listing out all the tasks that
21:09you want it to do. I even have examples
21:11for every part of the template for you
21:13to work off of. And then add in whatever
21:15you want. The proactivity level is also
21:17very important. So, it's whatever you're
21:19comfortable with. Do you want your agent
21:20to be an observer so that it's really
21:22just read only actions on everything? Or
21:25maybe you want to go so far as it's a
21:26partner. It can act autonomously even
21:28sending emails on your behalf. You can
21:30pick your level. Generally what I do is
21:33the advisor. That's what my second brain
21:34is. And then for security boundaries,
21:36like what do you want your agent to
21:37never do? We want to have a big emphasis
21:40on security for our planning and our
21:42implementation. Memory categories, what
21:45types of knowledge we want it to track
21:46and maintain and search through over
21:48time. The infrastructure, so where do we
21:50want to deploy this? Like maybe you want
21:52your second brain only ever running on
21:53your computer. Other times you might
21:55want it running remotely so it's
21:56accessible 24/7. So, hosted in some kind
21:59of droplet like in Digital Ocean or
22:01Hostinger, and then you can access it
22:02from Slack remotely. I have that set up
22:04as well.
22:06And then just uh laying out your
22:07priorities for integrations cuz that'll
22:09determine exactly how it creates the
22:11phases in the PRD. So, you fill in
22:14everything just like I've done here. And
22:16then I'll actually do this right now.
22:17I'll do {slash} create second brain PRD.
22:19I'll pass the path to this example here.
22:22And it's going to take a while cuz it's
22:24going to do a lot of research. It's
22:25going to take into account all the
22:27customizations that you want to specify.
22:29This is also where you could point it to
22:31a repository like open claw and say, "I
22:33want to take inspiration for how open
22:35claw did this or how Nemo claw did
22:37this." So, there's a lot of resources
22:39out there already that you can feed in
22:42to your coding agent. That's the beauty
22:43of using a coding agent here is you can
22:45customize things as much as you want.
22:46So, I'll come back once I have the PRD
22:49created. I'll show you what that looks
22:50like, too.
22:51And there we go. Our PRD is created. So,
22:54it outputs to the dot agents plans
22:56folder by default. Doesn't really matter
22:57where this is, but the important thing
22:59is that each of the phases that we have
23:01laid out in this PRD maps to everything
23:05that I've shown you in this diagram. And
23:06it's put in an order where we can build
23:08them one at a time. So, you can start by
23:10creating the memory foundation and
23:12you'll already have at least a part of a
23:14second brain that's pretty useful. And
23:16then you'll build in the hooks for
23:18context persistence and loading them
23:19into your sessions. You'll go on to
23:21building the memory search and then
23:23start getting into your integrations and
23:24the skills and adding in capabilities.
23:26You build it over time. We don't want to
23:28have our coding agent try to build your
23:29entire second brain in one shot. That is
23:31not going to work and it's going to be
23:33really hard to stay in the driver's seat
23:35of exactly what you're building in. So,
23:38that's why we do it in phases. And so,
23:40literally what you can do at this point,
23:41once you have your PRD, is you can go
23:44into a brand new Claude code session.
23:46You can point it to the PRD. Like I'll
23:48just copy this path, paste it in here,
23:50and say, "Let's build phase one." Right?
23:53Or if you have already built the first
23:54few phases, you can say, "Let's build
23:55phase four." And then you can kick off a
23:57planning session, figure out exactly
23:59what you want to build, if you want to
24:00tweak anything from the PRD. You go in,
24:03you create the code, you test it, and
24:04you can create your entire second brain
24:06this way in just a couple of days. It
24:09doesn't take long to get to the point
24:11where you have something as powerful as
24:13open claw, but it's entirely your own
24:15and it's a lot simpler to maintain and
24:18more secure. And so I would encourage
24:20you to try it out. I have the template
24:21and this diagram both in the GitHub repo
24:23linked in the description. Even if you
24:25already have a second brain, go through
24:27this process to get some inspiration to
24:29evolve what you already have. And
24:31remember, come and join Dynamis to be a
24:33part of the four-hour second brain
24:35workshop happening this Friday, April
24:383rd. I'm going to be building the entire
24:40thing from scratch, walking through it
24:42all in a lot more detail. So, I hope to
24:44see you there. And I hope that this
24:45video was a good starting point for you,
24:47even just showing you what goes into a
24:49powerful second brain that can save you
24:50hours and hours every single week. And
24:53so, if you appreciated this video and
24:54you're looking forward to more things on
24:56building agents and second brains, I
24:57would really appreciate a like and a
24:59subscribe. And with that, I will see you
25:01in the next video.

About this transcript

This page contains the full transcript of Full Guide - Build Your Own AI Second Brain with Claude Code by Cole Medin, generated from the public captions YouTube serves with the video. The transcript has 5,302 words across 741 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.