With no context, your agent is as generic as someone else's

If you run a Hermes agent with no context, it is going to be as generic as someone else's agent. And if your agent runs on bad context, your agent is going to perform worse.

Recognize this?

So I built an AI operating system to run my life with Hermes and Obsidian, and I think building a system like that is the highest leverage action you can take.

• My notes and context live inside Obsidian, and Hermes runs the routines.

• NotebookLM (aka Gemini Notebook) helps me ask questions across hundreds of sources.

• Plannotator helps me avoid AI slop in my Obsidian vault.

• Every day, the system creates a daily note.

• Every week, it turns those notes into a review.

• The dashboard gives me visibility on how my life is going.

Below I go through the whole system, show how the different parts fit together, and explain how you can start building one. The first version is a folder, one file, and one skill. It's very simple, and we don't want to overcomplicate this.

Only one of the five layers is the model

For an AI OS, you have different layers.

You have a context layer, which is your files. You have a layer of instructions that tells the model how to operate with those files. You have the model itself, which could be GPT, it could be a Claude model. You have the agentic harness, which is Hermes Agent. Then you have skills, and skills are playbooks that tell Hermes how to accomplish different types of work, so you don't explain yourself over and over.

Hermes Agent is an agent harness, and the advantage of that is you can use any model with it. That makes the system durable and not tied to one provider.

I use Claude Code a lot, and Claude Code is closed source. If I don't like something about it, I can't modify it, I can't really change it. With Hermes Agent it is fully open source and transparent. I know the system prompt. I can create my own plugins.

That is also why I want to build my personal knowledge system on Hermes. It is open source, it has a plugin system, and I connect it with Obsidian so that everything is stored locally and the system is durable for years ahead. This is the concept of file over app.

Obsidian is a memory layer you own. It is your notes, it is all of your context.

Set up a daily note system and agent memory

Here is the whole first version, so you know what you are building before you start: a vault, a folder for your daily notes, one AGENTS.md file, and one skill. That's it.

You go to Obsidian, download it, and create a vault. Then you create a very simple structure: a folder called Notes, with a subfolder called Daily, for the daily notes you take in the morning. As your vault becomes more complex you might need to create more folders, but for now this is the simplest thing you can do.

Then AGENTS.md. This is the part that explains to Hermes Agent how to work with me. What are the rules we establish, what are the boundaries. This folder contains only my notes, so I can have boundaries between me and AI-generated notes. What are the hard rules Hermes should not be doing. What is my vault structure, because mine has about six thousand notes and Hermes just gets lost if you have a vault that large, so you need to guide it, to provide instructions on the structure of your vault, how to place your notes, and how to create templates.

AGENTS.md is your static memory layer. It holds the things that don't change every day: your preferred communication style, the tools you use, who you are.

Then you install Hermes Agent, add the folder as a project, and you are ready to go. You don't need any MCP to connect Hermes to Obsidian. Hermes can natively read those Markdown files.

Now the first real routine. I told Hermes: set up a morning routine skill, which asks me questions about what's going on, what's on my mind, how do I feel, how I slept, and I want a template for that.

Then I answered it, on camera. Right now I'm recording a video, it's 8am, feeling good. Sleep schedule is kinda inconsistent, went to bed at 12, woke up at 6, so we can do better here...

Frontmatter is very useful to filter and sort your notes. With frontmatter, Hermes can query your Obsidian vault like a database, and once you have more data points it becomes very easy to see patterns.

The first version put the note in the wrong folder. So I said: let's move it, and let's update the skill so that next time we won't make the same mistake.

The last piece is cron. Cron jobs let you run the prompts or those skills autonomously on a schedule. So tomorrow at 6am I'm going to have the chat already there with this context ready for me. And you can expand it to go through your emails, do some news reading, maybe some YouTube reading. All of that is possible, and it's really bounded by your imagination.

After seven days, over the weekend, you can ask it to do a weekly review: analyze seven days of your daily notes, find patterns, and understand how to plan your next week.

The dashboard gives you visibility on how your life is going

So we have this daily note. What I want to show you next is how to build your life OS dashboard.

We need to extend Obsidian to enable display of those kinds of dashboards. Community plugins, exit restricted mode, browse, and the one you need is called Datacore. Then I asked Hermes for the alignment dashboard: use the Datacore plugin to display the data and plot the graph, start with my sleep score and my readiness score from Oura Ring.

From there you can track your steps, your activity levels, your training, your habits. I track YouTube, so it's pulling from the YouTube API and displaying right there.

To design the full thing rather than one plot, I take a screenshot of the dashboard and go to Claude Design. You explore a few directions, comment on the one you like, export it as a project file, and hand it to Hermes to implement.

That's your alignment dashboard. Highly recommend. Incredibly useful.

The biggest mistake is prompting without direction

How do you work with Hermes agent, how do you stay aligned, how do you avoid redoing work twice? I think that's the biggest mistake people make when they're just starting. They're constantly prompting AI without understanding the direction, where they want to go.

You don't want to say "hey agent, go implement this thing for me", one sentence of context and that's it. That is not going to give you great results, because the output of the agent is going to be very much misaligned with what you actually want.

So I use a tool called Plannotator. It's open source and it's free. I tell the agent to write me a plan as an HTML artifact and to ask me clarifying questions inside that file, then open it in Plannotator.

Once you send feedback it goes back to Hermes, and the agent understands what's going on and how to proceed with this plan. This process of aligning yourself with the agent is what increases your results and your throughput, by asking proper questions.

And one question I really love to ask Hermes: ask me the top ten questions that are going to reduce uncertainty the most. Hermes works out what the most fuzzy parts of the plan are, and how we can reduce uncertainty in that plan.

I use it beyond plans too, for doing my designs, as a local alternative to Claude Design.

NotebookLM is the oracle for context that will never fit

There is a problem of context window, and the context window of those models is actually finite. In one of my sessions I have a 200K token window, and one token is approximately four characters. It doesn't really scale if you want to chat with five hundred YouTube videos. NotebookLM does: three hundred videos, three hundred sources at once, and you can chat about the sources from inside Hermes agent.

But I don't want to prompt NotebookLM by hand. I think we're past this era of a human prompting something. In the web app you can only ask one question at a time, and that's a big bottleneck. Through the CLI you can ask around five questions in parallel. So I gave Hermes a YouTube channel, How I AI: upload the last 100 videos from this channel, ask five questions, and save into my NotebookLM vault. What are the trends, what's going on right now, what are the unique ideas that may be underexplored.

We have exact citations saved in our Obsidian vault, so we can track back to the source. I haven't even touched NotebookLM, I didn't prompt anything there, it just asked all of these questions for us. That's a highly valuable workflow if you want to learn some complex space: upload a whole YouTube channel on that topic and just ask questions. Those sources are actually YouTube videos, so they're grounded to actual human experience, which is much more valuable than asking AI about something. I treat NotebookLM as sort of an oracle, where the agent can hold this big chunk of context and ask any question on that topic.

It grows with you

The part of Hermes that I find really exciting is the self-improvement loop, where it can create skills, improve skills and memory based on your live interaction with it.

Every 10 user prompts there is another sub-agent that looks at the whole conversation and classifies whether something should be saved to memory. That's the memory layer. There's also a skill layer doing a similar thing: when a prompt takes a lot of tool calls to accomplish, 10 tool iterations inside a single turn, it creates a skill for that kind of situation.

There's a skill called journey, and it's a command. You can see that you start from literally nothing, and then Hermes over time starts creating those skills and memories. One of mine is the rule that I should follow the vault authorship contract. Another is a skill for how to do screen recording properly on macOS, which it wrote after I'd been talking about it.

So this agent really grows with you, and you can see your progress, which is a unique feature of the Hermes agent. I haven't seen that in any of the other agents.

If you want to use Hermes agent from your phone, here is how I set it up for Discord, where I separate my chats and profiles. Each chat has a separate context, and you can think of it as a different sub-agent with a different prompt and a different purpose.

Build it with me

I think building a system like this is the highest leverage action you can take. If you want to build the whole thing rather than a folder and one skill, that's The 30-Day Agentic Second Brain.

Artem

<3

Resources

• Watch the full build on YouTube

• Hermes Agents + Obsidian: My Second Brain Has a Team of Agents in Discord

• Obsidian: https://obsidian.md

• Datacore plugin

• Plannotator: github

Everything I do runs out of one folder. My work, my week, my notes, my goals.

I did not build it to be organized. I built it to stop explaining my life to an AI every single time I open it.

There are three things in here, and that is the whole system: the folder, the file the AI reads before it touches anything, and an agent pointed at that folder.

This is the whole thing. A folder on a desktop, with text files in it.

Layer one: the folder

This is a folder on my computer. Inside it are text files, and that is the entire thing. Obsidian is just a nice window into that folder. If I delete Obsidian right now, every one of these files is still sitting there, and I can open them in anything.

That matters more than it sounds, because it means nothing you build here is trapped. Not in an app, not in an AI, not in anyone's cloud.

Then you point an agent at that same directory. You pick your working directory, and in my case I pick the same one as my vault. That is it. No uploading, no importing, no connecting an account.

Today I am using Claude Code, and there is also Codex. That is what makes the system appealing: you can swap the AI and keep the system.

Three layers, and the bottom one is just a folder.

Two problems, two answers

Point an agent at a folder with thousands of files and it fails in two separate ways, and they need two different answers. The first: it does not know me. The second: it cannot read everything.

The second one has a number attached. Ask it to find your notes on some topic and it goes through the whole vault, reads all the projects and all the notes, and spends the context on the search instead of on the answer. In the video the context bar reads 136K while the dump zone, where Claude starts cutting corners, is around 300K.

So: one answer for it does not know me, one answer for it cannot read everything.

Answer one: one file it reads first

The first answer is a file the AI reads before it does anything else, every single time.

Inside it is who I am and how I work, written once instead of re-typed every session. A map of my vaults, personal and client. How I want to be worked with: I am a physicist, I think from first principles, I question best practices. Hard rules on what not to do, starting with never expose credentials. And the vault structure, which matters more than the rest, because it is the difference between an agent that knows where things live and one that searches blindly.

The part that does the most work is the data model: every note type, where it lives, what it is for.

It is two files rather than one for portability. CLAUDE.md holds a single line pointing at AGENTS.md, and every agent reads the same rules. That makes the vault model-agnostic and provider-agnostic, so it is not dependent on one company.

It is a text file. I can read it, edit it, keep it in version control, and take it into a completely different AI, whatever that turns out to be next year.

One file of instructions, read by both agents. Swapping the model does not cost you the setup.

Answer two: stop reading files, read a view

The second problem is the one people try to solve with a bigger context window. The actual answer is to read less.

I have a note type called Dashboard, and they go in one folder. A dashboard aggregates one kind of information, every goal or every session or every idea, into a table. Obsidian calls them Bases, and an agent cannot see them by default. The Obsidian CLI is what makes them readable:

bash obsidian list-views --file ideas.base obsidian query --file ideas.base

The results come back structured, which is what an agent prefers, and it can navigate them easily.

That is the whole unlock: we are not reading all of the files. Those files can be very long. We are reading a very tiny subset, one table view, and that is what makes this context-efficient.

To know what you are building, read one table. Not seven thousand files.

One practical note from the video: the agent got stuck the first time because it did not know the CLI existed. Kepano's Obsidian skills fixed that in one paste.

Both links are in Resources: the CLI at obsidian.md/cli and Kepano's skills on GitHub.

The loop that runs it

Everything above still needs me sitting at the machine. This next part does not, and it is the part I use the most, because it happens while I am asleep.

It starts at 6:00 AM every day. It instructs Claude to do my daily morning review: go into the vault, invoke my daily skill, follow the workflow. Nobody presses a button. I did not start it and I was not at the computer. I wake up and it is ready. I answer a few questions and the daily note is written.

The honest downside is that your computer has to be running and connected. The fix is to caffeinate your Mac so it never sleeps.

It had already run before he opened the laptop.

If you want the whole system built with you, that is the 30-Day Agentic Second Brain.

The loop that improves it

This is the part that turns a tool into a system. When it gets something wrong, I tell it once, and the next time it runs with no mistakes. That is a skill, a retrospective system.

Where a correction lands is a routing decision, and the rule is simple. If it should be shared across all of my work, it belongs in the memory. Otherwise it goes into the skills.

I stay in the loop. Claude proposes diffs, I pick what to apply, and then those corrections go into the system. Nothing you are doing is disappearing.

Extract what was learned, propose the diff, let him pick.

A mistake goes back into the rules once, and it does not come back next week.

What it looks like after a year

Everyone shows you their setup on day one. Clean vault, three notes, a graph with eight dots.

Mine has been running more than a year and it is a mess. Links point at notes I deleted. Hundreds of notes point to nothing at all. Notes still marked in progress that I have not touched since spring.

That is the honest version, and it is the reason this works. The system does not have to be perfect. It has to give you value in delivering your work. It really does not matter if your notes are not connected, or if you have orphans. That is fine.

A year in: 5,841 notes, 1,801 orphans, 1,196 broken links. It still delivers the work.

The fastest way to start

You do not need the routines, the dashboards or the retrospective to feel this. You need one file.

Make AGENTS.md in your vault root. Write who you are, how you want to be written for, and the

Resources

• Watch the video: https://youtu.be/Ws7lekerTrA

So now you have this feeling that you've done a big chunk of work with Claude, and you can tell that you taught it something along the way.

This is the moment when you want to capture this learning. It's also the moment when the learning might just disappear, if you close the session.

By the end of this you'll have two skills. One learns from the sessions you are currently working in, and the other reads every session you ever had and writes the fixes back to your vault.

Your notes are only half of it

Second brain is all of your context stored digitally.

It can live on the cloud, it can be on your machine, and most people keep it in their folder in an Obsidian vault and they call it a second brain.

And that's only half of it.

The other half is this folder, which almost nobody opens. And that's where you have every conversation stored with Claude, and it's on your computer right now.

What "better" actually means

Improving our second brain. What do we mean by that? Let's define it.

One way to improve it is to add your context, add more notes, more projects, more history. That's what everybody talks about.

And the other one is playbooks. That's actually how you plus AI execute the work. And this video is about playbooks.

Playbooks are, simply put, skills. And as you work with Claude, you have those conversation traces, and you can leverage this information to improve your second brain.

The memory layer is just files

Here is a memory layer. And the memory layer is just files on your computer.

You open Claude in a folder. And in that folder, you have agents.md or claude.md, you have the skills, sort of playbooks. And here is memory.md, which is just an index.

Why claude.md gets ignored

And here is the thing that you might notice, that the memory layer, so this part, gets ignored.

This is because claude.md is read at the start, and 500 lines later, the model is no longer looking at it anymore.

And if you put the same instruction into the skill and invoke that skill, it works much better, because it arrives in the most recent context.

The skill that catches it

Here is a skill, and this one I use the most, and that's going to help you to learn from your sessions. This is called the retrospective skill.

The retrospective skill runs exactly at this moment, when you're coming to the end of your Claude session.

It reads your current session. It pulls what actually changed, what are the corrections which you made, where Claude missed steps, where the work was redone, what actually worked.

And then it proposes edits to your actual setup, and you have a table where you can approve or reject additions, so you are in control.

Watch it run

So let's take an example right now. I was doing the outline for my video, and here we got so many corrections.

What I do is I tell Claude:

yeah, let's do retrospective and learn from the current session

As simple as this.

Those are real corrections which I have done, and Claude doesn't have them by default. You need to tell Claude to use this retrospective skill to actually learn from the session.

Next time I go through my video outlines, this never happens again.

And it applies to every skill you run, every session.

Where it breaks down

One thing it might not be good at is that when you are deep into the long context, here I had like 400K tokens. But if you go beyond that, the model actually forgets what happened at the start.

So mistakes early on in the session don't always get reflected properly.

So retrospective is something that you do only with a single session, when you want to teach Claude something about the current work you are doing, about what happened in this conversation.

A week of sessions instead

But if you take a week of work instead, this is where this new skill comes in, which I call session intelligence.

Most of our work is in a loop with a large language model. And in my scenario, it's 100%. All of the work is in those conversations, is in those sessions.

And I don't see those patterns of my interaction with Claude. And it could be that I repeat the same thing over and over. And this pattern you could be missing.

I built a second skill, which reads a week worth of sessions on the machine. It's very tunable. You can put it to read conversations and it produces one report.

What you keep repeating. Where the things keep breaking. How you actually work.

And the findings become a skill or a rule. And in the end, your setup gets actually better.

The folder with every conversation in it

The way it works is that you have this folder .claude on your computer.

It's a hidden folder and contains all of your conversations with Claude across all of the projects.

Here is the projects folder. And here is my artem-vault. This is where I work. I can go there, and you can see those files. And those files are actually my conversations with Claude, all stored locally.

And you can see the time when it was edited and it reflects the pattern of my conversations. So you can see they just go back in time. And you can look at them and you can actually analyze them.

And this is an example of this file. It has this weird formatting, but it contains all of your messages.

And the way I leverage this and I go about analyzing this is using sub-agents. This whole conversations are, there are tremendous amount of conversations. I use Haiku sub-agents to read the slices of the corpus. And then after we have done with the analysis, we merge findings into the report.

91 sessions in one report

I run this one about once a week. Here is how this report looks like. I analyze 91 sessions.

It has overall my theme, like where have I spent my time. It analyzes the work type. It gives me the amount of most useful skills. Actually, you can see that retrospective is my most used skills here.

And here are the recurring patterns which happen over and over. This is just a summary. But if you look into the roadmap here, you can see the actual analysis and ranking of all of the friction points which happen as you work.

A failure it found that I had already moved on from

And here is an example of a failure that happened.

I use this tool called Plannotator. And typically, that's how I annotate my HTML documents or my Markdown documents. And here you can provide comments.

And once you send feedback, what happened here is that feedback got lost. And I basically wasted a lot of time.

You can see my actual message. And here is the proposal. How can we improve so that this never happens again?

And in the moment, I didn't thought about that improvement. And by running this skill, it actually surfaced that.

What you stop doing

If you leverage all of your sessions or all of your conversations, the next piece of work that you're going to be doing is going to be much better.

It's going to be less friction for you to go through your work.

You actually stop explaining yourself. You stop repeating yourself.

You're actually training your second brain to work the way you work. It's not the other way around.

And actually, your work becomes more enjoyable. And this is the part you don't expect.

Start here

If you keep repeating yourself to Claude, this is for you.

And I want you to grab retrospective skill and run it on one session. And that's the whole first step. And this is what I run every day.

https://memory-evolved-artemzhutov.netlify.app

Artem

You think this one’s just for people who write code?
So did I.

If you are using Claude Code to run your life, all the knowledge you captured is sitting there.
Your sessions, your notes, your everything...
But now you can actually apply dynamic workflows reliably to extract insights and do meaningful work with it.

Fan out and synthesize: point a workflow at your sessions, your notes, your transcripts, and get one structured output back. The most common use case across my Obsidian.

Full video walkthrough here:

What a dynamic workflow actually is

You can think about dynamic workflows as a script which orchestrates agents.
Claude writes those JavaScript programs to orchestrate different sub-agents.
So you don’t hand-write the JavaScript. Claude writes the script for you.

The one building block is an agent. It has a model specification and an agent type.
Out of all of these agents, you can construct programs of two types.
You can execute those agents in parallel, or you can have a pipeline.
In our workflow we have a first phase as a draft, and then when all of those agents are finished, it goes into the second phase to check.

The HTML report the workflow produced: 49 sessions analyzed, 86 corrections mined. Every quote is verified against the actual session, with my real verbatim corrections shown next to the proposed CLAUDE.md edit.

Why use dynamic workflows at all

There are a few problems which have been around with Claude Code and existing sub-agents.

One of them is agent laziness. If you hand Claude a big task, say analyzing 50 items in a security review, or your daily notes, or analyzing videos, it can stop the task before actually finishing it completely.

With a workflow, this is not really possible. What we are doing is actually executing a program, and it’s deterministic. We are spawning all the sub-agents with isolated context, and there’s an actual deterministic program that runs to make sure all of the items have been addressed.

Another problem is if you’re working within the main Claude Code agent, it tends to have this self-preferential bias to prefer its own findings. With sub-agents, because each one has its own isolated context window, they’re on their own, and that allows you to remove this bias.

The final point is a goal drift. Claude tends to drift about its initial goal which was set if you run a session over many, many turns. That comes from this problem of context thread, and because we have those sub-agents with isolated context, we can actually solve this issue.

Mine your last 50 sessions for the corrections you keep making

I just asked Claude to set up a workflow and go through my last 50 sessions and turn them into recurring rules.

The prompt I used:

go through my last 50 sessions and mine them for the corrections I keep making and turn them into CLAUDE.md rules

It’s going to run 10 parallel agents to extract corrections, then there’s going to be an agent to analyze those corrections, and then there are going to be final sub-agents to reconcile those against the existing CLAUDE.md.
While it’s working, I asked it to produce an HTML report for me to review the corrections.

It came back with the findings. It created for me an HTML file with the recurring corrections and proposed edits to my CLAUDE.md.
We analyzed 49 sessions and had 86 corrections.

A dynamic workflow running live in Claude Code. The three phases on the left run in order: mine, then cluster, then reconcile. In the mine phase, ten agents run in parallel, each Opus 4.8 with its own isolated context window, each working its own slice of the sessions.

Now, you can think of those corrections as not itself valuable in a way, but I believe the value here is the fact that I can see the parts which are constantly repeating.
One of the themes which I’m repeating is about the words Claude fabricates, about AI slop, wrong facts. And here is a proposal for a CLAUDE.md rule.
I don’t think putting those into CLAUDE.md is the best solution. I would package this into skills and make sure the skills reduce those mistakes.

You can go through all of them. And it’s very, very fun to read your actual comments and text back to Claude, what to do or not to do :)

Mine your last month of daily notes for what you keep postponing

You can apply the same pattern to analyze not only your sessions, but also your daily notes in Obsidian.

Here is my ask:

go through my daily notes and extract the insights and patterns which keep repeating

We found we have 31 daily notes. It’s going to run a Haiku sub-agent per note, and then there are going to be Opus sub-agents to synthesize a cluster across all of these notes.
Those Haiku sub-agents are very, very fast. They’re almost finishing it in real time.

Here is my report. It finally came out.
Just wow. It’s actually incredible. I just scrolled through it and it’s eye-opening for me.
What I really love here is that Claude also provides evidence from the actual daily notes, the date and what bullet point it was.
Just mind blown, to be honest :)

The daily-notes report: recurring tension points ranked, each one backed by evidence pulled straight from my daily notes, with the date and the exact bullet point it came from.

Now with that workflow, you can analyze your daily notes at scale in a reliable and predictable format.
Each time, if you want to do this next month, you’re going to have the same workflow and the results are going to be reproducible.

Mine a NotebookLM notebook for ideas you can actually implement

I gave this to a NotebookLM notebook. This notebook contains my daily digest videos.
I asked Claude to first get the transcripts from NotebookLM for those videos, then run a detailed analysis for the ideas which I can implement in my Obsidian vault, and then give me actual prompts to set up each idea.

Claude is on the task, extracting the transcripts. After extraction there is a synthesize sub-agent, then there’s going to be one sub-agent to create a paste-ready prompt for me to implement those ideas, and then the final stage is to render this as an artifact.
I’m very curious what it would come up with. That’s something that I’ve never done before.

We are back, and here’s the result: vault ideas from NotebookLM.
This one is very interesting. I really love it: a skill-audit workflow.

One idea card from the board. A skill-audit workflow: a Haiku sub-agent scores each skill against a rubric, ranks them worst to best, and then an Opus synthesis names the single highest-value fix.

You have a Haiku sub-agent, you have a rubric to score your skills, then rank them worst to best, then propose the fixes. And then you have this final Opus agent to run the score and create the HTML.
This one is something I would actually try.

And here is the prompt. The idea comes with a copy-paste prompt for me to paste into Claude and implement this idea.

Every idea ships with a paste-ready Claude Code prompt. Copy it, paste it into Claude, and the workflow is yours.

Where this goes

I’m starting to realize that it’s actually very, very big.
You can analyze any input. It could be a video, it could be your working sessions, it could be your daily notes, really any input, and get a structured output in the way you want.

Then you make a decision based on this report on what to do next. And you can make it even more actionable, just one prompt away. There is an actual prompt for you to paste into Claude to do this fix and implement this idea.

There are so many scenarios we haven’t looked at.
We touched on classify and act.
We touched on fan out and synthesize. That’s the most common use case across my Obsidian.

You can run a tournament pattern where you have attempts, maybe synthesizing video ideas, and then you have a judge for how good each idea is, you do the scoring, and then there is a final pick for that tournament.

Another scenario is loop until done. I imagine it could be on a schedule. If that’s a daily digest, you can run it on a daily basis, say 7am: go to YouTube, get transcripts, create this report for me.

Another idea is using it for deep verification. Say you have a report or an article, then you have a claim extractor that gets each claim, and then you have a workflow which goes through each claim, analyzes the source, checks the source, do it across every claim, and then you get a final verified report.

A few more patterns to try: classify and act, fan out and synthesize, tournament, loop until done, deep verification. Just a starting point, there are so many.

There’s also a question about how to pair it with skills.
What I found over the last week: I don’t want to have a separate workflow. I keep everything self-contained within the skills.
Say if I have this deep-verify skill, I have a skill.md file, and you can add this workflow inside of it, which is a JavaScript file that encodes this workflow. Within this skill, I can ask Claude to run this workflow to check each claim in its own sub-agent.
That’s what I found works the best. I don’t want to contaminate or blend my skills with the workflow. I just want to work with one entity, which is skills, and then I bring the workflows into the skills.

I believe that’s just a starting point for us to play with this new technology. There are so many use cases, it’s very, very big.

Now that you know how to create and use workflows, I recommend you check out the video about NotebookLM.
I’ll see you in the next one.

Resources

Full video walkthrough - the complete build, live.

Dynamic workflows, from the team that built them - Thariq’s writeup.
https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code

Every Claude Code session starts with 5 to 15 minutes of context establishment.
You manual through old conversations, finding where things left off.
Your most common prompt becomes “hey, what was I working on?”

Close a Claude Code window and the context is lost.
You need to reestablish it.
You do the same work again next time.
Okay, how do I find those two files?
Which files did they create, what decisions were made?
All of that you need to explain every session.
This really wastes so much energy...

You have a bunch of Claude Code sessions and there is no end to them.
No way to capture the state of the work on this project.
The next day you just close everything, it gets too crowded, and you start everything from scratch.

Sound familiar?

I’m going to show you three things: a session file that survives across your Claude Code conversations, an Obsidian dashboard that gives you a live project state instead of stale CLAUDE.md, and a handoff prompt that transfers exactly what matters to your agent.

Full video walkthrough here:

A session file that survives across conversations

One session file in your vault tracks work across multiple Claude Code conversations. Each conversation closes, the session stays.

A Claude Code session is just a single chat conversation.
You have the terminal, and once the context gets filled up - in my case I’ve spent more than 200k tokens in the session - the context window is full but my work is still not over.

A session file lets you keep track of multiple Claude Code conversations.

It’s just a markdown file.
It contains a goal you want to achieve, the background context on this project, definition of done.
The core idea is to capture the progress as we work.

Once the context window fills up, we update our progress status in this note, then we transfer the context to another agent, another Claude Code session, to start fresh.
This way you can capture your work across sessions, multiple days.

I have this project - I’m developing a course right now.
I have those working sessions inside of this dashboard.
It displays what I was working on, and here we are capturing the progress, what I’ve done that session.

Those session files can span multiple Claude Code conversations, multiple days of work.
Each of your Claude Code sessions has its own session file with the ability to track the state of the project you’re working on.

Your CLAUDE.md goes stale - dashboards give you live state

Having a session file for your project is still not enough to capture the complete state of your project.

Rules and preferences stay current in CLAUDE.md. But current tasks, project state, what you’re working on - that goes stale quickly.

This is where we introduce dashboards, which enable dynamic memory.

Those dashboards can contain the project state, work in progress, current tasks, sessions, context, working plans.
This is something that changes all the time based on the current state of the project.

The old way to manage your memory - things which don’t change much, like your working style, who you are, what are your preferences, how do you like to interact with AI, what are your key constraints - that’s CLAUDE.md.

But the dashboard contains overview of the project, sessions, plans, open tasks.
What I really love is they’re using the data from the files which contain a link to this dashboard.
You can aggregate all of the sessions, all of the plans.
You can do it for any type of your projects, for any type of your files.

Open dashboard, resolve embeds, load live state. One note. Always current.

Here is how this works.
I provide this dashboard to Claude Code and tell it to read it.
I tell it, okay, let’s load the state of this project.
It reads the markdown file.
It sees the embedded queries and then resolves them with Datacore.
Now the most important piece - we dynamically resolved those queries.
We have plans, we have all attached session files.
Now the agent can see everything that is happening there.
This way we just loaded our memory dynamically and can continue working where we stopped.

To sum it all up - you have a markdown note, you have embedded views, it could be Bases, it could be Dataview.
All of our sessions, with our tasks, with our plans.
We can ask Claude to resolve those queries, and in the end just get a table, loaded into the Claude Code context.
You can ask it to read the files or not to read the files, it’s your decision.
But the main idea is that we are here aligned with Claude.
Claude sees exactly the same picture as I do.
I can continue working where I left off.
Very, very convenient.
I use it all the time.

I recommend you to audit your CLAUDE.md to see what’s there and updated.
Move out all of your dynamic changes into dashboards, to make sure that you always have up to date memory.

The dumb zone - what happens when context fills up

What happens if you hit your context limit?

Past 200k tokens Claude starts skipping context. The smart zone is where your best work happens.

Imagine that your one million context window is this whole box.
You have loaded your system prompt plus memory instructions, and you keep executing, you keep working with Claude until you hit what I define as the dumb zone - around 200k tokens, that’s my rule.
If you’re doing software engineering, the rule might be a bit more strict.
People say okay it’s around 150k tokens, it’s somewhere in that zone.

Claude starts cutting corners.
Just becomes lazy, becomes forgetful.
Continuing to work beyond that many tokens is just a waste.

The standard way is to do compaction.
There is this compact command that frees up context by summarizing the conversation so far.
This command is great and it solves this issue, but I have a few problems with that command.

One of the problems is I can’t capture learnings right now with that command.
How do I transfer the context to another agent?
I want to write this information in my Obsidian into a session file.
That’s the first piece which I’m missing.

The second piece is that this command is not flexible.
I can’t change the prompt for compaction because it’s a built-in command, I have no control over.
What if I want to start a new session, with a plan, what was done before, and the proposed next steps?

Handoffs - you control the transfer

This is where a handoff prompt comes into play.

You have your Claude Code sessions.
Let’s say you’ve been working with a Claude Code session and you hit 200k tokens.
That’s the rule of thumb for me.
Models have a 1 million token context window.
The hard limit for me is 200k tokens.
What I do from there is I run this handoff command which captures what I’ve done in that session, what are the next steps, and what is the intent for the next session.

Before closing my session I also run a retrospective skill, which I showed in one of the previous videos, to capture the learnings.
In this session I was building the outline for my video, preparing the presentation, and there were a few moments which went wrong.
Claude made 12 corrections.
I’m saying okay, this is banned, this is AI slop.
We are analyzing what is the work which we have redone, and then we are proposing changes to our skills.
Here are the proposed diffs, which I agree with, I tell it let’s apply those diffs.
This is extremely valuable so that next time, whenever I go through this workflow, I don’t have to explain again that something needs to be done in this particular way.

Running a retrospective before closing the session. 12 corrections - “this is AI slop” - each one becomes a permanent skill update.

Now the agent generates a handoff file.
It schedules this auto-continue.
I’m not touching anything right now.
The agent just types in the next prompt and starts a new session.
It tells the other agent - okay, here’s a handoff, follow the instructions, this is continuation from a previous session.
This is what was done, this is the current state, and here are the next steps.

So now we are in a fresh context window.
We started everything clean and we can continue our work this way.

If I want to park this, I would type “handoff park” - then we would update our progress in the session file in Obsidian, and this way we can capture the current state of the project.
Then whenever I want to continue on this project - even if it’s a week later - I can just read it from the session file in Obsidian directly.

I use a terminal called cmux for this.
It’s useful because the agent can actually programmatically interact with this terminal.
It can type to any terminal window which is open.
So I use cmux to restart my work automatically :)

Try it

You don’t need all three pieces at once.
Start with one session file for your most active project.
You’ll feel the difference on your first “continue” - instead of re-explaining, you just work.

Now that you know how to never lose your context, you might also want to build a dashboard for your life.
I’m going to show you how to build one in the next video.

My alignment dashboard - sleep, gym, habits, all in one place. This is the next video.

Artem <3

Resources

Full video walkthrough - I demo all three pieces live.

Join the community on Discord: https://discord.gg/g5Z4Wk2fDk

I’ve been living in Obsidian for the last one and a half years, ever since I switched over from Notion. Back then I was doing daily notes, plans, goals, ideas in Notion. The one thing I really missed when I left: Notion lets you build nice dashboards out of the box. Interactivity, just there.

For the entire one and a half years, I was using Obsidian as a text editor. Just markdown. And I found those files very hard to read. As your notes, your plans, your ideas become more complex, markdown becomes a very restricting format. Hard to engage with 😅.

Then a couple of weeks ago, a new post came out from Anthropic. Thariq (one of their engineers) went viral with an article about why he stopped using markdown entirely. Over the last couple of weeks I’ve been exploring how to integrate HTML into Obsidian. I came up with some great ideas. It actually started working for me, and I was blown away by a few discoveries I made along the way.

I’m applying the exact same philosophy to Obsidian. I’m calling it Markdown 2.0 ;)

And here’s the best part: my Obsidian dashboards are now better than what Notion gave me. Claude built me a custom gym + sleep + alignment dashboard that we both open every morning. I’ll show you below 👇

What you’ll get from this issue

By the end of this, you’ll have three things rendered from notes you already have:

1. A presentation from any outline.

2. A triage board for your ideas.

3. A live dashboard from your frontmatter (like the health dashboard + gym tracker I use every day).

The principle: information density

The core argument for HTML instead of markdown is information density. Rather than just walls of text, you can have tables, illustrations, code snippets, plots, diagrams, all within a single contained file.

What this unlocks

Slides from any outline. I use HTML inside Obsidian to create my slides. This diagram was created based on my outline, which was just a markdown file. If you look under the hood, it’s just a markdown file. My input was just an outline. The point is, this is dynamic HTML code living inside my Obsidian. I can press a button and the rest of the slide appears. I actually constructed the presentation for this week’s video this way, from the outline.

Notes can actually be interactive software. You can build micro-software for you. Drag and drop, kanban-style dashboard. Then you can copy the diff and send it to your agent to do those changes for you. Press a button on a slide and it renders the next point. Everything behind that is just this piece of code. Claude or other AI agents can read and render it at no problem.

Dashboards from your daily notes. The most exciting part for me is the dashboards. I’m pulling the information from my daily notes about my sleep score. I record it every day. My energy in the morning, my energy in the evening, my bedtime. I dive into this more deeply in the next section. You can think of those dashboards as dynamic memory for Claude 👇

The killer use case: dynamic memory for Claude

The dashboard I open every morning is the Command Center. One view where me and Claude start the day.

The first iteration was an HTML file. It looked very beautiful. The problem is it’s outside of Obsidian, so it’s not connected. Those goals were not dynamic. I couldn’t modify anything there.

So I integrated it inside Obsidian using the Dataview plugin (github.com/blacksmithgu/obsidian-dataview). In Dataview settings: enable inline queries, enable JavaScript queries. Those two should be enabled. Then you can embed arbitrary code inside your Obsidian note and it actually executes against your vault.

Now I have my goals on the dashboard, and I can edit those goals, I can edit the start date and end date. If I change my sleep quality from 8 to 2 in my daily note, the plot updates in real time.

These dashboards are actually more flexible than Notion. Here’s the timeline view I built for my focus goals 👇

Plugin: Timeline for Bases by TfTHacker.

To review this every morning, you can just ask Claude to read my dashboard. It reads this command center JS file, sees that it has embedded queries and bases views, and now it’s actually pulling the data from those bases views. This way you can be aligned with Claude. You see the same information, and Claude sees the same information.

I think of this as a dynamic memory 🧠. Goals come and go. Whenever the goals from the past disappear from this view, all your context stays fresh. You don’t need to explain your goals every session. What is your point A, how do you currently live? What is your point B, where do you want to go? Everything is self-contained.

You can get started in just 5 minutes and build your own dashboard.

Tradeoffs

Here are some tradeoffs of HTML versus markdown.

Generation time. Whenever we use Claude or an agent to write HTML to visualize, it’s going to take approximately 2 to 4 times longer. It’s gonna spend more tokens. It’s gonna take longer to generate those outputs. I actually like that ;) You generate this and you actually engage with the output. It’s much easier for me to scroll an HTML file like this one and quickly understand what’s going on. I believe the tradeoff is worth the cost.

Version control. If you’re using Git with your Obsidian to back it up, whenever you have HTML it’s very hard to review, because you have all of those tags. That becomes not really great for a human to review the edits.

Token usage. It’s going to take tokens. But the models have an increased context window. One million context window is affordable at the scale. You can also use sub-agents to generate those diagrams. I typically use one sub-agent per diagram. This way the main context window stays lean and you can work for a longer time.

Fastest way to start

1. Read Thariq’s article. It’s actually quite short and very insightful, very engaging. The article itself is an HTML artifact, so you’ll feel the difference while you’re reading it.

2. Ask your agent to visualize your notes in HTML. Just ask it to create an HTML dashboard and open it for you. Once you have that, you’ll see that your style is not as beautiful as this one, for example. What you can do then, you can just copy a link and tell Claude, I want to apply the same to my dashboard. If you like some style, some design, you can just take a screenshot and let Claude copy it.

3. Plug in Anthropic’s frontend-design skill. It gives Claude a strong taste profile out of the box, instead of generic AI aesthetics.

Watch the videos

• Markdown 2.0: Notes Are Software Now — the principle and three concrete things you can render from notes you already have.

• Build your Claude Code Command Center in Obsidian — the one dashboard me and Claude open every morning. Dynamic memory for your agent.

That’s it for this one. Build a dashboard, open it tomorrow morning, tell me how it feels.

See you in the next one, Artem

I just shipped a video on the three Claude Code skills I won't work without.

With those 3 skills, you're going to make your Claude Code smarter than other people. Going to transform each chat into learning with the /retrospective skill, never lose your work with agent handoffs, and finally, will make it follow complex orchestrated workflows.

🎁 All three are ready to install, just paste the prompt to Claude and go:

https://claude-code-skills-artemzhutov.netlify.app

Full walkthrough (11 min):

https://youtu.be/3xZ9Ke_g1jM

/retrospective: the self-improvement loop

/retrospective is the skill I use all the time. It enables me to compound my work.

An agent spawns a sub-agent which goes and analyzes my current conversation. It marks corrections I've done, what was the work, what are the steps that were improvised. Based on those signals it suggests improvements into my skills and the memory. We are entering this self-improvement loop.

The next time when we run the skill, going to be just one shot.

What I really love about that, that I have a control over what I add to the memory/skills. I'm always in control. The agent is generating a proposed diff. Once approved, going to be executed.

Every time we run the /retrospective skill, everything we do is compounding.

/handoff: before you hit the dumb zone

The /handoff skill is incredibly useful whenever we are hitting our context limit.

There is this concept of a dumb zone. From my practice, approximately above 200K tokens with 1M token models. Claude starts making up some facts, starts cutting corners, becomes very annoying to work with.

The /handoff skill is going to take all of the context of the session, write the learnings to a sessions file, then transfer and introduce a handoff to another agent on how to continue this work. We record the progress, so we can always restart, and we never lose the context about what we did in that session.

What I really love here is that we are not directly jumping into execution. We are proposing the next steps, make sure that we are aligned with an agent.

This way you never lose your work.

/skill-management: the meta-skill

The next skill is a skill manager. Skill manager enables Claude Code to follow complex workflows. The key is to have a skill that enables us to create new skills in a reliable way.

This is the pain I opened with. I have a bunch of skills and I just end up getting lost. There is a skill for LinkedIn, a skill for post creation, a skill for content creation.

This leads to what I call skill rot. Whenever I say, okay, let's create a new post, Claude Code is confused. Should I load a LinkedIn skill? Should I use a post creation skill, a content skill?

I was in the pain of having a lot of skills and not having control over them.

What I do is have just a single SKILL.md, which routes to a different workflow. Whenever I say new video, let's start brainstorm. Whenever we want to do outline, let's load this workflow. Whenever we want to create slides, let's follow this workflow.

This way, I don't have to remember should I use this skill for hook, should I use a skill for slides.

It's just one skill that does my complete video production workflow.

Skills come from your actual usage

The bigger thing I learned the hard way is that skills come from your actual usage.

You know the skill, you actually done the work, you know how the skill behaves. Not designing a skill in a vacuum.

Whenever you do your work in Claude Code, record a video, create a presentation, write a post, if you want to make it a workflow, package it as a skill. The skill that survives is the one you've already run by hand a bunch of times.

Get the system

If Claude is making up facts above 200K tokens. If you have a bunch of skills and you just end up getting lost. If skill rot is real and Claude Code is confused which one to load...

Then it's time to make your Claude Code actually smart.

I run 5 weeks of live workshops in a small group, where you build your own system. Claude Code reads your Obsidian vault, knows your projects, and remembers your decisions :)

Cohort 3 starts today.

📚 https://lab.artemzhutov.com

See you next week,

Artem

It’s been almost a year since I started using Claude Code with Obsidian. Here are my crystallized learnings.

You ask AI to write a draft, do something for you. You read it. The output is generic. You tell it to fix it. Still generic... 1 hour later you end up rewriting it yourself.

Sound familiar?

Why do you even have a second brain if you’re redoing everything?

Three techniques that actually fix this:

• Generic voice. Build your voice profile.

• Wrong information. Every claim has to backtrack to the source.

• Bad plans. USER-COMMENT loop and Grill Me for reviewing AI plans.

Without review, your second brain becomes useless

Bad thinking compounds. On this plot is the quality of information in your obsidian vault. Here is iterations without review.

If we’re just accepting everything that AI writes into our obsidian vault without reviewing first, our second brain becomes the same quality as the average internet. It becomes useless.

We should review what you write in your obsidian vault. Maintain the high quality, unique voice of our notes.

Without you, the agent just produces output. You happily ship it, accept it, and you end up with a slop. The agent trends towards confident mediocrity if you don’t discuss your decisions.

Reviewing AI is really painful. That’s a friction you should experience, to catch all of this bad thinking. Human feeling pain is a feature. It’s not a bug :)

Your moat is training your agent

In the future, everyone will have an agent. Working with an agent is not enough.

Agents are trained on huge, huge amounts of information from Reddit, from internet. That’s a baseline which everybody has. That’s mediocre.

Everyone has access to these agents. Internet is generic. There is no moat. Everyone has it.

Your moat is that you need to train your agents. If you don’t train your agent, if you don’t take care of that, it’s going to be mediocre.

Your unique advantage is having your notes, your thinking. It could be just LLM wiki, or plain obsidian. Feed that to an agent as its context. To have a great, great baseline that produces great outcomes :)

Output depends on the context window

From first principles, the output really depends on the context window. The next token appearing in your chat depends on all of the previous history of conversation.

How do you control the context? Two knobs. One is memory. Your CLAUDE.md, your vault content. The other is skills.

Then the three patterns map onto the three problems:

• Generic voice. Use your exact words. Your voice profile.

• Wrong information. Every claim in the research note is backed up with a citation. Backtrack to the source.

• Bad plans. USER-COMMENT loop: AI produces a draft of the plan, you read it, you provide comments inline, you tell it to update based on your comments, then you lock in the plan. Plus Grill Me: you work together with Claude until you achieve a shared understanding.

The cost of skipping plans = redoing the work

If you don’t slow down, if you start skipping the plans, you go into the loop of redoing the work. Every time. That’s a huge, huge cost.

You tell the agent: I accept everything. Then something is broken. You say fix it. You don’t want to understand. It does it. Fixes it. But you start going in a loop where you don’t understand what’s going on, what’s happening.

You waste so much energy. You’re unsatisfied with the result. You lose control of the agent. You lose motivation. You feel disappointed...

A couple months back, I tried to max out my Claude tokens. Run more agents, ship more. That’s not the way anymore. The way now is plan first, then ship something you understand very, very deep.

Get the system

If you’re tired of redoing everything. If your obsidian vault is going generic. If you’re stuck in the fix, fix, fix loop, losing motivation, feeling disappointed...

Then it’s time to train your agent.

I run 5 weeks of live workshops where you build your own personal operating system with Claude code and obsidian. Your vault becomes the system that helps you do your work and achieve the best results :)

Cohort 3 starts Tuesday. 4 seats remaining (they go fast on the last day). Deadline: Mon May 4 11:59pm ET.

https://lab.artemzhutov.com

See you Tuesday <3

Artem

I wanted an agent I could set and forget. Reliable, with isolated Discord channels for different areas of my life.

As a bonus I didn’t expect, this agent has been learning from me.

This is a Hermes agent. You can run the same setup yourself.

The bonus I didn’t expect

I’ve been running it for the last week. A few things happened I didn’t expect.

It wrote 7 entries into my user profile on its own.

I was working with the agent on some task. On its own, it created the skill at the end of the workflow once I finished. I haven’t seen that anywhere else in any agent. Truly novel.

What happened: I was searching for YouTube videos for sources, going to import them into NotebookLM. Once I finished, Hermes in the background captured the pattern and created a skill for me.

It happened again with my evening review. Here is the receipt:

I didn’t even have to tell it anything to do that. We create skills on our own. Here the agent just does the job for us.

How the learning works

Here is the key feature. The agent has a self-improvement loop.

Three triggers, running in the background:

1. After 10 user turns, a memory review agent updates my USER.md.

2. After 15 tool iterations, a skill review agent updates my skills.

3. When a session has been untouched for a couple of days, at 4 AM Hermes runs a final pass and learns from it.

I dug into the source code. The exact file is the prompt the agent uses for each pass.

Inside one cycle the loop looks like this. I chat with Hermes. Back and forth. After 10 turns, a separate agent (you can think of it as a learning Hermes) gets the transcript. It reads the chat. Asks itself: anything about Artem worth remembering? It writes to USER.md, MEMORY.md, or skills. If there is nothing worth saving, it stops. The main chat never sees the learning Hermes. I just keep going.

That is a key innovation. I haven’t seen that anywhere.

One persona per Discord channel

If you use Discord, there is also a config file where you can set up skills per channel.

If I want to do a coding task, I do it in a build channel. If I want to do content, I do it in a content channel. I specifically limit the set of skills per channel. Very handy to limit the scope and the focus.

There is also a great addition: you can set the personality of the agent.

For my vault channel (where I interact with my Obsidian), I prompt the agent with a persona. Where my daily notes go. Always use wikilinks. Here is my vault structure.

I think of it as a CLAUDE.md for my Discord channel. I define the scope of what is happening there to help the agent.

Very flexible. You can create a multi-agent setup. Discord channels, one for each area of your life.

Where Hermes fits, and where Claude Code fits

From my phone, in Discord, I can ask: give me a list of my home feed videos.

I can be anywhere. Just on my phone, through Discord. I can run all of the skills I developed the last year. Just one command. In real time, I get my home feed videos.

I can ask anything about those videos. Put them into NotebookLM. Run them through my familiar workflows. That’s a huge unlock.

Capture on the go. Braindump. Research. Things I can run reliably while I work on something else.

When I want to do real work (pair with an agent, review the plans, be very strict to avoid AI slop), I switch to Claude Code with my Obsidian side by side. Just a new tab. Claude Code, my Obsidian vault. Really be a human in the loop.

Hermes is my capture inbox and the start of fuel into my world.

Try it

Watch the full walkthrough: Hermes Agent + Obsidian on YouTube

Install it yourself: the Hermes Agent quickstart

Really exciting times to start using it.

Cohort 3 of the Claude Code x Obsidian Lab starts May 5.

We integrate AI agents with our context in Obsidian to build a personal operating system. Five weeks of live sessions.

This cohort I have capacity for 10 people. Early bird price now, before it goes up next week.

lab.artemzhutov.com

I wanted to know if he is right. ⌕ My goal is to improve my decision making. I really love Ray Dalio. I have his book called Principles. So I took the same sources, the same goal, then built the wiki and my system side by side in real time.

Dalio’s 5-step process. Diagram via https://www.principles.com/

Here’s what happened.

Karpathy’s wiki architecture

Karpathy’s wiki has three parts:

1. Your raw sources: YouTube transcripts, articles, PDFs.

2. The wiki itself: Claude reads each source, writes a summary, and pulls out people and concepts into pages.

3. A schema file that tells Claude how the wiki is organized, so it knows where to look when you ask a question.

With those index files and entity pages, you can query the wiki easily and navigate it on a graph.

Karpathy’s wiki architecture from the gist.

Where the wiki breaks

I ingested 19 sources into the wiki in parallel. It took me about 20 minutes. Then I asked 10 questions against it.

Claude was reading all the transcripts. The index was not helpful. Claude was reading the full files to answer one question. 44,000 tokens per question. Multiply by 10 for 10 questions.

My limits were blowing up the roof. The ingesting cost is just blowing.

Compare this to NotebookLM. I added 50 sources because ingestion was instant. NotebookLM ingestion is just embedding. They use state-of-the-art embedding models, like the ones Google has. You’re not doing this ingestion step in any way. You’re right away ready to ask questions. You don’t build this entire wiki index.

Same 10 questions. Approximately a minute per reply. All 10 answers with citations back to the transcripts.

So what?

We have all this knowledge and then so what? You created a wiki, you have the summaries, you have this index. What’s happening next? Did you do that?

We have all this knowledge and then so what?

The wiki has no integration with the real world. You can ask a question about it, but that’s it.

Here is what I do instead

My goal is to improve my decision making. I ask questions about it. I extract the concepts. Then I improve my skills.

Here is what I do instead.

Three steps:

1. ⚡ Create skills out of this knowledge.

2. ↻ Integrate those skills into your daily routines.

3. ▸ Run those new skills within the routines.

A great example is a morning routine, where you integrate the decision-making framework into how you distribute your time.

I built a decision-making skill based on Dalio’s 5-step process:

1. ◎ Know your goals.

2. ⚠ Don’t tolerate problems.

3. ⌕ Diagnose the root causes.

4. ◈ Design a plan.

5. ▸ Execute the plan.

I added a daily template with reflection prompts, and a weekly review section that asks: “Are the problems repeated this week? Are they the same type of problems we had from last week?”

From Dalio videos to my system.

Whenever I need to make a decision, the skill is right there. I apply this knowledge instead of just storing it.

More notebooks

I’ve done more testing and created more notebooks. Here are some I’ve collected.

A few of my recent notebooks.

One example: I pulled the last 2 weeks of videos about Hermes Agent, OpenClaw, and Claude Code channels into one notebook. 21 sources. I asked many questions and got great answers grounded in the YouTube videos and what people are actually using.

This is what it really excels at. I can be in the know without being biased to a single video from YouTube. Watching one video gives me one person’s opinion. Pulling 21 videos into a notebook gets me up to speed and decreases that feeling of missing out. It helped me not lose my mind.

Here is an example of a question I asked: “Why did Anthropic ban subscriptions?” The answers were great, grounded across the videos.

The notebook answering my question across 21 video sources.

If I’d gone the wiki route, Claude would have to go read all the transcripts every time I ask a question. It’s just too long. You can’t wait for that. By outsourcing the synthesis work to NotebookLM, you spend a fraction of the tokens.

And the era of free tokens has ended. I can feel it. In January, Anthropic’s tokens were unlimited, it was extremely hard to hit the weekly limit. Right now it’s tightening. The LLM wiki approach is very costly and very slow.

Where wiki really shines

I believe wiki really shines where you need to go very, very deep. PhD-level research. Something that’s going to sustain you long term. You need high accuracy. You can afford 30 minutes to ingest one source.

Team wikis, I believe, would be a great use case. Competitive analysis is definitely a better fit. Claude can go read all those files and provide a better response, because it has access to the sources.

For personal knowledge, where I want to learn about a topic, I feel it’s a bit overkill. I’m not going to spend an hour to set up a wiki for each topic. I can only spend so much talking for a day. Right now tokens are subsidized, you don’t pay for them as much. If you try to use it through API, you’re definitely not going to be using LLM wiki. Just no way.

NotebookLM, you’re not doing maintenance, you’re not doing processing. Sources stay raw. You ask a question and you get the answer.

Side by side.

Try it

Open NotebookLM. Ask Claude to find the videos and articles for your topic. It will add them to the notebook. Then ask your questions and get the answers back.

I built a NotebookLM skill that does this in one command: notebooklm-skill-artemzhutov.netlify.app

One more thing

Claude Code x Obsidian Lab Cohort 3 starts May 5.

Five weeks building a personal operating system like the one in this newsletter. We turn sources into skills, then integrate those skills into your daily routines so they help you do your work.

We just wrapping up Cohort 2. You are getting the combined learning from 40 people who built their personal operating system in the first two cohorts.

Last cohort F. came in as an ADHD non-programmer and shipped 400 commits in his first week. He told me the tools supplemented his weaknesses and he got years of work done in a week. Kind of mind-blowing.

Cohort 3 is capped at 12 seats.

lab.artemzhutov.com

If you try NotebookLM after reading this, drop me a message with your thoughts.

See you next week.

You open a bunch of tabs. You find videos, articles, podcasts. The context is scattered. At some point you just kill those tabs. And you kill your intention to act on any of it.

I built a system that closes the loop. Feed expert content into NotebookLM. Connect Claude Code to it. Set a goal. Get a protocol with experiments based on your answers. Wake up earlier, go to the gym, track if it actually works. The best way to learn is by doing something. An experiment is a specific change you try for a few weeks and track if it works.

Goal to research to experiments to morning routine. The loop that turns expert knowledge into daily action.

Here’s the full walkthrough where I set this up from scratch.

Turn 300 episodes into a knowledge base

My goal: improve my focus, have more energy, go to the gym, be fit. The research part is handled by NotebookLM. You load sources and start asking questions.

The challenge is getting those sources in. You can’t just go into NotebookLM and tell it to add a YouTube channel. Imagine yourself going to each YouTube video, getting a link, uploading it manually. Such a big pain.

Claude Code does it. I connected it to my notebook. I created a skill, which you can also download from the description. It listed all 53 of my notebooks.

I created a new notebook about Andrew Huberman, filtered by health topics. 400 videos on the channel. Claude helped me pick which ones are health related. Then it uploaded them.

You have all of the access to this knowledge and you don’t have to watch the podcast. You can save so much time if you want to learn about a new topic.

This is where everything stops

You can ask questions in NotebookLM. Where do I start with health? You get a quality answer with citations. You can click through and trace the exact citation back to the video.

This is already cool. 300 episodes of the world’s top neuroscientist, and you can ask any question with cited answers back to the exact episode.

But this is where everything stops at the learning stage. You can ask questions, but they are missing the steps where we actually plan to do those experiments. You want to wake up earlier, go to the gym, act on what you learned. You need to schedule this into a calendar. You need to review what is the effect on your health. Are you achieving your goals?

These parts are completely missing. You can ask questions, but then so what? How do you act on that? You can’t set a reminder from NotebookLM. You can’t design an experiment. You can’t track whether you followed through.

You learn something. You never act on it.

Claude Code bridges the gap

NotebookLM holds the research. Claude Code schedules focus blocks, creates experiments, reviews results. One context.

This is where Claude Code comes in. I think of Claude Code as something that can help me actually act on this knowledge. It helps me manage my calendar, schedule my focus blocks, track whether I’m achieving my goals or not.

Claude Code queries the notebook with my goal. It gets cited answers from Huberman’s research. Based on those, it designs interview questions across several areas: supplements, exercise, sleep optimization. Each question traces back to the source.

Your goal + 300 episodes go into Claude Code. It generates interview questions cited to specific episodes. You answer. You get a personal protocol.

I told it: my goal is to improve my health, I want you to ask questions based on Andrew Huberman’s episodes. It ran six queries in parallel, saved the responses into my Obsidian vault. 7 out of 8 citations were very strong matches. The citations are accurate and grounded.

Then I answered the interview questions. Claude looked up my existing fitness experiments, grabbed my data. It built a health profile: current state, target state, gap assessment. Where is high, medium, or low.

Health profile: current state, Huberman target, gap assessment.

The proposed top 3 highest leverage experiments: sleep regularity (the biggest gap), morning sunlight, and adding zone 2 cardio.

From protocol to action

The experiments land in my Obsidian vault as notes. Each one has a status and a frequency. My morning routine skill reads the Experiments base through Obsidian CLI, filters by status active, and surfaces them in my daily note.

Claude reads the Experiments base via Obsidian CLI, filters by active status. Five experiments show up every morning.

The only way I don’t forget about this is because Claude asks me about each one: how is this experiment going? Any observations here? Based on the observations, it schedules the next actions.

And it works. After a gym day, energy is consistently higher. The mood is also higher. The sleep quality is higher.

Rest day: energy 6.1, mood 6.4, sleep 5.8. Gym day: 6.8, 7.1, 6.5.

The dashboard becomes a place where you see and control an area of your life. Goals, experiments, action items, research. Everything at a glance. I wrote about how this health dashboard works in a previous post.

Protocol becomes calendar events, experiments in your morning routine, and a health dashboard to track it all.

Any expert, any domain

My vision for NotebookLM: external knowledge across experts, across domains. If you’re into product management, there is Lenny’s Podcast. I loaded 200 episodes. You can chat with them in the same way.

If you want to learn about something else, you can together with Claude search for YouTube channels. It filters the videos which are relevant to your goal. NotebookLM serves as a source of verifiable truth. Claude Code can read any notebook and help you close the loop.

We move on from learning to actually acting and reviewing our results. The highest leverage right now is absorb any expert knowledge and act on it the same day.

That’s the best way to learn, by doing something.

NotebookLM stores the domain knowledge of an expert. Claude Code reads it and helps you design experiments, track them in your morning routine, schedule them in your calendar, and keep track of how you feel.

Resources

NotebookLM skill - set up the NotebookLM skill in the next ten minutes. Load 300 podcasts of your favorite creator and ask questions.
notebooklm-skill-artemzhutov.netlify.app

Full walkthrough (18 min) - I load 300 Huberman episodes, run a cited interview, turn it into experiments.
Watch on YouTube

Claude Code x Obsidian Lab - You come in with your own goal. You leave with a system that does things for you. One member with zero programming experience wrote 100,000+ lines of code with autonomous task loops. Another built a /daily command that manages his entire family life. 5 weeks. 10 live sessions. Cohort 3 starts April 28.
lab.artemzhutov.com

Artem

You wrote a CLAUDE.md. You thought that was the answer. But it gets huge. Claude starts forgetting rules at the top. Your preferences evolve faster than you can update the file.

Left: what most people do. Right: what’s actually available.

Claude Code now has three memory systems. Most people only know about the first one. The other two run in the background. You don’t even notice they’re there.

I reverse-engineered the dream prompt from Claude Code’s source code. In this post I break down each layer, share the exact prompt, and give you a retrospective skill that turns every conversation into a learning loop.

Full video walkthrough (22 min): It Dreams, It Remembers, It Works For You

The CLAUDE.md Problem

This is where most people start. Your CLAUDE.md. Who you are, how you work, your rules, your preferences. I’m doing the same thing. My CLAUDE.md has hard rules, file organization, how to use Obsidian CLI, writing voice, all of that.

And it’s hard to manage. You add rules, you forget to remove old ones. Last time I touched CLAUDE.md was probably 2 weeks ago. Your work is evolving and CLAUDE.md can’t keep up with all of that.

Auto-Memory: Claude Writes Its Own Memories Now

The solution is auto-memory. Instead of maintaining this giant file called CLAUDE.md, Claude now has a single index file, MEMORY.md. Just the index of memories, different sections.

Each memory is its own file. Has a name, a description, and a type. Four types: user (who you are), feedback (corrections and confirmations), project (ongoing work), reference (pointers to external systems).

The key difference between auto-memory and CLAUDE.md: CLAUDE.md is managed by you. You write preferences there. Auto-memory is something Claude manages in the background.

Those preferences are automatically loaded in the next session. I can ask Claude about memories it has about me. It knows my patterns. Time autonomy, Pomodoro blocks, all of that.

Designed in a way that you don’t even notice that it’s happening and it’s remembering those preferences.

And you have full control. These files are hidden by default in ~/.claude/, but here’s what I do: I symlink them into my Obsidian vault and view them in Obsidian Bases. Each individual memory file shows up as a row. You can open any one and see exactly what Claude remembers and why.

You correct Claude once. It writes a memory file. Next session, that preference is automatically loaded.

How to enable: Open Claude Code, run /memory, turn on auto-memory in settings. That’s it.

But Memories Go Stale Too

There is still a problem. The way you work changes. Your preferences are always evolving. What was true a month ago might not be true now.

Claude keeps collecting memories, but it doesn’t know which ones are still relevant. The index file grows. That becomes again a problem.

Who cleans up?

Auto-Dream: The Hidden Feature Nobody Documented

The solution to stale memories is auto-dream. A new Claude Code feature shipped last week. Still in research preview.

It’s a hidden feature. There is no documentation about it.

What I did is I asked Claude Code to read its modified source code and reconstruct the prompt. It performs a dream, a reflective pass on the memory files, like a human would do.

Every 24 hours, this prompt runs in the background. It gathers your sessions, reads the current memory files and the index. The goal is to consolidate existing memories and prune the ones which are no longer relevant.

Auto-dream runs every 24 hours. Reads your sessions, consolidates memories, prunes stale ones.

The Dream Prompt: 4 Phases

Here is the exact prompt I reconstructed from Claude Code’s source code. Full prompt with all constants.

Phase 1: Orient. Check what’s allowed to exist. Read the index file. Understand where we are right now.

Phase 2: Gather signal. Daily logs, memories that already drifted. The most important part: transcript search. You have access to your conversations stored locally on your computer. Full trace of interaction. Based on that trace, gather what became stale, what needs updating, what are the new preferences.

Phase 3: Consolidate. We have new information. Merge it into existing memories, delete contradicting facts, convert relative dates to absolute.

Phase 4: Prune and index. Update the index file. Make sure it’s under 200 lines.

How to enable: In /memory settings, turn on auto-dream. It runs in the background. You enable it and it just works.

What Claude Actually Sees When You Start a Session

You can see the system prompt of Claude Code and how all of it works together. When you start a new Claude Code session, Claude gets: CLAUDE.md first. After that, memory. The index of all your memories, with a limit of 200 lines max.

It references those individual memory files. The memory files are not in the system prompt. This keeps your context window efficient.

CLAUDE.md loads first, then MEMORY.md index, then individual memories are loaded on demand. You can see all of it.

Work Produces Memory: The Self-Improving Loop

The way to think about memory is that work produces memory. A conversation with Claude Code. You do some work, write a post, ship a video, finish a piece of work.

I have a skill called retrospective. It runs sub-agents to analyze my conversation with Claude, propose updates to the skills, propose new memories, and update the memory index.

Similar to auto-dream, but on a scale of one conversation, when I’m working. I get full observability and full control of what’s going to be written to my memory.

The steps: first, extracting signals. Corrections I made. Things that were redone. Things that worked on first try. Then Claude proposes the findings as a table. I can review, approve, reject.

The more you use the system, the better it gets. Every piece of work, with every chat.

Run retrospective after any piece of work. Sub-agents analyze the conversation, propose skill updates and new memories.

You do your work. At the end of the session you run this retrospective skill. Next time when you have to record a video or do the same type of work, it’s just going to be smooth. One shot.

The full loop: work produces signal, retrospective captures it, skills and memories improve, next session is better.

Dynamic Memory: Dashboards Per Area of Your Life

Memory alone doesn’t capture the way humans operate in the real world. The real world is too complex. You have decisions to make, stuff to track. You need to keep track of progress across different areas of your life.

The way I imagine my life as different areas. I have content to post, videos to record, goals to achieve, taxes to file, plans to work on.

For each area, I create a dashboard. Here is my health dashboard. Goals, active sessions, action items, progress. All in one view.

I can read those dashboards using Obsidian CLI. I can tell Claude to read this dashboard by resolving all the queries. Now it’s running all these queries and the results match exactly what we have in our dashboard.

Now we are on the same page with Claude about my health goals, my next action items. It is much more efficient than “Claude, let’s just find all of my notes about something.”

I do this for each part of my life. Not only health. Every project, every area.

My health dashboard in Obsidian. Goals, active sessions, action items, progress. All in one view.

From here, I have a clear overview of this area of my life. I have sessions, I have action items, and I can resume sessions easily. This brings clarity to me. It keeps me sane.

How It All Fits Together

So what does the full stack look like?

1. CLAUDE.md. Your persona, your rules, preferences. Stuff that doesn’t change frequently.
2. Skills. Structured processes, playbooks. The essence of doing some action, captured as documentation. I have 150 skills accumulated over the last months of working with Claude Code.
3. Dashboards. Area context. What you’re working on in each area of your life.
4. Auto-memory + auto-dream. Dynamic preferences that Claude manages and consolidates.

Any new agent reads all four layers and just works.

CLAUDE.md + skills + dashboards + memory. Any new agent reads all four and just works.

It Gets Better the Longer You Use It

If you start using it now, you might have just a very lean CLAUDE.md. No memories, no skills. The more you use it, you work together with Claude. You do your first corrections to memory. You see how you prefer to work and you teach Claude your preferences. Then after some time, it just works.

Month one: thin. A few memories. Month six: knows your patterns, decisions, what worked. Not just facts. Understanding.

Start Today

That data is your asset. That’s your competitive advantage. You’re just training your agents by doing your standard work. Every session makes it better and better.

Just start. The memory accumulates.

Two things you can use right now:

1. Retrospective skill. Run sub-agents on your own conversations to extract learnings. Copy-paste a prompt, that’s it.
2. Memory observability setup. See exactly what Claude knows about you, right in Obsidian. Full control.

https://memory-evolved-artemzhutov.netlify.app

How to get started with the basics:

1. Open Claude Code. Write a CLAUDE.md with who you are and how you work.
2. Run /memory. Turn on auto-memory and auto-dream.
3. Just use it. Correct Claude when it gets something wrong. The memory builds itself.

Everything in this post, the memory structure, the skills, the dashboards, that’s what people build in the Claude Code x Obsidian Lab. In 5 weeks you walk out with a working system. 20 people across 9 countries built theirs last cohort. None of them were software developers. Cohort 3 starts April 28.

Artem

I run Claude Code from my Obsidian vault every day. All of my context is there. My preferences in CLAUDE.md. My memory files that persist across sessions. Skills I packaged from previous work. Notes going back years. The one thing which was missing is reach it from my phone. And now I can.

I ran OpenClaw for that before. It worked, but I was always SSHing into my Mac Mini to fix it. It was very hard to manage. I spent more time maintaining OpenClaw than actually using it from my phone. And the subscription was kind of a gray area with terms of service. Now with channels it’s officially supported. Full transparency.

What Channels Actually Is

Channels plugs your phone into an existing Claude Code session. You start Claude Code with a channels plugin. Your phone pushes messages into Claude Code. Claude processes them with full filesystem access, tools, skills. Reply goes back.

No new setup. No rebuilding context somewhere else. Whatever you already built in your vault, channels gives you phone access to all of it.

Layer 1: Your Obsidian vault. Your context, your life. Layer 2: Claude Code. The executor. Layer 3: Channels. Talk from your phone.

What I Ran From My Phone

I opened Discord on my phone. Asked: “generate a diagram to understand how the channels work.”

The agent received the message. It reads my project files, understands what I’m working on, generates a diagram using the excalidraw skill. The image appears in Discord. That’s the thing. You can attach images, diagrams, PDFs back to Discord messages.

Then: “create a PDF file with my slides and attach it to my Discord.”

The agent generates the PDF. Attaches it to the message.

I also asked it to analyze Reddit sentiment in the Claude Code subreddit. The agent extracted all the Reddit posts. Read them. Crunched the data for four minutes. You need to be patient with those agents to teach them the way you want results to be produced. But the results came back with exact Reddit threads with analysis and quotes. Real threads you can click and go to.

With just your vault and CLAUDE.md, you can ask it to search your notes, summarize a file, answer questions about your day. All from your phone.

OpenClaw vs Claude Code

I ran OpenClaw. Here’s the honest difference.

OpenClaw is more mature in terms of platform support. 23+ platforms. WhatsApp, Signal, all of those different channels. It also has built-in heartbeats. Proactive agents that check stuff and report back on a schedule.

What I typically do is I do some work and then I package something as a skill, which I understand, which I can open in my Obsidian, I can look through it, I can tune it. Brings to me much more observability. I can open any file, note, I can see exactly what’s happening in the skill, what’s written there. It gives me the sense of control that I can read those files, I can see what the agent would be doing.

Here’s the thing about observability: running Claude Code with Obsidian helps me understand what the agent does. I can see exactly the files. Running OpenClaw without Obsidian, or Claude Code without Obsidian, makes it very hard to understand what the agent is doing. A lot of people run OpenClaw without Obsidian. With Obsidian, you see every edit, every file the agent touched.

When the agent is working through channels, it’s a bit harder to observe. OpenClaw has built-in streaming to tools. For Claude Code channels, you can ask the agent to send messages to Telegram or Discord to update about progress. One limitation: you can’t really stop the agent mid-task. You can only guide it by sending another message.

OpenClaw: 23+ platforms, bring your own model. Claude Code: Telegram and Discord, flat $200/mo subscription, state-of-the-art models.

The pricing: the amount of usage which you are getting out of the $200 subscription is heavily subsidized. You burn in tokens like a couple grand easily. With OpenClaw, you bring your own model. You can use OpenAI models or open models, but their vibes are just not great for a personal assistant. Anthropic models like Opus follow instructions better, more natural conversation. That’s kind of the problem with bringing your own API key.

The most important thing is having your context. Your preferences, your skills, your playbooks. Without that, the agent is generic. It can’t be personal by definition. You run a session, and at the end you’ve done some work. Now you want to package it as a skill. That’s going to be your playbook which you can run whenever you want. And because everything runs locally, you have access to your whole conversation history, every session, every decision, every correction. This makes the agent better and better over time.

The memory architecture is different too. OpenClaw has a layered system. SOUL.md as your personality and principles. MEMORY.md for curated long-term facts. Daily journal logs. A facts database with entity lookups. Semantic search across sessions with embeddings. It’s sophisticated.

Claude Code has CLAUDE.md plus auto-memory that writes and updates memory files on its own across sessions. Simpler, but it works because you control the files directly. You can open them, read them, edit them in Obsidian.

Both can run from your Obsidian vault. That’s the key. Running either one from your vault is what enables real personalization.

For heartbeats, we can get something very similar within Claude Code by using the built-in /loop skill. You can tell it the interval. Hours or minutes. And then you can tell the prompt, or you can tell it to run some specific skill.

Try this one. Copy-paste into Claude Code:

/loop 2h "Check in with me. Ask how I'm doing, what I'm stuck on, what's on my mind. Be supportive and curious, not pushy."

That’s the therapist style interaction. Every 2 hours, it asks about your state. Or every 24 hours at 7 AM, scan of my latest notes, extract ideas from previous day, send me morning brief using Telegram or Discord.

Loop pattern: scheduled intervals, agent task, reply to channel.

Discord is the Future

I think Discord is the future for our agents.

I’ve seen a person from Twitter who was doing something like that with his OpenClaw setup, which was quite impressive to be honest. A general chat, a pulse channel where you get reports from Reddit, logs, different channels for different agents. Channel-based scope for agents with their own context.

Someone’s OpenClaw Discord setup. Per-channel agents with isolated context. This is what inspired me.

I want to set up something similar. The default Discord channels plugin gives you one agent, one session. No context isolation between channels. But I’ve been testing an upgraded Discord plugin that filters messages per channel, so each channel routes to its own Claude Code session.

The Experiment I’m Running

On my own Discord server right now. One bot token, upgraded plugin, multiple agents each filtered to their own channel. Research, therapy, daily review, source monitor, orchestrator.

Each agent gets its own persona file. You write who they are, how they should behave, what tools they focus on. Then you spawn them and they just live in their channel, waiting for messages.

5 agents, 5 Discord channels, 1 Obsidian vault. Pick a channel, talk to that agent.

The Orchestrator

It’s the Discord server as a control center for your agents. You open Discord on your phone, pick a channel, talk to that specific agent. All of them running from the same vault, same skills, same context.

The orchestrator agent is the one that sees everything. I can ask it about any other Claude Code session. “What is the weekly plan agent doing right now?” It reads what’s happening in that session and reports back. It can spawn new agents, check on running ones, relay messages between them. I covered the cmux orchestrator pattern in a previous video.

Why This Beats the Old Way

What makes it stick for me is that I can create those agents just in time, whenever I need them. It automatically creates a Discord channel for the agent and you can just spawn it. Previously with Telegram and multi-bot OpenClaw setups with isolated context, it was a huge pain. I had to get access to each bot, create a bot in Telegram, then try to make it run, then SSH from Claude Code to Mac Mini to fix it. I spent one hour doing that and it still doesn’t work and I’m afraid to touch it.

Now it’s much easier. You can have those assistant agents. You just run them. And you can also get back to the terminal as well to see what’s happening.

I actually tested this while writing this newsletter. The default Discord integration gives you one channel, one agent. That’s what Anthropic ships as the official plugin. What I tested is the multi-channel setup. The orchestrator agent in its own channel, receiving my messages from the gym, pulling the YouTube transcript, drafting the newsletter, going through multiple rounds of edits. All remotely, while I was not in front of the computer. Then I came back and continued working in the same Claude Code session.

Try It

Telegram setup (2 minutes):

1. claude plugin install telegram@claude-plugins-official

2. Create a bot with BotFather, copy the token

3. claude -> /telegram:configure <token>

4. claude --channels plugin:telegram@claude-plugins-official

Discord setup:

1. claude plugin install discord@claude-plugins-official

2. Create application at Discord Developer Portal, enable Message Content Intent, copy bot token

3. claude -> /discord:configure <token>

4. Generate OAuth2 URL with bot permissions, invite to server

5. claude --channels plugin:discord@claude-plugins-official

Full setup walkthrough in the video: watch from 7:00
Official docs: Claude Code Channels

For dictation on the go I use Wispr Flow. Much better than default Android dictation.

What’s Next

Two weeks ago we had /loop. Last week /dispatch. Now we have channels. I think that’s kind of the full piece to build your own OpenClaw with Claude Code.

And here’s what closes the whole loop: I sync my vault between my MacBook and my Android phone through Obsidian Sync. Claude Code makes edits in Obsidian. Those changes appear on my phone almost instantly. I can review what the agent did right from my phone. Command from phone, agent works, edits show up in your vault on your phone.

It’s really exciting times to be alive, honestly.

Full video walkthrough (22 min): Claude Code Channels Replaced My OpenClaw Setup

Let’s Discuss

If you had 5 Discord channels with 5 different agents, what would you put in them? Reply to this email. I’m genuinely curious.

Join the conversation: Discord community

Artem

But it wasn’t always this way.

I opened Claude Code and started working.
Then I needed another agent to do another task.
I opened a new tab.
Then another, and another.
Quickly I had 10 tabs.

Claude, M1, M2, M3, M4, M5. Which one was doing what?

I didn’t know what was happening on this tab, switching between all of them just kills my flow.
Sessions go stale and the context gets lost.

I had this exact problem.

Tabs vs named workspaces

cmux: Isolated Workspaces, Not Tabs

The tool that changed this for me is cmux - a terminal workspace manager.

Named workspaces with emojis. Orchestrator, feature-research, video-script, daily-review - each one isolated.

It’s not a new tab.
It’s an isolated workspace.

Each workspace has a terminal, the ability to spawn other terminals inside of it, and hot keys to jump between them.

But the real power - cmux is programmable.
Claude Code can programmatically access the contents of any workspace.

cmux list-workspaces

The orchestrator sees all workspace names, not “tab 4.”

It reads the screen of any workspace:

cmux read-screen --workspace workspace:1

No interrupting the agent.
Just seeing what it’s doing.

And it can talk to any workspace:

cmux send --workspace workspace:1 "what was our progress today"

The agent in that workspace starts working on the task.
The orchestrator sleeps for 15 seconds, waits for the response, reads the screen.
You see the response from that agent.

This way Claude enables communication between agents across different workspaces.

Three commands: list, read, send. That’s it.

The Orchestrator: One Agent Manages the Rest

Agent Control - what are my agents doing right now

One Claude Code agent becomes the orchestrator - it spawns and controls the others.

I have one main orchestrator workspace.
Then I have a cmux skill that shows how to use cmux programmatically.

Say I just want to spawn a workspace to review my daily progress.
It creates a workspace named “daily review” with this prompt: read today’s daily note, give me a summary of what’s inside.

Now a Claude Code agent starts working on that task.
You see the pattern - you can have isolated workspaces for each of your tasks.

I talk to one agent.
That agent manages the rest.

The Dashboard: How Not to Go Crazy

Real Obsidian Bases dashboard - sessions grouped by status: blocked, done, in-progress, review

But now the problem is - how do you keep track of all these sessions?

You use Obsidian and Obsidian Bases.

Every workspace has a session file in Obsidian.
The dashboard generates itself.

Each session has a related field that links to its dashboard.
The Obsidian Base queries all linked sessions automatically - status, date, title, related workspace.

You create a session, link it to the dashboard, it shows up.
No manual tracking.

When you spawn a workspace, the agent creates its own session file and links it to the dashboard.
The Base does the rest.

Nothing is “done” until you verify it.
You read the dashboard, check the output, add comments.
The orchestrator picks up your comments and relays them to the right agent.

Each session has a goal.
You have a progress field.
You have the outcome.
Here’s also the definition of done.

Sessions grouped by status - the dashboard queries them automatically

The Full Loop

Daily note -> sessions -> spawn workspaces -> verify output -> comment -> orchestrator relays

Here’s how it all connects.

You have a daily note which you use to plan your day.
The orchestrator reads this plan and understands your intent for today.
Then you create sessions from there.
The orchestrator spawns workspaces for you to do the work.

You look at the progress.
You provide comments to the agent.
When the agent reads the file, it sees your comment.

You can verify what’s happening.
You can comment on the work.
That’s the whole workflow.

Where Are You on the AI Ladder?

Most people using AI are somewhere on this spectrum:

• Level 1: You don’t use AI

• Level 2: You use AI via chat (ChatGPT, Claude, Gemini)

• Level 3: You customized it with your context (Claude Projects, custom GPTs)

• Level 4: You work through an AI IDE (Cursor, Windsurf)

• Level 5: You solve work tasks using agents in the terminal (Claude Code, Codex)

• Level 6: You launched a personal AI agent

• Level 7: You’re building multi-agent infrastructure (orchestration, cmux)

What you just read is Level 7.
Most people are at 2-4.

In the Claude Code x Obsidian Lab (starts March 17) we take you from wherever you are to Level 5-6.
Some of you will touch 7.

How to structure your vault so agents can read it.
How to spawn and orchestrate workspaces.
How to use Obsidian Bases to track your work without manual updates.
You build it with me over six weeks. lab.artemzhutov.com

From Tabs to Workspaces

Before, I had this ghostly terminal with cursor chaos.
This concept of tabs was not really working.
I was feeling overwhelmed since summer.

And now we have cmux, which is much, much better.
It has these workspaces.
I added this concept of sessions and dashboards to it.
More scalable and more controllable, integrated with Obsidian.

Get the cmux skill + orchestrator setup:

https://cmux-artemzhutov.netlify.app

Watch the full demo:

Claude Code x Obsidian Lab starts March 17 - build your own agent systems from scratch, with live feedback.

https://lab.artemzhutov.com

Artem

Typically what happens, I start working on something and then two hours later I don’t know what’s happening and how I ended here in the current situation. I plan my day in my daily note, but nobody checks if I’m following through.

I set up three agents in my Obsidian vault with intervals when they’re going to fire. One is my accountability check - every 30 minutes it asks me if I’m on track on my goals. Another one is an executive coach. And the final one is a source monitor.

All 3 automation files ready to use - drop them in your vault, one command to schedule: link

In this post I walk through all three automations, how I set them up, what they actually produce, and what doesn’t work yet.

Here’s the full walkthrough (26 min) where I set up each one from scratch: link

How /loop Works

To set this up, we use this /loop command in Claude Code. By the way, this is also available on the desktop version.

/loop 30m "Read my day plan for today, my daily note, and check with me if I am on track. If I don't have anything in my daily plan, ask me what is the goal."

That’s it. Copy-paste this into Claude Code and you have your first automation running. This is the simplest one to start with - try it.

The agent can also notify you. I have a script in my automation file that sends a macOS notification when the agent needs my attention:

osascript -e 'display notification "Off track - check your day plan" with title "[auto] accountability"'

Claude uses this skill called loop. I didn’t create this skill. It comes with Claude Code. It schedules a cron job - basically a script which is going to run inside of this session with all of the context which we have here. Every 30 minutes it fires and reads my day plan and checks if I’m on track.

But this is not a cron job running a script. A script runs a command. A scheduled task runs a full agent. With all its tools. And that’s where it gets interesting.

You type /loop, the scheduler fires on interval, and a full agent runs with your CLAUDE.md, skills, tools, and entire vault.

Every time the scheduled prompt fires, the agent gets your full context. Your CLAUDE.md with all your rules. Your skills. Your tools. Your entire vault. It’s not running in isolation. It’s running as you. With everything it knows about you.

This agent has access to all of our skills, to all of our MCP tools and connections, to all of our context within Obsidian. It can reason. It can understand. It can debug and adapt at the next run.

That’s why the accountability check actually works - it can read my day plan, compare it to what I’m doing, and give me a real answer.

Accountability Check

This one is the one that helps me stay on track. Every 30 minutes, it fires this automation to see if I’m on track with what I plan to do throughout my day.

It reminds me that you have a limited time in your life and every 30 minutes matters. It asks a hard question - isn’t that the thing that matters the most right now? Or how many 30-minute blocks do you have left today?

This is especially useful if you sit and think for 15 minutes at the start of your day what you want to accomplish and then you fire this agent and tell it let’s go, let’s stay on track.

I was recording this video and it was firing those jobs at 12:00 p.m. I was not answering because I was busy. When I checked, it told me: “you’re reading the accountability automation file instead of recording.” It was prompting me to record. I’m recording. Go chill.

Executive Coach: Memento Mori on a Timer

I use this Dan Koe framework for six interrupts throughout my day. This executive coach basically runs every three hours. It tries to ask me these questions to interrupt the patterns which I live throughout my life. And those questions are really really hard.

- 11:00 - What am I avoiding right now?
- 13:30 - If someone filmed the last 2 hours, what would they conclude?
- 15:15 - Am I moving toward the life I hate or the life I want?
- 17:00 - What’s the most important thing I’m pretending isn’t important?
- 19:30 - What did I do today out of identity protection?
- 21:00 - When did I feel most alive today? Most dead?

Those questions are really refreshing if you’re throughout your day and you’re just into the task and you try to think - is this really what matters the most right now? I think this executive coach is something which enables this broad perspective on what’s going on.

Shoutout to Dan Koe’s article for the framework.

Want to try it yourself? Here’s a prompt you can copy-paste:

/loop 3h "Pick one question from this list and ask me. Rotate - don't repeat the same one twice in a row: 1) What am I avoiding right now? 2) If someone filmed the last 2 hours, what would they conclude? 3) Am I moving toward the life I hate or the life I want? 4) What's the most important thing I'm pretending isn't important? 5) What did I do today out of identity protection? 6) When did I feel most alive today? Most dead?"

Source Monitor: Reddit + YouTube

I have this automation called source monitor. It tells Claude to check my sources for the relevant content about Claude Code, agents, Obsidian. Scan those Reddits using the Reddit read skill. And then also check my YouTube home feed. Do that for each source, extract the most interesting items, and notify me once we are done.

On the first iteration, I didn’t like that it actually didn’t read the comments and understand what’s happening there. The YouTube videos had no links, no summary. So we went about doing another iteration within the same session.

On iteration two, Claude read all of the comments and extracted what the community thinks about that. Now I can go there and click and engage with the material which matters to me. I don’t have to scroll Reddit or YouTube on my own. My agents just go ahead and extract what only matters to me and what would be interesting for me.

Imagine that Claude went and searched for recent videos about Claude Code - it got the transcript and gave me a summary of what matters, with takeaways from the actual source. You can make your own daily digest without going to those different websites. Just huge unlock.

And that was a prompt which we did with Claude. That’s it. I told it: use my Reddit skill and use my YouTube skill to accomplish this.

Self-Improving Agents

Here is the concept of this self-healing agent. Let’s say we have some automations like the daily digest where we parsed resources from YouTube, from Reddit. We run it and then we didn’t like something or there was some error. We provide feedback. Our agent reads the logs of what went wrong. Based on this feedback and those logs, the agent goes and edits the code or our skill files and the next run produces a better result.

Run, review, edit code, better result. You don’t design the perfect agent from day one - it continuously evolves.

This way you have this continuous loop where you don’t actually try to design a perfect automation, a perfect agent from one go. It’s continuously evolving and you tune it in how you want the agent to behave. You have this complete flexibility in terms of what the agents are capable of, and that makes this very flexible and just exciting.

Here’s what that looks like in practice - my source monitor going from version 1 to version 2:

Left: Iteration 1 - basic list of links with no context. Right: Iteration 2 - deep analysis with comment extraction, transcript summaries, and community sentiment.

Managing Agents: cmux + Remote Control

I have this terminal with a bunch of tabs and workspaces. If I try to work on something else, I create a new workspace. It’s been very helpful to keep those workspaces organized. The terminal I’m using is called cmux. If you connect Claude Code to cmux - if you tell Claude how to use this terminal - it can do some quite good stuff for you. Like having an orchestrator agent that manages other Claude Code sessions. I have an auto-check workspace with all my automations running there - the orchestrator can spawn new sessions, send commands, read what’s happening in any workspace.

Each workspace is a separate Claude Code session. You can programmatically create workspaces, manage tabs within them, and send keys to any terminal - all from another agent or a script.

We can also control those automations from our phone or from a desktop app. I can see all of my sessions appearing right there. The key is to turn on remote control in the settings. Each session which is spawned inside the terminal becomes available for remote control and you can connect to it through your Claude phone/desktop app.

And regarding notifications - I think it’s very useful to add some observability. When do I need to check up on my agent? You don’t check on agents. They check in with you.

Limitations

Those automations only work within a session. Within Claude Code, if the session is alive it’s going to work. Those sessions have a three-day expiry date. They auto-expire, and to avoid this I also set up an automation - a task renewer every two days to renew automations. So they get automatically rescheduled avoiding this three-day limit.

Also the machine must be awake. If your machine is not running then it’s not going to run. And there might be some issues with the token cost. If you’re going to have a lot of tasks, it might not be that manageable to have all of them running. So here we need to be mindful.

If you want to make a Claude Code session persistent, you can run it inside of tmux (a terminal multiplexer), or you can set up those sessions on a Mac Mini which is always on and then it runs those automations for you.

What People Are Building

I just wrapped up Demo Day for the first cohort of the Claude Code x Obsidian Lab. 20 people, 6 weeks. Everybody has a completely different system. The amount of creativity surprised me.

One consultant went from never using Obsidian to 1,000 files in a month. He recorded two days shadowing a logistics company with Granola, synthesized everything in his vault, and then Claude reconstructed the entire business workflow as a Miro diagram. That’s a forward deployed engineer - going on-site, capturing everything, and having an agent map out what people are actually doing and where the pain points are.

And one person built a simple markdown system with a /daily command - no Obsidian, just Cursor and Claude Code. He said: “I don’t want to try to remember anything in my life. I just want this thing to do everything.” He’s gotten so much done in just the last week that it’s pretty crazy.

The transformations mattered more than the tools. People who had never opened a terminal were building agent workflows. People who thought Obsidian was too complex found their own way in. The range was the whole point - from the simplest markdown system to a full Rails platform capturing screen activity, WhatsApp, LinkedIn, email, and phone calls.

I also organized offline Claude Code meetups where people presented what they built to 80+ people. If you want to organize your local meetups, shoot me a message :)

Presenting Obsidian x Claude Code at a local Claude Code meetup

Let’s Discuss

What would you schedule? What do you check manually every day that an agent could do for you?

Join our Discord community: Discord

Resources

All 3 automation files - source monitor, accountability check, executive coach. Drop into your vault, one command to schedule – Link

Full walkthrough (26 min) - I set up each automation from scratch.

Claude Code x Obsidian Lab - Cohort 2 starts March 17. We start from scratch: setting up Obsidian, setting up Claude Code, getting everyone up to speed. Then we go beyond. You build your own skills, your own workflows, your own agent. Live, with real feedback from the group.

Artem

One week of my work, visualized. Every node is a session, every connection is a file it touched.

I just open a new terminal and then what’s going on. I need to somehow find all this context. What was the project, what are the decisions. I need to start from zero all the time.

It gets worse mid-session. When we hit context limit at 60%, we need to compact or hand off. Then half of the decisions have been lost. Or even worse if I want to continue next day, I don’t remember what was happening back then.

Zoomed in: every purple node is a conversation, every colored square is a file it created or modified. Skills, recipes, content drafts - all connected together.

The current paradigm of grepping over files doesn’t scale. So I plugged QMD into my vault, a search engine by Tobias Lutke, CEO of Shopify. Made in Canada.

The whole memory system I’m about to show you - it’s a skill. Install it in 2 minutes and Claude Code already knows how to use it.

QMD: A Local Search Engine for Your Vault

QMD is a local search engine for your knowledge base. It indexes your Obsidian vault and finds anything in under a second.

For each vault folder I have a QMD collection. Notes, daily entries, sessions, transcripts. One-to-one mapping. For each collection I can perform a focused search.

qmd collection list
qmd search "video workflow" -c notes -n 3

That’s it. One command, your vault is searchable.

But searchable how? The default way Claude Code searches is brute force - it sends a Haiku sub-agent to grep through every file. I tried it (watch): searched for my notes about different graph approaches the normal way. It took 3 minutes. I was bored, scrolling Twitter while waiting. And the results? 300 files, not great.

QMD search was instant. Better results. Way fewer tokens. You don’t have to use sub-agents to do that. The difference: grep matches strings, QMD ranks by relevance.

Grep vs BM25 vs Semantic (watch)

QMD gives you three search modes. BM25 (qmd search) is deterministic full-text search. Like grep, it matches exact keywords. Unlike grep, it scores each file: how often does the word appear, and how rare is it across all your documents? A short note mentioning “sleep” five times scores higher than a 10,000-word file where “sleep” appears once. No AI, no embeddings - just math. Semantic (qmd vsearch) uses embeddings to find meaning - you can search for a concept even if the exact words aren’t there. Hybrid (qmd query) combines both.

I searched for “sleep” across my vault. Here’s the difference.

Benchmark: grep returns 200 files of noise in all directions. BM25 finds relevant sleep experiments in 2 seconds. Semantic finds meaning even without exact keywords.

Grep found 200 files. All over the place. It finds all the files which contain the word “sleep.” It even finds sleep() - a programming command that pauses code execution. Nothing to do with actual sleep. That’s the problem with string matching.

BM25 (2 seconds): a reflection about sleep quality. Experiment with tracking sleep fragmentation patterns. Sleep interrupted at 3am. Much better.

But qmd search "insomnia" returns zero results. The word doesn’t exist in the vault.

Semantic search: I type qmd vsearch "couldn't sleep, bad night" and it found a bedtime discipline goal I set years ago. It goes beyond the keywords and explores the meaning. Four of five results don’t contain the search words at all. Grep could never find them.

Hybrid (qmd query "couldn't sleep, bad night"): ranks sleep quality improvement at 89%, sleep interrupted at 3am at 51%, health sleep optimization at 42%. The best ranking of all.

The progression: grep catches strings, BM25 catches relevance, semantic catches meaning.

Start with BM25. Fast and handles structured notes. 80% of searches. Add semantic for transcripts and braindumps, where you’d never search for those exact words.

What Semantic Search Actually Surfaces (watch)

I searched my daily notes: “find the days when I was happy and what was the reason.”

This is a non-trivial query. Claude adapted it and ran multiple searches:

qmd vsearch "happy, grateful, excited" -c daily -n 5
qmd vsearch "energy, great day, feeling good" -c daily -n 5
qmd vsearch "satisfaction, accomplishment" -c daily -n 5

Found semantically relevant connections across months of daily notes.

The pattern: my happiest days are when I ship something and I had good sleep recovery, like sauna or 9 hours of sleep.

Then it surfaced something I had completely forgotten. Back in October when I was writing my PhD thesis and I was about to give up. I needed to do it day by day, come in and write something. But what I realized back then is that I just need to see it through discomfort instead of escaping to quick fixes.

I didn’t remember writing that. I didn’t expect the search could surface this. But there it was, the exact citation.

/recall - Load Context Before You Start (watch)

/recall is a Claude Code skill that sits on top of QMD. It loads context before you start working - instead of explaining to Claude what you were doing, you tell it to recall.

It has three modes: temporal (scan your session history by date), topic (BM25 search across your QMD collections), and graph (interactive visualization of sessions and files).

Three modes: temporal (yesterday, last week), topic (BM25 across collections), graph (visual exploration).

/recall yesterday
/recall topic graph
/recall graph last week

Yesterday reconstructed 39 sessions from one day. Timeline, number of messages in each session, what was done when.

39 sessions from one day. Each row shows the time, message count, and what I was working on. I can go back to any of them.

Topic searched for “QMD video” across sessions and notes. Returned the dashboard, production plan, to-do list. All related files surfaced in less than a minute. Compare that to the brute force approach: tell Claude “find all information about this project” and it sends Haiku to grep through your vault for 3 minutes, burns tokens, and comes back with worse results. With /recall topic, I reconstructed the full state of the project and asked: what is the next highest leverage action?

Graph opened an interactive visualization of my whole week. Sessions as colored blobs, older ones dimmer, recent ones highlighted in purple. Files clustered by type: goals, research, voice, docs, content, skills.

Here’s an example: I was exploring lunch places. I told Claude “I want to have a great lunch” and we analyzed different places to go. I stored those as activities I might want to try. A week later, I open the graph, see that session, copy those file paths into Claude Code and continue from there. The graph makes every past conversation recoverable.

Activity graph for my week. Sessions branch into files. I can trace any conversation back to what it produced.

Session graph controls: filter by time range, color-coded by file type. Older sessions fade to a dimmer purple, recent ones glow bright. Hover to highlight connections, click to select.

700 Sessions, All Searchable (watch)

Claude Code saves all your conversations as JSONL files on your computer. I had 700 sessions in the last 3 weeks. Each one has decisions, questions, context I’ll need again.

The raw files have tool uses, system prompts, roles. We parse a clear markdown, the actual signal, the actual user messages, and embed this into the QMD index.

At the end of each session when I close my terminal, I have a hook which exports and embeds those sessions into QMD. So the index is always fresh. I can get back to anything I had even from today.

Session closes, hook fires, QMD index updates. Always fresh, no manual steps.

Finding Ideas You Never Acted On (watch)

This is the one that surprised me. I searched: “find the ideas that I have never acted on.”

Having Claude synthesize the raw QMD results is very useful - it’s hard to parse the actual raw results yourself. Claude summarized what it found:

• October 19th - I wanted to build a PhD writing dashboard but never did it

• I had ideas for illustration-based apps but never followed through

• I had an idea to record a screen recording about my full Obsidian workflow but never committed

Claude’s synthesis of the hybrid search results. Dates, ideas, things I wrote months ago and completely forgot about.

And it’s all local - all of these embeddings live on your computer.

Tools Change. Your Context Stays.

Your notes stop being passive. They stop being trapped in your Obsidian world. They actually start doing things. All of your notes is useful context about yourself that you can use to achieve goals in your life.

Tools change. A month from now there are going to be new models. So what. If you have your context you can make it work in any situation. Claude Code, Codex, Gemini CLI, anything.

The memory layer works as a skill across your whole stack. I use Obsidian Sync to keep my vault in sync between my Mac and a Mac Mini that’s always on. On the Mac Mini, OpenClaw runs 24/7. So I pick up my phone, open OpenClaw, and I have the same vault, same QMD index, same skills - from anywhere.

The full stack: Obsidian vault at the bottom, QMD search in the middle, Claude Code and OpenClaw at the top. Context flows up.

Try It Today

Download the /recall skill, drop it in your .claude/skills/ folder, and you have the session pipeline and recall working today (or ask Claude to do it for you :) ).

If you want the full system, I’m running Claude Code x Obsidian Lab - 6 weeks, hands-on. We start from scratch: setting up Obsidian, setting up Claude Code, getting everyone up to speed. Then we go beyond what I showed here. You build your own skills, your own workflows, your own agent that actually knows your context. Bi-weekly workshops and masterminds where you get real feedback from the group. Everyone has similar problems - information overload, Claude creating a mess, spending more time tuning Obsidian than doing real work. Cohort 2 starts March 17.

Let’s Discuss

What’s your biggest pain with Claude Code memory? Do you re-explain context every session?

Join our Discord community: https://discord.gg/g5Z4Wk2fDk

Resources

QMD - the search engine behind all of this. By Tobias Lutke.
https://github.com/tobi/qmd

Claude memory system - /recall - Download and try today.

Claude Code x Obsidian Lab - 6 weeks of hands-on practice building AI workflows that use your notes. Cohort 2 starts March 17. Early bird pricing ends this week.

Watch the full video - 42 min walkthrough with live demos.

Artem

NotebookLM reads 300 sources. But then what? You copy-paste answers into your notes and lose the citations. The research stays in a browser window you’ll never reopen.

So I built a Claude Code skill that pulls everything out. Three terminal commands - search YouTube, add 20 videos as sources, ask questions. Every answer comes back with citations pointing to exactly which video said what.

Then it all lands in Obsidian as a knowledge graph. Each source becomes a file. Each topic becomes a file. Citations create links between them. I open “Claude Code” as a topic and see which 6 videos mentioned it, what they said, and follow the links to

I tried connecting NotebookLM to my research months ago and gave up. Too slow. Adding sources manually in the browser, one by one, clicking through the UI. NotebookLM supports up to 300 sources - that’s the number that makes it different from just asking Claude - but who’s going to drag 300 files into a browser window?

Now it’s different. I built a Claude Code skill that does everything from terminal. 20 YouTube videos become a knowledge graph I can walk through. Watch the full walkthrough (33 min)

Before: 20 browser tabs, copy-paste, lost sources. After: one terminal command.

NotebookLM is Google’s research tool. You give it sources - YouTube videos, PDFs, web articles, your own notes - and it reads all of them. When you ask a question, it gives you a cited answer pointing to exactly which source said what. No hallucination, because it only uses what you gave it.

The key difference from the browser workflow: I have much more granular control over the sources. Instead of NotebookLM’s built-in suggestions that recommend whatever it thinks is relevant, I pick exactly what goes in. I can search YouTube from terminal, see the results, and choose which videos to add. This way you increase the signal-to-noise ratio.

Searching YouTube from terminal with ytcli - I pick the exact videos that become research sources

You can set a custom persona per notebook - tell NotebookLM to respond concise and direct, or in whatever style fits your research.

The Research Workflow

I wanted to research what other people are building with Claude Code and Obsidian. Instead of watching 20 YouTube videos at 2x speed and forgetting what video 2 said by video 6, I ran three commands:

1. Search YouTube for relevant videos

2. Create a NotebookLM notebook and add all 20 as sources

3. Ask questions and get cited answers

notebooklm ask --new --json "What are the gaps in these videos?"

One terminal. No browser tabs. Claude Code orchestrated the whole thing. Watch: Live demo from terminal

The citations are what make this useful. When NotebookLM says “three creators mentioned using Obsidian Bases for context management,” it points you to exactly which video, which timestamp. I tested the citation accuracy: about 60% were strong matches to exact passages, 31% partial matches, 10-15% weak. Not perfect, but way better than my memory after watching 20 videos. Watch: Citation accuracy audit

Under the hood, every answer comes back as structured JSON - each claim has a marker like [1] or [2] that traces to a specific source and passage:

How citations work: each claim traces back to the exact source and passage

In practice, this means you can click through to the original video and timestamp:

Citation markers in practice - answers point to exact sources with passage-level deep links

Every answer is grounded - you can trace claims back to the source. Good enough to trust as a research starting point, not good enough to cite in a paper without checking.

Here’s what a cited answer looks like when it lands in Obsidian - the exact passage from the source, with a link back to the ground truth:

A cited answer in Obsidian - exact passage from the source, linked back to the ground truth

The Knowledge Graph

Everything comes back to Obsidian. Not as a flat dump, but as a linked knowledge graph.

Each source becomes a file. Each topic becomes a file. Citations create wikilinks between them. So when I open “Claude Code” as a topic in my vault, I can see which 6 videos mentioned it, what they said, and follow the links to the exact passages. Watch: Graph view and connections

Research that used to disappear into browser tabs now lives in the vault, connected to everything else. And because it’s all on your computer as markdown files - you own it. Claude can read it, you can search it, it’s not trapped in the NotebookLM browser window.

Claude Code creates a research dashboard in Obsidian. Sources with YouTube thumbnails, topics that act as hubs on the graph, and citation backlinks showing exactly where each video is referenced in your Q&A answers. All in one view.

Sources base in Obsidian - every video with thumbnail, topics, and citation backlinks

Citations become wikilinks. When you open a Q&A answer, every claim links back to the source passage it came from:

Citations become wikilinks - each Q&A answer traces back to its source passages

Open the graph view and you can see the whole network - sources, topics, and citations all connected:

Graph view in Obsidian - sources, topics, and citations all connected

Here’s the full pipeline from input to output:

The full loop: notes go in, a knowledge graph comes back

Everything in this video was built live in the Claude Code x Obsidian Lab - this was Week 5: Workflows and External Automations. 6 weeks, one workflow per week, from zero to a working system.

Here’s what Lab participants are building:

• L., engineer - autonomous CRM agent with LinkedIn crawling and a secured DMZ for prompt injection protection

• A., content creator - /create-presentation skill that turns Obsidian plans into slides automatically

• M., developer - per-project CLAUDE.md architecture with /handoff and /resume for project continuity

• S., lecturer - task notes synced to dual calendar (Google + Outlook) with Whisper phone transcription

Audio Overviews

The knowledge graph is one output. Audio is another. NotebookLM can generate a podcast-style audio overview of all your sources - two AI hosts discussing your research, citing your material. Same sources, different format. Watch: Audio overviews

I typed one command, it generated the audio, it landed in my vault, synced to my phone via Obsidian Sync.

notebooklm audio generate --topic "gaps in Claude Code + Obsidian workflows"

Audio overview: two AI hosts discuss your research, citing your sources

The podcast lands in your vault and syncs to your phone through Obsidian Sync. I was walking and listening to a summary of 20 videos - my own research, as a podcast, on my phone.

Obsidian Mobile playing the audio overview - flashcards, audio, all synced from desktop

I don’t know if this is the future of research or just a fun trick. But I use it. When I have a notebook with 15 sources and I want the gist before diving in, I generate audio and listen while I do other things.

What Else It Can Do

The video covers the full loop in 33 minutes, but the skill does more than YouTube research.

I uploaded 282 of my own daily notes to a single notebook. All of them, in 2 minutes from terminal. Now I can chat with my past self - “give me a weekly summary for Feb 10-16, what went well, what didn’t” - and get cited answers pointing to specific days. Sleep maintenance wins, fitness consistency, late-night sabotage patterns - all pulled from my own journal entries with citations back to the exact daily note.

Chatting with 282 daily notes from the last year - weekly summary with cited answers from my own journal

That’s the vault-as-source angle: your own writing becomes queryable.

Other things I tried:

• Flashcards - NotebookLM generates study cards from any source set. I got 58 flashcards from 20 videos, imported them into Obsidian. “What is the primary goal of project memory?” - flip - answer with citation.

• Slides - Generate presentation slides from your research. Same cited sources, different output format.

• Academic research - Search arXiv for papers on your topic, feed them into NotebookLM, get grounded citations. Full observability over what’s going on - responses are not made up.

• Podcast research - Lex Fridman episodes, 4 hours each. Feed a bunch of these in, ask specific questions across all episodes.

• Company onboarding - Put your company docs into NotebookLM. New hires ask questions from terminal instead of bothering the team.

• Market research - Feed competitors’ blog posts, YouTube videos. Get cited analysis.

Try It

The skill is free and open source. Setup takes about 15 minutes - you need Claude Code, an Obsidian vault, and a Google account.

After that, three commands get you from “I want to research X” to a knowledge graph in your vault with cited answers, audio overviews, and flashcards.

https://github.com/ArtemXTech/personal-os-skills/tree/main/skills/notebooklm

The Python scripts that power it:
https://github.com/ArtemXTech/personal-os-skills/tree/main/skills/notebooklm/scripts

Let’s Discuss

What’s your research workflow? How do you handle sources that are too big for one context window?

Join our Discord community: https://discord.gg/g5Z4Wk2fDk

Resources

Skills repo - Browse the skills I mentioned
https://github.com/ArtemXTech/personal-os-skills

Claude Code x Obsidian Lab - 6-week program where we build workflows like this from scratch every week. Everything in this video was built live in the Lab.
https://lab.artemzhutov.com

I run a free workshop tomorrow - Zero to Obsidian CLI Pro in 90 minutes. Claude Code + Obsidian CLI, you build the system live. 76 people registered.
lu.ma/m5fnplqq

Artem

I made a full walkthrough where I tested every command: watch here. This newsletter covers what changed, why it matters, and what you can try right now.

What is Obsidian CLI

Obsidian 1.12 shipped a command-line interface. 101 commands. You can now programmatically do actions in your Obsidian from the terminal.

But you won’t be typing these commands. Claude Code will. Or OpenClaw. Or any other coding agent. The CLI is the bridge between AI agents and your vault.

Kepano’s announcement - install, enable, let agents in

Why CLI, Not MCP

Previously we had a bunch of MCP servers, local REST API plugins, Obsidian URI. A whole mess of infrastructure just to programmatically talk to Obsidian. Now one official CLI that unifies everything.

Before CLI: a mess of plugins, APIs, and workarounds

Kepano said it best:

“CLI adds things that no plugin API could do”

CLI is faster, has direct access to your local files, no authentication needed, more context-efficient, and you can pipe commands together. If I were to short MCP, I would do that in favor of CLI.

The Commands That Actually Matter

101 commands sounds like a lot. Most you’ll never touch. Here’s what changes your workflow:

8 command categories that matter out of 101

The game changers are base queries and eval. Base queries let you talk to hundreds of files through frontmatter only. What Obsidian sees is exactly what your agent sees. You’re on the same page. You control exactly what goes in and what comes out, and it’s context-efficient - no wasted tokens on full file reads.

Eval lets you call any plugin programmatically from terminal. Debug any plugin. One-shot anything.

Here’s what that looks like. I have a Bookmarks.base file that tracks everything I save - articles, tweets, videos. It has views: All Bookmarks, Unread, Processed, By Source. The base file itself is just YAML that defines filters and columns.

To get my unread bookmarks, one command:

obsidian base:query path="Templates/Bases/Bookmarks.base" view="Unread" format=md

Output:

| Title                                          | Date       | Source   | Author          |
| ---------------------------------------------- | ---------- | -------- | --------------- |
| On agentic coding, sense of urgency...         | 2026-02-12 | article  | walterra        |
| Something Big Is Happening                     | 2026-02-12 | article  | Matt Shumer     |
| Obsidian CLI Documentation                     | 2026-02-11 | article  | Obsidian        |
| The AI Vampire - Steve Yegge                   | 2026-02-11 | Medium   | Steve Yegge     |
| Distribution is the Only Moat Left             | 2026-02-10 | Twitter  | SIGKITTEN       |
| ...26 total                                    |            |          |                 |

26 bookmarks, structured, no file reads. My agent sees the same table I see in Obsidian, so from here it can summarize what I saved this week, find articles by topic, or mark them as read with property:set. The whole workflow is the same for anything - sessions, tasks, contacts, content drafts. One file with frontmatter, it auto-appears in the right base view, and any agent can query it.

Reading 100 files to check their status costs about 150,000 input tokens - $2.25 per query on Opus 4.6 pricing. One base:query returning the same data costs about 5,000 tokens - 7.5 cents. 30x cheaper. Every token of context you waste on file reads is a token you cannot use for actual reasoning.

If you want to set this up on your vault, I’m running a free workshop where we go from zero to CLI pro in 90 minutes.

Phone to Vault in One Command

I use OpenClaw (Telegram bot) that uses this CLI under the hood. Send a voice note from my phone, bot runs daily:prepend, it appears in my daily note. My phone, my terminal, my agents - all write to the same place.

Voice note from Telegram, transcribed and added to daily note via CLI

It’s a unified inbox for everything. It works with images too - I take a picture of my food, the agent analyzes calories and adds it to my daily note with the image embedded. I can send any link and ask Claude to research it. Voice notes, photos, links - it replaces so many apps. Just one inbox that works with audio, video, links. Unsubscribe from your voice note app.

And it works through your messenger, so Apple, Android, web - doesn’t matter. Telegram, Discord, WhatsApp, anything.

History: How Your Notes Evolved Over Time

Every file in Obsidian has saved versions. The CLI gives you programmatic access to all of them.

I used two commands to reconstruct how the slides for my video evolved across 44 versions over 15 hours:

obsidian history path="slides.md"
obsidian history:read path="slides.md" version=44

44 versions of my video slides reconstructed by an agent - from skeleton to final cut

The slides went from a 13-slide skeleton to “here’s what you build with them” across 15 hours. An agent compared key versions and built the full timeline automatically.

44 versions, zero git. Any agent can do this reconstruction on any note in your vault.

Vault Health

I ran obsidian deadends on my vault and found thousands of files with no outgoing links. obsidian orphans showed thousands more that nobody links to. obsidian unresolved found links pointing to files that don’t exist.

The point is not just finding them. You can pipe this into Claude Code and say “group these by folder, figure out which ones are from the same rename, and fix them with obsidian move.” In my case, most of the broken links in References/ were from files that got renamed. One move command fixes hundreds of those at once.

Broken links by folder - References and Notes had the most unresolved connections

Honestly, I am still exploring what to do with all this data. The numbers are impressive but figuring out which orphans matter and which are fine takes work. The commands exist, the data is there, and I am still building the workflow around it.

How to Actually Start

Prerequisites:

1. Obsidian Catalyst license ($25)

2. Install Obsidian 1.12

3. Enable CLI in settings

Full docs: https://help.obsidian.md/cli

My recommendation: don’t create skills yet. Put it into your CLAUDE.md memory. Let patterns emerge.

Over time, you’ll see how you use it. If Claude Code is reading full files just to change a property, teach it: “use obsidian property:set instead.” If it’s using mv to move files, teach it: “use obsidian move to preserve backlinks.”

Here’s what that looks like in practice. This is from my actual CLAUDE.md:

Vault mutations via CLI (when Obsidian is running):
- Daily note updates -> obsidian prepend path="YYYY-MM-DD.md" content="..."
- Frontmatter -> obsidian property:set path="file.md" name="status" value="done" type=text
- Tasks -> obsidian task path="file.md" line=N done
- Move/rename -> obsidian move path="old.md" to="new.md" (auto-updates backlinks)
- Read single property -> obsidian property:read path="file.md" name="status" (context efficient)

You go through the initial pain once.

If you want to set all of this up on your vault, I’m running a free workshop where we go from zero to CLI pro in 90 minutes.

Zero to Obsidian CLI Pro in 90 minutes - free workshop

Let’s Discuss

What command excites you most? Have you tried the CLI yet?

Join our Discord community: https://discord.gg/g5Z4Wk2fDk

More about what I do:

https://artemzhutov.com/

Artem

The moment I saw how Obsidian Bases work, how easy it is to filter your notes and build different views, I thought: what if we connect the agent to Obsidian Bases? That seemed like a huge unlock. I was frustrated by not having reproducible workflows.

The video is about how to stop explaining context to AI every time you start a conversation. How to create sessions files for your projects. How to build dashboards that let you load project-specific context in a context efficient way.

When we combine Claude Code and Obsidian, we get a system with high autonomy and unified context. That’s what makes it powerful.

ChatGPT has some autonomy but the context is scattered. You need to copy-paste from ChatGPT.

The solution is to put all your stuff in one place, one folder. Claude Code can search through your projects, your notes - that works up to a point.

The real solution is to structure your data using frontmatter and use Obsidian Bases to display it. Then make Claude read those Obsidian Bases so you can have workflows: “What are your active projects?” “What are your clients?”

It becomes a dashboard with all the context you need.

You can use dashboards for anything: learning something, job application tracker, client management. Knowledge workers, people working with clients, managing different workflows.

The Dashboard Pattern

The unlock is you can see exactly what data gets loaded into Claude Code. It reads the Obsidian files the same way you see them in Obsidian from Bases. That’s huge. You get reliable data loading rather than relying on Claude Code search, which is not efficient.

You can build a dashboard for any type of information as long as you can put it into an Obsidian Base. And you can put literally anything into a Base: bookmarks, clients, blog posts, content, working sessions with Claude. All of that has a dashboard.

19 dashboards - each one is a context I can load

Here’s my Working dashboard. It tracks active sessions with Claude Code and sessions in backlog.

What I put there is accumulated context. When I go for a 30-minute walk, I record myself, my ideas. I’m not focused on one topic, just jumping around. Then I transcribe it and have a braindump skill that distributes my ideas across dashboards. Sessions in the backlog get more context filled in. New sessions emerge with all context prepared for the agent, ready to work.

Working dashboard - In Progress, Blocked, Needs Review, Backlog

Here’s what a session in backlog looks like:

Session file - goal, context, code snippets, questions to explore

Switching Context

In terminal I just say “switch to [project]”. Claude reads the dashboard, queries linked sessions and tasks, shows me the full picture.

Here’s how context persists across days. Day 1: you build - create dashboard, add tasks, work on your project, close session. Context saved to dashboard. Day 2: you open a fresh Claude session, say “load context for Workshop”, Claude reads the dashboard, full context loaded. You pick up exactly where you left off.

Fresh session. Full context.

The pattern:

1. Dashboard has embedded Obsidian Bases views

2. Claude reads the dashboard, sees the embedded views

3. Claude queries the Bases, presents the context

4. I know exactly where I left off

The dashboard is self-documenting. Claude can read what you see.

This pattern is both agent and human-friendly. You can see exactly what goes into Claude’s context. It’s not full files, just a table view. Claude sees the embedding of the Obsidian Base, knows how to query it, and gets the same frontmatter you see. Tables are in JSON format.

It’s context-efficient because you only feed the table view, not the full files. Scalable. And the beauty is Claude reads my previous sessions working with this project. It knows exactly where I left off.

This Works for Anything

The concept is general. You have notes, you want to query them, organize them, see what’s relevant. Build a dashboard.

Resources - articles, bookmarks, references. Show untagged items, by category, by status.

Meetings - meeting notes, transcripts. Show by person, by project, what needs follow-up.

Content - ideas, drafts, posts. Show by stage: idea, draft, ready, published.

Clients - leads, conversations, next actions. Show who needs attention.

Whatever you track, you can build a dashboard for it.

This is what we’re exploring in the Claude Code + Obsidian Lab starting this week - hardware engineers, software developers, business owners learning to integrate AI with their workflows.

The most important mindset shift: engineer actions around your notes. Not just where to put an idea, but what happens to it later. For example, I have an idea and I want to understand how it goes into my newsletter so I don’t write a newsletter from scratch. The ideas are already there.

Previously notes were just sitting there for years, doing nothing. Passive store of information. Now we embrace a new mindset where notes are context for agents and they help us do our work better.

Personal Tools = High Leverage

You can reverse engineer any software now. Just ask Claude to explore the folders.

Example: Granola saves transcripts locally in a cache on your computer. I asked Claude “how does Granola work?” and we explored the folders together. Within 10 minutes we wrote a Python script to sync those transcripts to Obsidian. I captured it into a skill: https://github.com/ArtemXTech/personal-os-skills/tree/main/skills/granola

For Substack, the pain was you write content in Obsidian, then you need to transfer it to your blog, then to Substack. Substack requires specific formatting. The annoying part is getting the formatting right, avoiding doing the work twice. I just want stuff in my clipboard. Solved it now: the agent creates an HTML page with my blog post locally, I copy and paste into Substack.

Clawdbot: My experience

There’s been a lot of hype around Clawdbot. It’s a truly powerful tool. But here’s my experience.

I tried it. Even bought a Mac Mini for it in late December. It didn’t stick for my usage patterns. For me, the most productive setup is terminal with Claude Code on the left, Obsidian on the right. I don’t really need to execute remote tasks from Telegram.

The main issue is observability. It’s hard to see what the agent is doing. When people claim “I have this employee, this thing just produced my YouTube script” - that sounds crazy to me. I spend so much time to get my outline right, and the output the agent produces by default is just garbage.

I could see Clawdbot being useful as an intelligent inbox. Capturing braindumps, images, any data that goes into your Obsidian vault. It can reason about everything. But for creative output? Not there yet.

The solution: use predictable workflows you’ve tested before. Skills you trust. If you can make sure the agent runs those skills, you can see it’s on track. But getting those skills working requires prior testing.

Security: Be Very Careful

I tried Clawdbot and realized I didn’t turn on the setting in Telegram to allow people to add the bot to public channels. That’s one attack vector I was exposed to. I started caring much more about security, trying to close all my ports.

It’s dangerous to run these tools without understanding the exposure. See this thread about Clawdbot security issues.

So I set up two YubiKeys and I highly recommend putting two-factor authentication on that stuff.

I did a full security overhaul inspired by Karpathy’s Digital Hygiene Guide. Set up 1Password, imported 273 passwords, disabled remote access software like TeamViewer, hardened SSH to key-only. The YubiKeys go on 1Password, Google, Apple, GitHub.

Let’s Discuss

What have you tried? What works, what’s not?

Join our Discord community to discuss Obsidian and Claude Code integration: https://discord.gg/g5Z4Wk2fDk

Artem

This topic really matters right now because there’s too much stuff going on. Your attention is the most important currency. Everything is trying to distract you from your goals.

I didn’t know how to solve this problem. For me it was a big issue: when I started my morning I would go to all these websites (Twitter, YouTube, LinkedIn), spend two hours there and feel wasted. Then I’d regret it.

To solve this I use Cold Turkey Blocker that blocks websites and applications on my Mac. I taught Claude how to block all the websites like Gmail. I can just run focus start 120 and for the next two hours my websites and apps are blocked.

It’s been tremendous value and Claude can easily add websites to the block list.

How to Pair with Your Agent

There was a blog post last week from Amp. They’re building an agent harness similar to Claude Code where you can work with different models. I really loved their post and it changed the way I interact with Claude Code.

Here’s an example from their post on how to give a task to your agent:

Vague prompt:

Add dark mode to the settings page

Specified prompt:

Add dark mode to the settings page.
We store user preferences in localStorage under user-prefs.
Match the toggle style we use in the notifications panel.
Use Chrome devtools to check dark mode is implemented correctly, toggle it back to light mode and check that it works correctly too.
Run the e2e tests when you’re done.

Same task, different outcome. The difference is the context your agent knows.

The core principle: give the definition of done and engineer feedback loops. The prompt should be such that the agent understands when the task is done and can verify the result on its own. This saves you attention so you don’t have to manage it on every step, telling it “do this now” or “do that”.

This applies to Obsidian too. Instead of “update the front matter” (vague, no feedback loop), you could say “update front matter and verify accuracy using a Python script that everything has been updated and properly integrated.”

Read the full Amp guide

Why You Should Swear More at Your Agent

I came to realize that swearing at your agent is a great way to tag a session where something went off track. It shows friction points where the system is not working as intended. This is a very valuable signal you can use to better design your system or interaction with the agent.

For me, when I say curse words to an agent, it means something is not great. During weekly review sessions I analyze my conversations using the Wispr Flow skill. It suggests improvements to your CLAUDE.md such that this won’t happen next time.

That’s a great way to tag conversations. I think Anthropic does it too: they flag conversations where you say curse words as high signal feedback to improve their system. So why shouldn’t we use it for ourselves?

Check out the Wispr Flow skill

Cowork

This week Anthropic released Cowork - Claude’s agentic capabilities in Claude Desktop, no terminal needed. A great move to make Claude Code accessible for users who are afraid of the terminal.

I tried it. Rough experience for me - I opened it in my Obsidian vault and it didn’t recognize my skills. There was definitely a bug. Personally, I wouldn’t switch. I don’t see a reason to go from terminal where I have complete control to Cowork.

Cowork can render artifacts like in the web version, which might be cool. But all my artifacts are in Obsidian. I can ask Claude to open them, so I don’t really have that need.

Still, it’s a great experiment and I think this is the trend. Right now OpenAI is challenged to show something similar. Boris, the creator of Claude Code, said on Twitter that Cowork was fully created by Claude Code in just 2 weeks. OpenAI could build a similar app, but their models aren’t as good at agentic tasks.

Connecting Claude to Obsidian

With Cowork there are now multiple ways to connect Claude to Obsidian:

For working with Obsidian, I recommend terminal + Obsidian side-by-side. It is very useful to see Bases or markdown files update live as Claude works.

Side-by-side

Terminal plugin

MCP Tool Search

There was a new update to Claude Code this week. It addresses the issue with having many MCP server configurations where tool definitions consume a significant portion of the context window. They added MCP tool search that dynamically loads tools on demand instead of defining all of them beforehand.

It’s configurable and activates automatically when MCP tool descriptions consume too much of your context window.

Read the MCP docs

This is useful for people who want to connect Claude Code to many external tools like Notion, Linear, GitHub. Personally, I tried many MCP tools but never used any of them for real. Nowadays I just use command line tools and write skills around them.

Also, they killed ultrathink. Claude now thinks with max budget by default. The habit will stick for a while.

Walking Dictation Setup

I had this new idea about how to interact with Claude Code. I have my MacBook, an iPad, and I sometimes like to walk around in my office and just dictate my thoughts. It’s great for content ideation and brainstorming.

I wanted a workflow where I can interact with Claude Code while moving around, not stuck at a desk.

I discovered something: I can put an iPad on a whiteboard and mirror screen from my Mac. I have a hardware trigger for Wispr Flow and a wireless mic, so I can be anywhere in the room. Wispr Flow transcribes my voice at a click of a button. I have another trigger for long press that sends the message to Claude.

Here’s a short video of the setup in action:

It’s truly transformative.

Claude Code Extension for Obsidian

I developed an extension for Claude Code that lets it see your Obsidian vault, your active file, and selected text. It helps you stay on the same page with Claude without having to tag files manually.

Select a paragraph in your blog post, ask Claude to tighten it - no copy-paste needed. Open a meeting note, ask to extract action items. The interaction has less friction when Claude already knows what you’re looking at.

Plan to share more about this in the next video.

Workshop Recap

This week I ran a workshop. We had attendees from different backgrounds: people keen on using Obsidian, people who used it for interview preparation, people with backgrounds in finance, developers, consultants, and folks working in cybersecurity with teams.

A common theme emerged: people have to re-explain their context each time to Claude. Integrating Claude Code within their teams with Obsidian, working on side projects with Claude Code. How to manage your context is a big issue. How to find and structure information for Claude Code.

It’s really hard to meet a person who uses Claude Code in real life. It’s a very small community. It was great to engage with people at the workshop and propose working solutions to problems we share.

Let’s Discuss

What have you tried? What works, what’s not?

Join our Discord community

Resources

Skills repo - Browse the skills I mentioned (Wispr Flow and more)
github.com/ArtemXTech/personal-os-skills

Workshop - Stop re-explaining your life to AI. 2 days live, hands-on, leave with your system running. February 7-8.
workshop.artemzhutov.com

Lab - Turn your Obsidian into notes that do the work. No code. 6-week program, beginner-friendly. Starts January 27.
lab.artemzhutov.com

Artem