Obsidian Handbook on RanceLee的博客

AI Collaboration in Obsidian: From Conversation to Action

Mon, 01 Jan 0001 00:00:00 +0000

This chapter begins the fifth part: AI Collaboration.

The previous four parts covered Obsidian itself—how to get started, configure, write, and publish. This part covers the other side: with AI tools like Claude Code and Codex that can directly read and write local files, your Obsidian vault is no longer just a notebook for you to read; it also becomes a workbench where AI can work directly.

This chapter first explains how to get started, with three methods in increasing difficulty and automation:

The simplest way: directly give the file path to AI, let it read and process the original file
Obsidian CLI: more efficient than directly reading files, suitable when your vault has many files
Skill: solidify the entire workflow into a single command, fully automated

Directly Give AI the File Path

This is the simplest method—no plugins needed, no CLI knowledge required.

The AI here refers to tools like Claude Code or Codex that can directly read and write local files, not web-based chat interfaces like DeepSeek or ChatGPT.

You just need to give Claude Code or Codex the full path to a file, and it can read the file and process it directly on the original. For example:

“Summarize the key points of this note: /Users/yourusername/Documents/Obsidian/01Notes/some-note.md”
“Translate this article into English and overwrite the original”
“Check this draft for typos and logic issues, then fix them”

The AI reads the file content, understands your request, and writes the modified content back. Summarization, translation, polishing, formatting adjustments—these one-off tasks are well suited for this method.

The barrier is extremely low; you can use it right away. The only downside is that you have to manually specify the request and path each time, making it suitable for occasional use.

Obsidian CLI

Directly giving file paths works, but once your vault has many files, AI blindly scanning files becomes slow and the results may not be accurate. That’s where CLI comes in.

After updating to the latest version of Obsidian, a CLI interface is available, allowing AI to directly operate on your vault via commands.

Some may ask: Can’t AI already read my files directly? Why do we need CLI?

Here’s an analogy. Your Obsidian vault is a library with hundreds of books.

Without CLI: When AI needs to find information, it can only search between shelves, flipping through books one by one, or rely on you telling it “go to the third row, second book.”

With CLI: The library gains a retrieval system. AI enters a topic, and the system directly tells it which files are relevant, where they are, what keywords are in the notes—and it can also create new files, update properties, and move content between folders.

The efficiency difference is huge. Once your vault has many files, the accuracy and speed of AI finding things are on completely different levels with or without CLI.

How to Use

The simplest way: directly tell the AI to use CLI during your conversation.

For example, if you want AI to organize your notes, just say: “Use Obsidian CLI to search for content about XXX in my 01Notes/ folder,” and AI will call the obsidian search command to retrieve it, instead of blindly scanning files. Common commands include:

Search content: obsidian search vault="OBSIDIAN_VAULT" query="keyword" path="01Notes"
Read file: obsidian read vault="OBSIDIAN_VAULT" path="04Output/filename.md"
Create note: obsidian create vault="OBSIDIAN_VAULT" path="target-path.md" content="..."
List folder: obsidian files vault="OBSIDIAN_VAULT" folder="04Output"

You don’t need to memorize these commands; just tell AI what you want to do and let it choose which command to use.

An even more convenient way is to solidify these operations into a Skill. In the Skill, predefine which operations should be done via CLI, and AI will automatically follow the Skill’s rules without you having to remind it each time. My WeChat Official Account writing Skill works like this—it specifies searching for materials with obsidian search, outputting articles with obsidian create, and setting properties with obsidian property:set. Every time AI runs this Skill, it automatically uses CLI to operate the vault without additional instructions.

Skill: Turn a Workflow into a Single Command

CLI solves the “finding” problem, but you still have to manually state your needs each time. If you have a fixed workflow, you can write it as a Skill, and later run the entire process with a single command.

First, let me explain what a Skill is. Simply put, a Skill is a fixed script you write in advance for AI. You include all the rules, workflows, and formatting requirements. Then, each time you issue a command, AI runs according to this script without needing repeated explanations. If you’ve used Claude Code, a Skill corresponds to the /skill-name command.

Here are some scenarios where I use Skills to process Obsidian files:

Video to text: Bilibili or local videos, extract audio, transcribe to text, organize into Obsidian notes, and drop directly into the inbox folder.

Add bidirectional links: After writing a new note, have AI scan existing notes and add [[bidirectional links]] to related content, weaving the information network.

Write articles: Given a topic, AI searches for materials, confirms the topic direction, learns my writing style, writes a draft, reviews and reduces AI flavor, adds images, and finally outputs the article to the 04Output/ folder.

Proofreading and fact-checking: Throw a finished draft to AI, have it check paragraph by paragraph for errors, logic issues, and claims worth verifying.

These tasks used to be done manually, scattered and time-consuming. With Skills, a single command lets AI run the entire process, and you only need to confirm at key points.

Concepts alone are too abstract. Let’s look at a concrete example of a Skill.

I created a WeChat Official Account writing Skill for the 04Output/ folder, covering the complete writing process from topic selection to publication. Here’s how it works:

Step 1: Find topics. AI can search Reddit, Hacker News, and X for recent hot topics in AI, finance, and technology, and list several candidate topics for you to choose from.

Step 2: Search for materials. After confirming the topic, AI automatically searches for relevant information from the past two years, organizes it into knowledge base files, and saves them.

Step 3: Discuss direction. AI gives you 3-4 writing angles and corresponding outlines to choose from. You confirm before proceeding.

Step 4: Learn style and write draft. Several modes to choose from: read your own published articles to learn your style, apply style templates from authors like Jiubian or Huashu, or specify an article to extract style features on the spot. After learning the style, write the draft.

Step 5: Review. Three passes: content accuracy, reduce AI flavor (replace phrases like “it is worth noting,” “empower,” “in summary”), and polish sentence and paragraph details.

Step 6: Add images and publish. Insert image placeholders, and if needed, directly push to the WeChat Official Account draft box.

Throughout the process, AI uses Obsidian CLI to operate your folder: search existing notes as materials, save briefs and knowledge base files to specified directories, output the final article to 04Output/, and set frontmatter properties. You don’t need to manually move any files.

The screenshot below shows what it looks like when I issue a writing command to AI:

This is just an example for the 04Output/ folder. You can create your own Skills for any folder: a Skill for organizing reading notes, a Skill for summarizing meeting notes, a Skill for reviewing journals… As long as you can clearly describe “what I want AI to do for me in this folder,” you can write it as a Skill.

I have open-sourced this WeChat Official Account writing Skill. If you need it, you can download it directly from my blog: https://blog.discoverlabs.ac.cn/downloads/writing-gongzhonghao-skill/

Summary

What you learned today:

The simplest way: directly give the file path to AI, it can read and process the original file—summarization, translation, modification all work
Obsidian CLI: When your vault has many files, CLI gives AI a “library retrieval system” for more accurate and faster information finding
Skill: Write a fixed workflow as a script, run the entire process with one command, suitable for repetitive workflows

Key points:

The three methods increase in difficulty and automation; choose according to your needs
The combination of CLI + Skill is the true deep integration of AI and Obsidian
You don’t need to write a Skill from scratch; you can have AI write it for you

Claudian: Put Claude Code in the Obsidian Sidebar

Mon, 01 Jan 0001 00:00:00 +0000

There are three ways to integrate AI with Obsidian: directly providing file paths, using Obsidian CLI, and using Skills. Among these, the combination of CLI and Skills offers the best results, but it also has the highest barrier to entry—you need to have the terminal open, understand CLI commands, and write or modify Skills yourself.

If you find that too cumbersome, or if you only occasionally want AI to help you process notes without all that setup, the plugin introduced today is a lighter alternative: Claudian.

How the Plugin Approach Differs from Using the Terminal Directly

Before talking about Claudian, let’s clarify the fundamental difference between these two approaches.

When using the terminal directly, you have two windows: Obsidian and Claude Code. You’re writing notes in Obsidian and want AI to help you process something. You switch to the terminal and say, “Take a look at this file: /Users/you/Obsidian/SomeNote.md”. After AI processes it, you switch back to Obsidian to see the results. You jump back and forth between two windows, and each time you have to manually specify which file you’re working on.

The plugin approach is different. Claudian embeds AI into Obsidian’s sidebar. Whichever note you open, AI automatically knows what you’re looking at. You don’t need to specify the path; you just chat in the panel on the right. When it’s done, you don’t need to switch windows—the results are reflected directly in the note.

To use an analogy: the terminal approach is like having an office next door—you have to run over and say “Please process this document,” then bring the file over. The plugin approach is like having an assistant right at your desk—you say “Help me edit this paragraph,” and they work on it right in front of you.

One thing worth clarifying: Claudian essentially still calls the Claude Code CLI. Its capabilities are the same as using Claude Code directly in the terminal; it’s not using a different AI. The only difference is the entry point—it’s moved from the terminal to the Obsidian sidebar.

So if you’re already seriously using the Skill + CLI approach, Claudian is not a stronger replacement—it just makes the operation smoother. If you don’t use the terminal much, or if you find that setup too heavy, Claudian is a more suitable entry point for you.

What is Claudian

Claudian is an Obsidian plugin created by YishenTu. It’s open-source under the MIT license. GitHub repository:

https://github.com/YishenTu/claudian

Released in early 2026, it quickly gained over 4,500 stars and spread rapidly among Obsidian and Claude users.

Currently, it is not yet available in the official Obsidian plugin marketplace, so manual installation is required.

How to Install

Before installing, make sure of two things:

You have Claude Code CLI installed (command-line version, not the web version)
Your Obsidian version is 1.8.9 or newer

These are prerequisites; both are required. For installing Claude Code, please refer to the official documentation: claude.com/code.

The plugin supports a wide range of models: Claude subscription, API Key, or platforms that support the Anthropic API format like OpenRouter and DeepSeek.

Installation Method 1: Manual Download from GitHub Release (Recommended)

Go to https://github.com/YishenTu/claudian/releases and open the latest release page
Download three files: main.js, manifest.json, styles.css
In your Vault, find the .obsidian/plugins/ folder and create a new folder named claudian
Place the three files into that folder
Open Obsidian → Settings → Community plugins → Find Claudian → Enable

Installation Method 2: Automatic Installation with the BRAT Plugin

BRAT is a tool specifically for installing plugins that are not yet on the official marketplace. After installation, BRAT will also automatically notify you of updates to Claudian.

Search for BRAT in Obsidian’s Community Plugins, install and enable it
Open BRAT’s settings and click “Add Beta plugin”
Enter https://github.com/YishenTu/claudian and click Add Plugin
After installation, enable Claudian in Community Plugins

Both methods work; manual download is more straightforward, while BRAT makes updates easier.

What Claudian Can Do

Click the robot icon in the left ribbon, or use the command palette to open the Claudian panel. A chat panel will appear on the right.

When you talk to the AI here, it can directly execute actions in your Vault: read files, write files, search content, run commands—the same capabilities as using Claude Code in the terminal. The only difference is that you never leave the Obsidian interface.

Automatically Aware of the Current Note

I find this feature to be the most convenient.

Whichever note you open, Claudian automatically attaches it to the context. The AI knows what you’re looking at without you having to specify the file path each time.

If you want to reference other files, type @ in the chat box. A dropdown list will appear, allowing you to select from Vault files, or reference MCP services or custom Agents.

Additionally, you can tag certain notes (e.g., private), and Claudian will automatically skip those files, not sending their content to the AI.

Inline Edit: Select Text and Edit Directly

This feature is useful when you only want to edit a paragraph without letting the AI modify the entire note.

Select the text you want to edit, trigger the shortcut key (which you can customize), and a small panel pops up. You can give instructions like “Make this more conversational” or “Translate this into English,” and the AI only processes the selected portion.

Image Support

You can send images in the chat: drag and drop, paste a screenshot, or enter the image file path—all three methods work.

After seeing the image, the AI can describe its content, extract text, answer questions like “What is this image about?”, etc. This is quite useful for people who frequently take screenshots for notes.

Slash Commands

Type / and a list of your predefined command templates will appear.

For example, if you often use the action “Summarize the key points of the current note,” you can save it as /summarize. Next time, just type /summarize and the command expands, so you don’t have to retype it each time.

Templates can include parameter placeholders, reference @files, and even embed bash commands. If you use Claude Code Skills, Claudian recognizes the same format, so they can be shared between both.

Plan Mode

Press Shift+Tab to switch to Plan mode.

In this mode, the AI won’t directly modify your files. Instead, it will first explore and plan, presenting the plan to you for confirmation before executing.

This is suitable for larger tasks, such as “Help me organize the structure of the 01-notes/ folder” or “Merge these notes into a single summary.” If you run such operations directly, the AI might change many things you didn’t anticipate. Reviewing the plan first is much safer than dealing with a mess afterward and having to undo changes.

Permission Modes

Claudian has three permission modes that control whether you need to confirm when the AI performs actions:

YOLO: Fully automatic. The AI executes any action without pop-ups. Most efficient, but you need to trust the AI’s judgment.
Safe: A pop-up asks for your confirmation every time the AI wants to modify a file. Safe, but frequent confirmations can interrupt your flow.
Plan: This is the Plan Mode described above. Plan first, then execute.

For daily use, YOLO is sufficient. If you care more about your Vault structure, you can use Safe. Before large operations, switch to Plan to review first.

Model Selection

You can switch between Haiku, Sonnet, and Opus to meet the precision needs of different tasks. Use Haiku for simple questions to save tokens; use Sonnet for organizing complex notes; use Opus for deep reasoning tasks.

Summary

What we learned today:

The core difference between the plugin approach and the terminal approach: no need to switch windows, AI automatically knows the current note
Claudian is a plugin that embeds Claude Code into the Obsidian sidebar; it still calls the Claude Code CLI under the hood
Installation requires Claude Code CLI + Obsidian 1.8.9+, and can be done via manual download from GitHub Release or using BRAT
Core features: sidebar chat, automatic attachment of current note, Inline Edit, image support, Slash Commands, Plan Mode, permission control

Key points:

If you don’t want to deal with the terminal and Skills, Claudian is a lower-barrier entry point
If you’re already using the CLI + Skill approach, Claudian is not a replacement but a way to make operations smoother
Inline Edit is suitable for precise local edits; Plan Mode is suitable for large-scale operations
Permission modes range from YOLO → Safe → Plan, becoming more cautious as you go; choose based on the scenario

Clip YouTube Videos into Obsidian

Mon, 01 Jan 0001 00:00:00 +0000

Remember the Web Clipper from the previous chapter? It’s Obsidian’s official browser extension that lets you save web articles as clean local Markdown files with one click, fast and without relying on any third-party services.

Unfortunately, it used to only clip text. But recently, it quietly updated to version 1.4, adding a new feature that made my eyes light up:

It now supports clipping YouTube videos.

This isn’t a half-hearted operation like taking a screenshot or saving a link. Instead, it extracts the video’s full transcript with timestamps. You can click on any subtitle line to jump to that point in the video, and as the video plays, the subtitles scroll along automatically.

This feature solved a long-standing pain point for me—when I want to take notes while watching a video, I no longer have to keep pausing to manually type out the subtitles.

First, a Quick Refresher on Web Clipper

If this is your first time hearing about this plugin, here’s a brief background.

Web Clipper is Obsidian’s official browser extension, supporting Chrome, Edge, Firefox, and other major browsers. Its core function is to save web content as local Markdown files with one click—clean formatting, fully offline, and no third-party cloud services involved.

Installation and basic setup were covered in the previous chapter, so I won’t repeat them here.

In this post, we’ll jump straight to the new feature. But first, a heads-up: you need to upgrade the plugin to version 1.4 or later.

Entering YouTube Clipping Mode

The process is straightforward.

Open any YouTube video, click the Web Clipper icon in your browser’s toolbar, and when the plugin panel pops up, look for the “open book” icon and click it.

After clicking, the interface transforms completely.

You’ll see the video at the top and the full transcript below, with each line timestamped.

This interface isn’t static. As the video plays, the subtitles automatically scroll to match, and the current line is highlighted. It works both ways—click any subtitle line, and the video jumps to that point.

What This Interface Offers

The official description of this YouTube subtitle interface is:

Provides interactive subtitle functionality, supporting video pinning, jump-to-play via subtitles, auto-scrolling, and highlighting the current position.

In simple terms, it does four things:

Video Pinning: When you scroll through the subtitles, the video stays fixed at the top. You can browse the transcript while the video continues playing, without interference.

Click to Jump: Find a sentence you’re interested in, click it, and the video jumps there immediately. No more manually dragging the progress bar to guess the time.

Auto-Scroll: The subtitle area scrolls in real-time with the video playback, so you don’t have to follow along manually.

Highlight Current Position: The currently playing subtitle line is highlighted, so you can see at a glance where you are in the video.

There are also a few extra features in the top-right corner: you can underline subtitles, highlight text, and adjust font size.

If you think the video is worth archiving, click the Obsidian icon in the top-right corner, and the entire content will be saved locally just like a regular clip.

After Saving to Obsidian

After saving, open Obsidian and find the new note.

At the top, you’ll see an embedded preview of the original video that you can play directly in Obsidian; below it is the full transcript with timestamps.

In the future, when you want to revisit this video, you don’t need to open your browser and search for it. Everything is in Obsidian—search, reference, annotation, all in one place.

What If You Don’t Understand English?

Many great videos on YouTube are in English, with English subtitles. But there’s a solution. We’ve covered three methods before, and I’ll reiterate them here:

Immersive Translate: This browser extension can directly provide bilingual translations for YouTube subtitles, displaying Chinese and English side by side. It’s the simplest to use.

Connect DeepSeek in Web Clipper: Web Clipper supports configuring an AI interface. You can set it to automatically call DeepSeek to translate the content into Chinese during clipping. Set it up once, and it’s fully automatic from then on. That means the subtitles below the video will already be translated when they arrive in your vault.

Translate with Claudian after saving: After saving the video subtitles into Obsidian, use the Claudian sidebar to translate them. The results are excellent, and you can even have it create a bilingual version, a pure Chinese version, etc.

These three methods were covered in previous articles. If you have questions, feel free to refer back to them.

Unfortunately, Bilibili Is Not Supported

It’s a real pity that this feature currently does not support Bilibili, especially since Bilibili is my go-to platform for educational videos. I hope the official team will add support in the future.

Fortunately, I previously created a free, open-source skill that can handle Bilibili video content. You can find it on the blog’s download page. If you need it, go check it out.

What We Learned Today

Web Clipper 1.4 added YouTube video clipping. To enter this mode, click the “open book” icon in the plugin panel.
The subtitle interface supports four features: video pinning, click-to-jump playback, auto-scroll, and highlighting the current position.
After saving, the Obsidian note includes both an embedded preview of the original video and the full timestamped transcript.
English videos are not a barrier. Immersive Translate, connecting DeepSeek in Web Clipper, and Claudian are three viable solutions.
Bilibili is not currently supported, but there is a free open-source skill to fill the gap.

Key Takeaways

Web Clipper’s YouTube clipping isn’t about taking screenshots or saving links; it extracts the full transcript and timeline.
Subtitles and video are bidirectionally linked: click a subtitle to jump in the video, and the subtitles follow the video playback.
Once saved into Obsidian, the video content becomes a searchable, quotable local note.
Three translation methods are available to suit your needs; language is not a barrier.
Bilibili is not yet supported—be aware of this limitation.

Command Plugin: Customize Your Context Menu

Mon, 01 Jan 0001 00:00:00 +0000

I’ve covered many operations and mentioned commands frequently, but I know you might not be used to that workflow. For common tasks, we can use the Commander plugin to add them to our context menu, making them much more convenient to access.

In simple terms: take the commands you use often and pin them directly to your context menu. Right-click anytime to access them, without needing to open the Command Palette every time.

Install the Commander Plugin

Open Settings, go to Community Plugins, search for command, find the Commander plugin, and install it.

There are several plugins with “command” in their names. Look for Commander by Johnny and phibr0, with 470k+ downloads. Make sure you get the right one.

Open the Plugin Settings

After installation, go to the Installed Plugins list, find Commander, and click the gear icon on the right to open its settings.

Once inside, you’ll see several tabs: General, Left Ribbon, Homepage, Status Bar, Editor Menu… We want to customize the context menu, so click the Editor Menu tab.

There are already some default commands. Scroll to the bottom and click the Add Command button.

Search and Select a Command

After the search box pops up, first type a keyword, then wait for the command list to appear before selecting.

You must type a keyword first, then select from the list. Don’t click on the list while it’s empty, or you might not find the command you want—there are too many commands, and the default display is incomplete.

Name the Command

After selecting a command, a dialog will appear asking you to give it a custom name. It’s recommended to use a descriptive name so you can easily identify it in the context menu.

(Sometimes before this step, you may be asked to choose an icon. Pick any one or skip it—it doesn’t affect functionality.)

See the Result

Once done, right-click anywhere in the editor, and the newly added command will appear in the menu.

That’s it—six steps and you’re done. From now on, just right-click to use the command, much faster than opening the Command Palette.

Summary

This plugin is very simple to use, but it can significantly boost your daily efficiency. Obsidian has hundreds of commands. Pin your most frequently used ones to the context menu, and trigger them with a right-click, saving you the repetitive open-search-execute cycle.

What you learned today:

The Commander plugin can add any Obsidian command to the context menu, sidebar, status bar, and other locations.
When adding a command, you must type a keyword first before selecting, otherwise you might not find it.
Give your commands descriptive names for easier identification in the context menu.

Key points:

When searching for a command, type first, then select—the order matters.
Commander can customize not only the context menu but also several other locations like the sidebar and status bar.
Descriptive names are much more user-friendly than the default long English command names.

Create Your First Obsidian Vault

Mon, 01 Jan 0001 00:00:00 +0000

Now that you know what Obsidian is and why it’s recommended, let’s get started by creating your first vault.

What is a Vault?

When you open Obsidian, it asks you to select or create a Vault.

What is a vault? Simply put, it’s a folder. All your notes, attachments, and configuration are stored in this folder. A vault = an independent note space. You can think of it as separate notebooks.

If you open this folder on your computer, you’ll see a bunch of .md files and subfolders, just like any other folder. Obsidian just adds a nice interface and powerful features on top of this folder.

Why Create Multiple Vaults?

Obsidian supports creating multiple vaults. You might ask: why not put everything in one vault?

You can put everything in one vault, and for most people, one vault is enough. But there are scenarios where separate vaults make sense:

Writing a novel: one vault per novel. That way, backlinks and tags are specific to that novel and won’t mix with other notes.
Separating work and personal life: one vault for work notes, one for personal notes. When you change jobs, you can delete the work vault without affecting personal content.
Shared scenarios: family shared vault, team project vault, isolated from personal notes.

Recommendation for beginners: start with one vault. Once you’re comfortable and feel the need to split, you can do it then.

I personally use a single main vault, with folders to organize different types of content: inbox, notes, templates, output, archive… one vault handles everything.

How to Create a Vault

Apple Ecosystem Users (Recommended)

If you use an iPhone/iPad and a Mac, here’s the easiest way:

Step 1: Create the vault on your phone or iPad.

Open Obsidian on iOS, tap “Create new vault”, give it a name. The key is — choose iCloud sync by default, so your vault is automatically stored in iCloud Drive. Step 2: Open it on your Mac.

Open Obsidian on Mac, select “Open existing vault”, find the vault folder you just created in iCloud Drive, and open it. Why do it this way? Because a vault created on iOS is automatically placed in the Obsidian folder in iCloud Drive, and sync is enabled by default without any manual setup. If you create it on Mac first, you’d have to manually move the folder to the iCloud directory, adding an extra step.

Once set up, notes written on your phone sync instantly to your Mac, and changes made on your Mac appear immediately on your phone.

Windows / Android Users

Open Obsidian, click “Create new vault”, and choose a location you can easily find.

If you want multi-device sync, place your vault folder in a OneDrive sync directory. Same principle as iCloud — essentially, put the folder in a cloud drive directory and let the cloud drive handle the rest.

What Does the Obsidian Interface Look Like?

Once your vault is created, open it and you’ll see the interface. Don’t be intimidated — it’s simple, with three main areas:

The leftmost column contains shortcut buttons — search, graph view, daily note, etc. These are quick entries provided by plugins, which we’ll cover later.

Next to it is the file list, identical to the folder structure on your computer. You can create new folders, new notes, and drag to reorder.

You can organize notes with folders, just like managing files on your computer. For example, my vault is divided like this:

00 Inbox — temporary material thrown in
01 Notes — formal notes
04 Output — finished articles
05 Archive — infrequently used but kept

You don’t need to copy my structure — organize according to your own habits. The key is: don’t get hung up on categorization, just start writing.

Center: Editor Area

This is where you write notes, and where you’ll spend most of your time.

Open a note (or create a new one) and start writing directly. All the Markdown syntax you learned earlier works here — # for headings, ** for bold, - for lists, [[]] for backlinks.

Above the editor, there’s a file path showing which folder the current note is in.

The right sidebar is collapsed by default. When opened, you’ll see several tabs:

Backlinks: shows which notes reference the current note (the core of backlinks)
Tags: list of tags in the current note
Outline: auto-generated table of contents based on heading levels, easy for navigation

You might not use the right panel much at first. That’s fine — as your notes grow and you start using backlinks, the backlinks panel will become very useful.

Write Your First Note

Click “New note” in the top left (or press Ctrl/Cmd + N), and a blank note appears.

Give it a title, then start writing. For example:

# My First Obsidian Note

Started using Obsidian today.

## Why Obsidian
- Data is in my own hands
- Supports Markdown
- Works well with AI

## Today's Plan
- [ ] Familiarize with the interface
- [ ] Write the first note
- [x] Install Obsidian

After writing, the note is automatically saved — no need to press Ctrl+S, Obsidian saves in real time.

Connect Your Notes with Backlinks

We introduced the concept of backlinks earlier; now let’s see how to use them.

Link to a whole note: Type [[ and Obsidian will automatically show a list of notes to choose from. Select one and a backlink is created; click it to jump to that note.

Today I read [[Feynman Learning Method]], the core idea is to test yourself by teaching others.

Link to a specific section: If you don’t want to link the whole note, but only a section under a heading, add # after the note name and select the heading:

See [[Feynman Learning Method#Specific Steps]], the first step is to choose a concept.

Clicking this link will jump directly to the “Specific Steps” heading in the “Feynman Learning Method” note.

This is especially useful for organizing knowledge and concepts. For example, if you’re studying economics, you can create separate notes for “GDP”, “Inflation”, and “Interest Rate”, then use backlinks to reference them wherever you use these concepts. Over time, your vault becomes your own personal encyclopedia — each concept has an explanation, concepts are interconnected, and you can click to jump and review.

Edit View vs. Reading View

You may notice a toggle button (book icon) in the top right corner that switches between two views:

Edit View: You see all Markdown symbols. #, **, - [ ] are displayed as-is. Good for writing.

Reading View: Markdown symbols are rendered into actual formatting. Headings become larger and bold, bold text is actually bold, lists become beautiful lists. Good for reading.

There’s also an intermediate state called Live Preview — it renders as you write. The line where your cursor is shows raw Markdown, while other lines are rendered. Recommended for beginners as it balances editing and reading.

In Settings → Editor → Default editing mode, you can choose “Live Preview” or “Source mode”. I recommend selecting “Live Preview”.

How to Insert Images

Notes often need images. Inserting images in Obsidian is very simple:

Method 1: Direct paste. After taking a screenshot, press Ctrl/Cmd + V to paste into the editor, and the image is inserted.

Method 2: Drag and drop. Drag an image file from a folder directly into the editor.

After insertion, you’ll see something like this in the editor:

![[screenshot-2026-02-27.png]]

This is Obsidian’s image syntax — like backlinks, it uses ![[]] to wrap the filename. In Reading View, the image displays normally.

Where Are Images Stored?

This is a common point of confusion for beginners. When you paste an image, Obsidian automatically saves it to your specified attachment folder.

By default, images are dumped in the vault root directory, which can get messy over time. It’s recommended to set up a dedicated attachment folder to store all images, audio, PDFs, and other attachments in one place.

Recommended Attachment Settings

Open Settings → Files & Links, and configure as follows:

Setting	Recommended Value	Description
Default location for new notes	Specified folder for attachments	New notes are placed in a designated folder
Folder to store new notes	`00 Inbox`	New notes go to inbox first, then categorized later
Default attachment path	Specified folder for attachments	Images and other attachments are managed uniformly
Attachment folder path	`05 Archive/Assets`	All images, audio, PDFs are stored here

Links section:

Setting	Recommended Value	Description
Internal link type	Shortest form possible	Backlink paths are more concise
Always update internal links	On	Automatically updates all references when renaming files, no fear of renaming
Use Wiki links	On	Uses `[[]]` syntax, more convenient than standard Markdown links

After this setup, your vault stays tidy — notes and attachments each have their place, no mixing.

Better Solution: Image Hosting Service

But honestly, storing images in a local attachment folder is not the optimal solution.

Why? Because when you want to publish your article to WeChat public accounts, blogs, or other platforms, local images can’t be uploaded — you’d have to manually re-upload and re-insert each one. With many articles, this becomes very painful.

A better approach is to use an image hosting service — upload images to the web, get a URL, and reference that URL directly in Markdown. This way, no matter which platform you publish to, images display directly without extra processing.

<!-- Local attachment method -->
![[screenshot-2026-02-27.png]]

<!-- Image hosting method -->
![](https://cf-img.discoverlabs.ac.cn/202602272b6a153c41f15fd574a6c29c2ae4a4e2.webp)

Of course, using an image hosting service means your images are uploaded to the web, so be mindful of privacy — don’t upload screenshots containing sensitive information.

The specific setup and usage of image hosting services will be covered in the final chapter of this tutorial. For now, just know that it exists.

Summary

What you learned today:

What a vault is: it’s a folder where all your notes are stored.
Why create multiple vaults: most people only need one; split for novels, work, or shared scenarios.
How to create a vault: Apple users recommended to create on iPhone (auto iCloud sync); others place in a cloud drive directory.
Three interface areas: left sidebar for file management, center editor, right sidebar for info.
First note: Ctrl/Cmd+N to create, write in Markdown, auto-save.
Two views: Edit View shows symbols, Reading View shows rendered output; Live Preview recommended.
Insert images: paste or drag-and-drop; set up an attachment folder to keep your vault tidy.

Key takeaways:

Don’t get hung up on categorization, just start writing.
One vault is enough, split when needed.
Recommended: Live Preview mode, good for both writing and reading.

Custom CSS: Make Obsidian Feel Like Your Own

Mon, 01 Jan 0001 00:00:00 +0000

We’ve covered theme settings before, and Obsidian looks much better after installing a theme. But many people still feel something is off after switching themes—font too small, line spacing too tight, note area too narrow… These details are beyond the scope of themes. This chapter will cover how to fine-tune with CSS Snippets.

This chapter covers four things:

What CSS is—understandable even without coding knowledge
Why you still need CSS even with a theme
Let AI write CSS for you—just copy and paste
Where to put the CSS and how to make it work

What is CSS

CSS stands for Cascading Style Sheets. It sounds technical, but the core logic is simple: CSS is a set of rules that control how things look.

For example:

What font, size, and color should this text be?
How wide is this area? What are the margins?
What should the background color be when hovering?

Almost all visual effects you see on a webpage are controlled by CSS. Obsidian’s interface is also built on web technology (Electron), so CSS can be used to control its appearance as well.

The theme you install is essentially a large package of CSS written by someone else. A CSS Snippet is a small piece of CSS you add yourself, specifically for fine-tuning things the theme doesn’t cover.

The theme is the overall style; snippets are local tweaks. They don’t conflict and can be used together.

Why Still Need CSS with a Theme?

Themes solve the “overall style” problem, but many personal preference details are beyond the scope of themes—and they shouldn’t be, because everyone’s preferences are different.

Several common scenarios where themes fall short:

Note area too narrow: Many themes limit the maximum width of notes by default, leaving large blank spaces on wide screens with content squeezed in the middle. Some like this layout, others find it wasteful.

Line spacing too tight/loose: The default line spacing might not be comfortable for you, but the theme doesn’t have an option for it.

Heading color not right: You like the theme overall, but the H1 color is a bit too bright and you want to dim it.

Annoying UI element: For example, a button you never use—you want to hide it.

These needs are very specific and personal. CSS Snippets are the tool designed to solve these “last mile” problems.

No Need to Write It Yourself—Let AI Write It for You

This is the most important point of this chapter: You don’t need to learn CSS at all—just let AI write it for you.

The process is very simple: just tell the AI what you want to change:

“Write me an Obsidian CSS Snippet to set the maximum width of the note content area to 900px”

“Write me an Obsidian CSS Snippet to set the body line spacing to 1.8”

“Write me an Obsidian CSS Snippet to change the H1 color to dark blue”

The AI will give you a complete CSS code snippet that you can copy and use directly.

A few tips to get better results from AI:

Specify it’s an Obsidian CSS Snippet, otherwise the AI might give you regular web CSS with incorrect variable names.
Ask AI to add comments, tell it “Please add comments next to each property explaining what it does” so you can understand your file later.
Change one thing at a time, one snippet file for one thing—easier to debug and toggle off individually.

Example conversation:

Me: Write me an Obsidian CSS Snippet to set the maximum width of the note content area to 900px, please add comments.

AI:
.markdown-source-view, .markdown-reading-view {
  /* Limit the maximum width of the note content area */
  --file-line-width: 900px;
}

That’s it. No need to understand CSS syntax, no need to look up documentation. Describe what you want, get the code, paste it, done.

Where to Put the CSS? How to Make It Work?

CSS Snippets have a fixed storage location. Just follow these steps.

Step 1: Find the snippets folder

Path: Your Vault root → .obsidian folder → snippets folder

.obsidian is a hidden folder. On Mac, press Command + Shift + . to show hidden files. If the snippets folder doesn’t exist, create one manually.

Of course, you can also access it directly from Settings.

Step 2: Create a .css file

In the snippets folder, create a new text file, change the extension to .css. Name it whatever you like, but it’s recommended to use a descriptive name like note-width.css or line-height.css. Paste the code from AI into it and save.

Alternatively, you can open this folder and let AI write the CSS file directly there.

Step 3: Enable it in Obsidian

Path: Settings → Appearance → CSS snippets

Scroll to the bottom of the page, you’ll see a “CSS snippets” section. Click the refresh icon on the right, and the file you just created will appear in the list. Click the toggle next to the filename, the toggle changes color, and the snippet takes effect. The interface changes immediately, no restart needed. If the effect isn’t right, turn off the toggle and go back to check the code.

How I Use CSS Myself

Here are a few snippets I actually use, for reference.

Widen note area – This is my most used one—set the maximum width of the note content area wider, so there’s less whitespace on large screens.

Adjust line spacing – The default line spacing is a bit tight for me, so I use CSS to increase it slightly for more comfortable reading.

Hide unused elements – There are some buttons and icons in Obsidian’s interface that I never use. I set them to display: none with CSS to hide them, making the interface cleaner.

Callout style tweaks – I didn’t like the default colors of callout blocks in a certain theme, so I used CSS to change them to softer colors.

These four snippets are stored in four separate .css files, each can be toggled individually. If after a while you find one doesn’t suit you, just turn it off—they don’t interfere with each other.

Summary

What you learned today:

CSS is the rule for controlling interface appearance; Obsidian uses CSS Snippets for local tweaks.
Themes are overall styles; snippets are detail adjustments—they work together.
No need to write CSS yourself; tell AI what you want to change and copy the code it gives you.
Snippet storage path: Vault root → .obsidian/snippets/ → .css file.
Enable in Settings → Appearance → CSS snippets, toggle on to activate.

Key takeaways:

Describing your needs to AI to write CSS is much more efficient than learning CSS syntax yourself.
One snippet does one thing, making management and debugging easier.
Toggles can be turned off anytime—safe and reversible, no need to worry about breaking the interface.

Daily Notes: The First Habit for Obsidian Beginners

Mon, 01 Jan 0001 00:00:00 +0000

We’ve covered hotkeys—binding frequently used commands to keys to double your speed. Now let’s talk about another core plugin: Daily Notes.

The Daily Notes feature deserves its own chapter, not because it’s complicated, but because many Obsidian users never use it after installation, missing out on a valuable habit.

Why Write Daily Notes

Let’s start with a real problem: many people don’t write daily notes not because they don’t want to, but because it feels like a hassle—typing, organizing, figuring out what to write.

So let’s start with one method: voice input.

Doubao, Xunfei Input, or your system’s built-in voice keyboard all work. Open your daily note, switch to voice input, speak for a few minutes about what happened today, stop, and the text is automatically transcribed. No typing, no worrying about structure—just speak.

This lowers the barrier to writing daily notes to the minimum. After speaking a paragraph, occasionally add a line break manually, and you’re done in two or three minutes.

Don’t worry about quality. A simple log is perfectly fine. Where you went, what happened, what you thought—just jot it down.

What matters is not how well you write, but that you record your current thoughts, emotions, and events.

What can you do with your daily notes?

Besides reviewing them yourself, there’s an increasingly useful method: send your daily notes to an AI and have it review and summarize for you.

For example, paste the last week or month of daily notes and ask the AI: “What have I been mainly busy with? Are there any patterns? Any noticeable mood swings?”

The AI can help you spot patterns you might not notice yourself—which days you were in a bad state, when you were most productive, how your mindset changed around a decision. This is much more efficient than flipping through entries one by one.

A single daily note isn’t worth much, but a hundred notes are data.

Step 1: Enable the Daily Notes Core Plugin

Daily Notes is a core plugin in Obsidian, disabled by default. You need to enable it manually.

Path: Settings → Core Plugins → Find “Daily Notes” → Toggle the switch on the right.

After enabling, a calendar icon will appear in the left sidebar. Click it to open today’s daily note directly.

Step 2: Configure Daily Notes

After toggling it on, a small gear icon will appear to the right of the “Daily Notes” line in Core Plugins. Click it to configure.

A few options to note:

Date Format

The default is YYYY-MM-DD, like 2026-03-09. Usually you don’t need to change it—this format is easy to sort and search.

If you have a preference (e.g., including the day of the week YYYY-MM-DD dddd), you can customize it here. The format rules are the same as {{date:YYYY-MM-DD}} in templates.

New File Location

Daily note files are created in the vault root by default. It’s recommended to change this to a dedicated folder, like 07 Daily Notes or 07 Review/Daily. This keeps your daily notes separate from other notes for easier management.

Template File

Enter the path to your daily note template here. Once set, each time you create today’s daily note, it will automatically apply this template—no need to invoke it manually.

This feature works with the next step: first create the template, then come back and fill in the path.

Step 3: Create a Daily Note Template

In your template folder (e.g., 02 Templates), create a new file and name it “Daily Note Template” or “Daily Record”—whatever you prefer.

Write a framework for what you want to record each day. A practical basic version:

---
date: {{date}}
---

## What I did today

## Problems encountered

## Plans for tomorrow

This is the same daily note template example from the chapter on templates. If you already created it then, just use it directly—no need to recreate.

A few notes:

{{date}} will automatically be replaced with the current date, no need to fill it in manually.
The three sections are a minimal framework. Add or remove based on your habits.
If you use voice input, you can make the structure even simpler—for example, just keep one “## Today” section without sub-sections, and write a stream-of-consciousness log.
Don’t make it too complex. The core reason you can stick with daily notes is one thing: low barrier.

After creating the template file, go back to the Daily Notes settings from the previous step and fill in the template file path (just the file name, e.g., 02 Templates/Daily Note Template).

Step 4: Start Writing Daily Notes

Once set up, there are three ways to open today’s daily note:

Method 1: Toolbar Icon

Click the calendar icon in the left sidebar to open today’s daily note directly. If it doesn’t exist yet, it will be created automatically.

Method 2: Command Palette

Press Cmd+P to open the command palette, type “Open today’s daily note”, and press Enter.

Method 3: Hotkey

If you think you’ll open your daily note every day, it’s worth assigning a hotkey (as described in the hotkey section). Once set, a single key press gets you there.

Choose whichever method feels comfortable. I use the toolbar icon—one click is enough.

Summary

What you learned today:

Enable the Daily Notes plugin: Settings → Core Plugins → Daily Notes → Toggle on
Configure three items: Date format, storage folder, template file path
Create a daily note template: Place it in your template folder, {{date}} auto-fills the date
Opening methods: Toolbar icon / Cmd+P search “Open today’s daily note” / Custom hotkey

Key points:

Voice input is the lowest-effort way to write—use Doubao or other input methods, speak for a few minutes, text is transcribed automatically, no typing needed.
Don’t make the template too complex—the fewer sections, the easier to stick with it. Just get started.
After accumulating daily notes, you can send them to an AI to summarize patterns and review progress, which is much more efficient than flipping through them yourself.

Excalidraw in Obsidian: Hand-Drawn Diagrams in Notes

Mon, 01 Jan 0001 00:00:00 +0000

As mentioned earlier, Canvas files are in .canvas format and exist separately from .md files—they need to be managed independently and can’t be combined with notes in the same file. This chapter introduces a tool that solves this pain point: the Excalidraw plugin.

What is Excalidraw and How is it Different from Canvas?

What is Excalidraw?

Excalidraw is a free and open-source online drawing tool with a standalone web version (excalidraw.com) that you can use directly in your browser without needing to sign up. Its hand-drawn style is perfect for flowcharts, mind maps, architecture diagrams, and similar content.

In Obsidian, we use the third-party plugin version—maintained by community developers, not officially by Obsidian, so it needs to be installed manually. The core features are the same as the web version, but with additional deep integration with Obsidian.

Differences from Canvas

Both seem like “drawing on a canvas,” but the file format is completely different, which is the core difference:

Canvas: Generates a .canvas file. This is a standalone JSON file that exists separately from your .md notes and needs to be managed independently.
Excalidraw: The drawing data can be compressed and embedded at the end of a .md file—one file, text and drawing coexist, no separate management needed.

The two screenshots below are from the same file:

This is why I recommend Excalidraw: when you open a file, you see the text; with a switch, you see the drawing. Both types of content in one place.

Installing the Excalidraw Plugin

Excalidraw is a third-party plugin and needs to be installed manually.

Path: Settings → Third-party plugins → Community plugins → Search for “Excalidraw” → Install → Enable

After installation, enable the plugin, and you’ll see an Excalidraw icon appear in the left sidebar.

Creating and Using Excalidraw

How to Create a New File

There are two ways:

Command Palette: Cmd+P (Mac) or Ctrl+P (Windows), search for “Excalidraw: New Drawing”, press Enter.
Left Sidebar: Click the Excalidraw icon to create a new one directly.

By default, a new file is created as .excalidraw (not .md). Don’t worry—how to make it part of a .md file is the focus of the “Two-in-One” section later.

Common Operations and Shortcuts

In Excalidraw’s toolbar, each tool has a number displayed below it—that’s the shortcut key. Press the number to switch tools directly without clicking the toolbar:

Tool	Shortcut
Selection	1
Rectangle	2
Diamond	3
Ellipse	4
Arrow	5
Line	6
Freehand	7
Text	8
Eraser	0
Pan canvas	Space + drag, or middle mouse button drag
Zoom canvas	Ctrl/Cmd + mouse wheel
Fit to screen	Shift+1
Select all	Ctrl/Cmd + A
Undo	Ctrl/Cmd + Z

One extra feature compared to Canvas: Excalidraw has a dedicated Freehand tool (shortcut 7) that lets you draw freely with your mouse or trackpad—something Canvas can’t do.

Keyboard Workflow: Drawing Without Leaving the Keyboard

Excalidraw also supports a pure keyboard workflow, great for quickly creating nodes, connecting them, and writing content:

Basic Navigation (in Selection mode):

Action	Shortcut
Select next/previous element	Tab / Shift+Tab
Move selected element	← → ↑ ↓
Enter text editing	Enter (when a text element is selected)
Exit editing, return to selection	Esc
Duplicate selected element	Ctrl/Cmd + D
Delete selected element	Backspace or Delete
Select all	Ctrl/Cmd + A

Adding Content to the Canvas

Shapes and Text: Select a shape from the toolbar and click on the canvas to draw it. With the text tool, click and start typing—Chinese is supported.

Arrow Connections: When a rectangle is selected, hovering over its edge reveals green connection points. Drag an arrow from one of these points to another shape, and it will snap into place.

Existing Notes: Drag notes directly from the Obsidian file tree into the Excalidraw canvas—they will be embedded as note preview cards.

Images: Drag image files onto the canvas to display them directly.

Key Point! Drawing Excalidraw with AI

Similar to the “Drawing Canvas with AI” section earlier, Excalidraw can also be generated directly by Claude Code.

Background

We’ve previously introduced Claude Code and the Skill system. Canvas uses the json-canvas Skill, and Excalidraw also has a dedicated Skill: excalidraw-diagram. Of course, there are many MCPs and Skills around Excalidraw—you can choose what you need.

It’s created by axtonliu and open-sourced on GitHub:

https://github.com/axtonliu/axton-obsidian-visual-skills/tree/main/excalidraw-diagram

After downloading, place it in the ~/.claude/skills/ directory, just like other Skills.

This Skill generates standalone .excalidraw files, suitable for scenarios where you only need the drawing and don’t want it mixed with note text.

If you want to embed the drawing directly inside a .md file (the two-in-one format described later), I’ve written an extended Skill: obsidian-excalidraw, specifically for this purpose—the result is compressed and embedded at the end of the .md file, with no extra files created. The two Skills serve different purposes; choose as needed.

How to Use

In Claude Code, type /excalidraw-diagram, select this Skill, press Tab, then describe what you want to draw. Claude Code will generate the corresponding Excalidraw file.

Live Demo

I used the content of this chapter as a demo—I told Claude Code: “Draw a flowchart of the chapter structure of this Excalidraw content, showing the relationships between the sections.”

Claude Code read the content and automatically generated a structure diagram, embedded directly at the end of the .md file. Switch to Excalidraw mode to see it. No need to manually drag nodes or connect lines—much faster than drawing by hand.

Key Point! Embedding Excalidraw into .md Files (Two-in-One)

Let’s be clear: By default, the Excalidraw plugin creates .excalidraw files, which are separate from .md files and need to be managed independently, just like Canvas.

The “two-in-one” feature is not the default behavior; it requires additional configuration. Once configured, new files will be in .md format, with the drawing data compressed and stored at the end of the file, so both coexist in the same file.

Canvas can’t do this, but Excalidraw can—after configuration, the same .md file can serve as both a regular note and a drawing board, all in one file. This is the most valuable part of this article.

Below, I’ve broken it down into 5 steps.

5.1 Two Key Properties

Observant readers may have already seen these two frontmatter properties in my earlier note screenshots:

excalidraw-plugin: parsed
excalidraw-open-md: true

excalidraw-plugin: parsed: Tells the Excalidraw plugin that this .md file contains Excalidraw data that needs to be parsed. Without this property, the plugin won’t process the file.

excalidraw-open-md: true: Opens the file in Markdown mode by default (instead of directly entering drawing mode). Set to true, you’ll see the text first when opening the file, and manually switch when you need to draw. Without it, every time you open the file, it jumps straight to the drawing board, and you’d have to switch back to read text—annoying.

With these two properties in the frontmatter, the file gains “dual-mode” capability.

5.2 Creating a Template File

The key to the two-in-one setup is to save this configuration in a template file, so that new notes automatically include it without manual addition each time.

Steps:

In your template folder (e.g., 02 Templates/), create a new .md file and name it “Excalidraw Template”.
Copy and paste the following content into it, then save.

---
excalidraw-plugin: parsed
excalidraw-open-md: true
---

%%
### Drawing
```compressed-json
N4IgLgngDgpiBcIYA8DGBDANgSwCYCd0B3EAGhADcZ8BnbAewDsEAmcm+gV31TkQAswYKDXgB6MSgw4CxAHSp6AWzJJMMJTEZgaCANoBdcuihQAymHRg+oCthhEAQulQBrAOb4ujXAGF6mPT4CCAAxABmkVGqnnhm2ABefIycmJgAvuTh2Oq68MDp6UA
```
%%

This is an Excalidraw template with an empty canvas. The two frontmatter properties (excalidraw-plugin: parsed and excalidraw-open-md: true) tell the plugin that this file is in two-in-one format and should open in Markdown mode by default. The compressed-json at the end is the empty canvas data.

5.3 Excalidraw Plugin Settings

Having a template file alone isn’t enough—you also need to tell the Excalidraw plugin “where to find the template” and disable a setting that interferes with file management.

Path: Settings → Excalidraw

Two things to modify:

① Set the template location: In Excalidraw settings, find the “Template file” option and enter the path to your template, e.g., 02 Templates/Excalidraw Template. From then on, every time you create a new file with Excalidraw, it will automatically use this template, including the excalidraw-open-md: true property.

② Disable “Add date to new file name”: By default, Excalidraw appends the creation date to new file names, e.g., Drawing 2026-03-12. This makes file names verbose and incompatible with Obsidian’s template naming logic. Find this option and turn it off.

5.4 Binding a Shortcut Key

Switching between Markdown mode and drawing mode via the right-click menu is too slow—bind a shortcut key for instant toggling.

Path: Settings → Hotkeys → Search for “Excalidraw”

Find this entry: “Excalidraw: Toggle between Excalidraw and Markdown mode”

Bind it to Cmd+E (Mac) or Ctrl+E (Windows). First check if this key combination is already in use—Obsidian’s default Cmd+E is for italics. If you use italics often, choose a different key, like Cmd+Shift+E.

After binding, in a two-in-one file, press Cmd+E to toggle between “viewing text” and “viewing drawing”—very convenient.

5.5 Compressed Data at the End of the File

After setup, every time you save drawing content in a two-in-one file, a block of data is automatically generated at the end of the file:

%%
### Drawing
```compressed-json
N4IgLgngDgpiBcIYA8DGBDANgSwCYCd0B3EAGhADcZ8BnbAewDsEAmcm+gV31TkQ...
```
%%

This compressed-json code block is the result of compressing all the drawing data—coordinates, colors, text content, connection relationships—all compressed into this single line of string.

Three things to note:

Do not manually delete this content. If you delete it, the drawing data is gone, and switching to Excalidraw mode will show an empty canvas.
%% is Obsidian’s comment syntax. In Reading view, this content is hidden and won’t be displayed, so it doesn’t affect the note’s readability.
The compressed-json line must be a complete single line. If it’s broken by a line break, the file will error and fail to open.

Summary

What you learned today:

Excalidraw = free and open-source drawing tool: Has a standalone web version; Obsidian uses the third-party plugin version, with hand-drawn style and infinite canvas.
Core difference from Canvas: Canvas generates separate .canvas files that need independent management; Excalidraw drawing data can be compressed and embedded into .md files—one file, two uses.
Installation: Settings → Third-party plugins → Community plugins → Search for and install Excalidraw.
Tool shortcuts: Number keys 1-8 and 0 to switch tools, Esc to exit editing, Tab to jump between elements, arrow keys to move—core rhythm: number keys for tools + Esc/Tab for navigation.
AI drawing: The /obsidian-excalidraw Skill lets Claude Code directly generate embedded drawings, much faster than manually dragging nodes.
Two-in-one setup: Add excalidraw-plugin: parsed + excalidraw-open-md: true to frontmatter, configure via template file, set template path in Excalidraw settings, bind Cmd+E for quick mode switching.
File tail data: The ## Drawing + compressed-json code block is the compressed drawing data, wrapped in %%, invisible in Reading view—do not delete manually.

Acknowledgments: The “Two-in-One” setup in this chapter references the method by Bilibili creator Fiveth_ (video: BV1hyhPzoEcd), credited here.

Folder Structure: A Local Zettelkasten Workflow

Mon, 01 Jan 0001 00:00:00 +0000

After covering the diary plugin—which uses voice input to lower the barrier and sends accumulated entries to AI for review—this chapter addresses a common stumbling block after installing Obsidian: how to organize your folders.

Why Plan Your Folder Structure

Without a plan, the typical result is: when you start using Obsidian, you casually create folders like “Work”, “Study”, “Reading”, “Temporary”… As you create more and more, you can’t remember where you put things, so you end up searching every time, making the folders useless.

Or you go to the other extreme: spending a lot of time designing hierarchies like “Work/Project A/Meeting Notes/2026/Q1”… It’s meticulously planned, but after two months you find the maintenance cost too high. You don’t know where to put new things, and everything ends up piled in the root directory.

The goal of folder planning is not to make your vault look tidy, but to make both storing and finding smooth.

Overview of Popular Methods

Before presenting my own approach, let’s briefly look at two well-known methods—just so you know they exist.

PARA

PARA is a method by productivity blogger Tiago Forte, with four folders: Projects (ongoing projects), Areas (long-term responsibilities), Resources (reference materials), and Archives.

The logic is clear and it’s quite popular. The problem is that boundaries are fuzzy—you’re often unsure whether something belongs in Areas or Resources. Figuring it out takes time, and over time, it’s easy to give up.

Zettelkasten

Invented by German sociologist Niklas Luhmann, the core idea is: each note captures a single idea, identified by a number, and connected through links to form a network. It doesn’t rely on folder classification but on connections between notes.

It’s great for deep knowledge accumulation, but the barrier to entry is high, and maintenance costs are not low. It’s not suitable as the main framework for daily workflow.

My Approach: 5 Folders + 1 Rule

No need for that complexity. Here’s a structure I’ve found sufficient and easy to maintain.

Folder Structure

00-Inbox/
01-Notes/
02-Templates/
04-Output/
07-Diary/

You can also create project folders as needed, like “08-Renovation” or “09-English-Learning”, and archive or delete them when done.

00-Inbox: Everything Comes In First

This is the entry point of the entire system.

Browser clippings, voice-transcribed ideas, random notes, unprocessed materials—throw them all into the inbox first, no matter what.

Don’t spend time categorizing when collecting. Just get it in first. The value of the inbox is to reduce friction in recording: you don’t need to think “where should this go”, just put it in.

But the inbox has a golden rule: things that come in must be processed regularly.

Every few days (or weekly), go through the inbox and sort items to their proper places—notes go to notes, delete what’s unnecessary, and move things to be turned into articles to the output folder.

The inbox is not a warehouse; it cannot accumulate indefinitely. If you have items from three months ago still untouched in your inbox, it means this workflow isn’t working yet.

01-Notes: No Categories, Flat Layout

This is the biggest difference from traditional approaches in this entire system.

In the notes folder, do not create subfolders; all notes are laid flat in a single layer.

Book notes, meeting minutes, learned concepts, extensions of an idea—all together, no topic separation, no time ordering, just one big flat layer.

Why do this?

Because in the AI era, search is more important than classification. Whether you put a note under “Economics/Macro/Monetary Policy” or in the root directory, it makes no difference to AI search. AI finds things by understanding content, not by folder paths.

And the time you spend on manual classification is pure maintenance cost—time spent thinking where to put it, remembering where you put it, and later not finding it.

With flat layout, finding notes relies on search. AI can do full-text search, which is much more reliable than you remembering “I think it’s in some subfolder”.

04-Output: Content for External Audiences

This folder holds content you write for external audiences: WeChat public account articles, blog posts, formal reports, documents organized for others.

The difference from the notes folder is the audience. Notes are for yourself; they don’t need to be complete or pretty, just recorded. Output is for others to see, or complete content you want to preserve.

Separating them has a benefit: when you open the output folder, you see relatively complete content, undisturbed by drafts and fragments.

07-Diary: Separate, Don’t Mix with Notes

Diary goes in a separate folder.

Diary entries are files generated by date, and their number grows linearly over time. As mentioned earlier, it’s recommended to set a storage path in the diary plugin to keep them in one dedicated place.

The reason for separating from notes is simple: the use case for diary is different from notes. Diaries are browsed chronologically, notes are searched by keywords. Mixing them would interfere with each other.

Project Folders: Create as Needed, Archive When Done

Renovation, job change, learning a skill—things with a clear time boundary can have their own folder, putting all related files together for easy centralized viewing.

After the project is completed, archive or delete the folder. Don’t let it occupy space forever and become another clutter pile.

Why Flat Layout is Better in the AI Era

Traditional folder classification logic is based on “manual browsing”—you need the folder structure to remember where things are, so you classify and build hierarchies.

But now it’s different.

Obsidian’s full-text search + AI’s semantic understanding can already cover most “finding things” scenarios. You may not remember a note’s filename, but you remember roughly what it’s about—that’s enough. Search a few keywords, or let AI find it for you.

Under this premise, the marginal benefit of fine-grained classification becomes very small, but the maintenance cost remains.

The more complex the folder structure, the more it means:

You have to think one more step when putting something in (where does this go?)
You forget where you put it after a while
The system becomes inconsistent, with some things floating outside the structure

Conversely, the simpler the structure, the lower the maintenance cost, and the higher the chance of sticking with it. A simple system that runs consistently is far more valuable than a sophisticated one that is abandoned halfway.

Summary

What we covered today:

Core purpose of folder planning: make both storing and finding smooth, not for looks
Popular methods to be aware of: PARA and Zettelkasten each have their use cases, but maintenance costs are high for average users
My approach: 5 folders + 1 rule:
- 00-Inbox: everything comes in first, process regularly
- 01-Notes: flat layout, no categories
- 04-Output: complete content for external audiences
- 07-Diary: separate, don’t mix with notes
- Project folders: create as needed, archive when done
The golden rule of the inbox: things that come in must be processed regularly, no infinite accumulation

Key takeaways:

In the AI era, search is more important than classification—lay notes flat and let AI find them, more efficient than manual hierarchy maintenance
The simpler the system, the easier to stick with it—a simple structure that works beats a sophisticated but abandoned one
The inbox is an entry point, not a warehouse—regular emptying keeps the whole workflow running

Fonts: The Hidden Upgrade for Reading Comfort

Mon, 01 Jan 0001 00:00:00 +0000

We previously covered CSS Snippets, teaching you how to use a small piece of code to fine-tune various details of the Obsidian interface. This chapter is the final part of our beautification trilogy—changing fonts.

The topic of fonts is both simple and significant—it’s just changing a font, after all. But after you change it, you’ll likely have a reaction: “So I’ve been settling all along.” A good font doesn’t just make the interface flashier; it makes your eyes less tired every time you open Obsidian, reading smoother, and makes you want to write more.

This chapter covers four things:

Fonts have copyrights—how to use them safely
Where to download free fonts
How to install them into Obsidian after downloading
What font I use myself, and its confusing name

Fonts Have Copyrights

First, something many people don’t know: Fonts have copyrights.

If you search for a font name online, download it, install it, and use it for yourself, no one will bother you. But if you use that font in a commercial project—like product UI, printed promotional materials, or in released software—you could be infringing copyright.

Among Chinese fonts, there are many that “look free but actually have strict copyrights.” Companies like FounderType and Hanyi have specific licensing systems: free for personal use, paid for commercial use. Some designers and programmers, unaware of this, directly bundle fonts into projects and end up receiving legal letters.

But for taking notes in Obsidian, which is almost never a commercial use, any font is fine.

I bring this up to instill a habit: prioritize free and open-source fonts. You can use them without any legal worries, even for commercial purposes, and you can tinker with them freely.

Open-source fonts typically use the SIL Open Font License (SIL OFL) — this license means the font is free, can be used for personal and commercial purposes, and can even be modified and redistributed, with the only requirement being that modifications must also be open-sourced under the same license.

Choosing a font with SIL OFL is like choosing “permanently free and worry-free.”

Where to Download Fonts

After discussing copyright, let’s talk about download sources.

First recommendation: Maoken.com

Website: maoken.com

This is a Chinese website dedicated to cataloging free Chinese fonts. It features hundreds of free-to-use commercial Chinese fonts, each with preview images and license information. If you don’t know what to choose, just browse here and you’ll easily find something you like.

Second recommendation: GitHub

Many open-source fonts are released directly on GitHub. For example, the font I’ll recommend below, LXGW WenKai, is in the lxgw/LxgwWenKai repository on GitHub. Go to the Releases page and download the packaged font archive directly.

Accessing GitHub from China can sometimes be slow. You can use a Gitee mirror or go directly to Maoken.com, as many open-source fonts are also collected there.

Format Notes

Common font file formats:

.ttf (TrueType Font): Most universal, supported on both Mac and Windows
.otf (OpenType Font): Newer format, slightly more features, also supported on Mac/Windows

Either works; you can use either without worry.

How to Install Fonts into Obsidian

After downloading the font, there are two steps: first install it on your system, then tell Obsidian to use it.

Step 1: Install the font on your system

On Mac, double-click the downloaded .ttf or .otf file. A font preview window will appear. Click the “Install Font” button in the top-left corner. Done.

Alternatively, you can drag the font file directly into the Font Book application to install it.

On Windows, right-click the font file and select “Install” or “Install for all users”. Done.

Once installed, the font is in the system font library and can be used by all software.

Step 2: Enable the font in Obsidian

Obsidian has two ways to switch fonts: one is using the interface settings, and the other is using a CSS Snippet.

Method 1: Interface Settings (Simple, recommended to try first)

Path: Settings → Appearance → Fonts

There are three input fields:

Interface font: Font used for interface elements like sidebar, menus, title bar
Text font: Font used for note content (this is the most commonly changed)
Monospace font: Monospace font used for code blocks

In the “Text font” field, directly enter the font name, e.g., LXGW WenKai, press Enter, and Obsidian will immediately switch to it.

The font name must be the English name, with correct capitalization. This is the “official name” after the font is installed on the system, not the Chinese display name.

How to find the English name of a font? On Mac, open Font Book, find the font, and the displayed name is the English name. On Windows, check in Control Panel → Fonts.

Method 2: CSS Snippet (More flexible, suitable for fine control)

In your CSS Snippet file, add these lines:

/* Set fonts */
body {
  --font-text-theme: "LXGW WenKai", "LXGW WenKai CN", serif;     /* Text font */
  --font-interface-theme: "LXGW WenKai", "LXGW WenKai CN", sans-serif; /* Interface font */
}

--font-text-theme controls the text font, --font-interface-theme controls the interface font. Just combine them in one body {} block.

Put these lines into a .css file, save it to the .obsidian/snippets/ directory, and enable it in Settings → Appearance → CSS snippets.

Both methods have similar effects. Interface settings are more straightforward, while the CSS method is more flexible and can be combined with other snippets for management. For daily use, interface settings are sufficient.

My Choice: LXGW WenKai

After covering the methods, let me share my own choice: LXGW WenKai.

The name is a bit hard to remember in Chinese, but after installing it, the Chinese reading experience is quite good. It has a bit of a handwritten regular script feel, not rigid, and easy on the eyes even after long reading sessions.

License: SIL OFL 1.1, completely free for commercial use, no copyright worries.

Download: GitHub lxgw/LxgwWenKai https://github.com/lxgw/LxgwWenKai/releases

The creator also has a Bilibili account under the same LXGW name.

Summary

What we learned today:

Fonts have copyrights; personal note-taking in Obsidian is fine, but for commercial projects, prioritize SIL OFL free fonts.
Recommended download sources: Maoken.com (specializing in free Chinese fonts), GitHub.
Font installation process: double-click .ttf/.otf file to install on system → reference in Obsidian.
Changing fonts in Obsidian: Settings → Appearance → Text font, directly enter the font’s English name.
Advanced method: use the --font-text-theme variable in a CSS Snippet to set the font.
Recommended font: LXGW WenKai, free for commercial use, great Chinese reading experience.

Key takeaways:

Install on system first, then enter the font name. Two steps, no hassle.
Make sure to enter the font’s English name correctly, paying attention to capitalization.
If you don’t know which font to choose, browse Maoken.com first.
LXGW WenKai is what I currently use; the name is hard to remember, but the font is beautiful.

How to Save Web Pages to Obsidian with Web Clipper

Mon, 01 Jan 0001 00:00:00 +0000

We’ve covered templates—using variables to auto-fill dates and titles, and applying formats with one click when creating new notes. Now let’s take it a step further.

Taking notes isn’t enough. Every day you browse Twitter, read WeChat articles, and scroll Reddit. When you find something good, how do you save it? Screenshot? It becomes an image, unsearchable. Copy-paste? The formatting is a mess, and you have to manually add the title and link. Throw it into browser bookmarks? That’s the eternal resting place for bookmarks: stuff goes in but never comes out, and you never look at them again.

This chapter solves that problem: how to quickly and cleanly save web content into Obsidian. The tool is Obsidian’s official browser extension—Web Clipper.

Why Use Web Clipper

Before Web Clipper, I went through roughly three stages of saving web articles:

First stage: screenshot. One click, throw it into notes. Problem: screenshots aren’t searchable. Three months later, you have no idea what you captured, let alone find it.

Second stage: copy-paste. Copy the text into Obsidian, then manually add the title and source link. Problem: formatting is mostly messed up—headings become body text, bold disappears, code blocks become plain text. It takes minutes to clean up each time.

Third stage: bookmarks. Click the star in the browser, easiest. The cost: you’ll never open those links again.

Web Clipper’s logic: one-click save, clean formatting, automatic metadata, directly into Obsidian. Title, original link, save date—all auto-filled. Content is in Markdown format, images are preserved. With the AI Interpreter, you can even have AI summarize the content while clipping.

Installation

Web Clipper is a browser extension. It currently supports Chrome, Edge, Firefox, and Safari (some features may differ).

Important: WeChat articles need to be opened in a browser first; you can’t use them directly in the WeChat client. The WeChat client is a separate environment that browser extensions can’t access. You need to copy the link, open it in Chrome or Edge, then clip.

Installation Steps

Step 1: Chrome users open the Chrome Web Store, search for “Obsidian Web Clipper”, find the official extension (icon same as Obsidian, the gem pattern), click “Add to Chrome”.

Step 2: Edge users similarly open the Edge Add-ons store, search for “Obsidian Web Clipper”, install. Edge can also use the version from Chrome Web Store, either works.

Step 3: After installation, the extension icon appears in the top-right toolbar. If not visible, click the puzzle piece icon (Extensions) on the far right of the toolbar, find Obsidian Web Clipper, and pin it to the toolbar.

That’s it for installation.

Basic Settings

Click the extension icon in the toolbar to open the clipping panel. There’s a small gear icon in the bottom right—that’s the settings entry. Go into settings and configure the basics.

Connect Your Obsidian Vault

First thing in settings is to connect your Vault. In the “Vaults” section, click “Add vault”, enter your vault name—the one displayed in the bottom-left corner of Obsidian. For example, my vault is called “Obsidian Vault”, so I enter that.

Note: On first connection, Obsidian will pop up an authorization window asking if you allow Web Clipper to access it. Select “Allow”—this is a normal security prompt.

Set Default Storage Folder

After connecting the vault, set the Default location.

It’s recommended to create a dedicated inbox folder, like 00-Inbox or Inbox, specifically for clipped content. Don’t dump it directly into the vault root—over time the root will become messy, and you won’t know which notes are organized and which are unprocessed web archives.

Interface Overview

After setup, each time you open the extension, you’ll see three main areas:

Top: Properties area—automatically identifies the current page’s title, URL, author (if available)
Middle: Content preview area—the body has been converted to Markdown
Bottom: Action area—choose which vault and folder to save to, select a template, then click “Clip” to save

AI Interpreter

This is the feature worth spending the most time configuring in Web Clipper.

What It Is

The AI Interpreter lets you write instructions in a template, and when clipping, click the “Add to Obsidian” button, and AI will process the specified content. For example: summarize the full text, extract keywords, translate… What it can do depends on how you write the prompt.

This feature requires an API Key. If you already have an API key from OpenAI, DeepSeek, or Anthropic, you can use it directly; if not, register on the respective platform.

Configuration

Go to settings, find the “Interpreter” tab.

Step 1: Select your model source and enter the corresponding API Key. Supports OpenAI, Anthropic (Claude), Ollama (local models), and more. I use DeepSeek—I find it best for summarizing articles.

Step 2: Enable “Enable Interpreter”, turn this switch on.

After that, write prompt variables in your template, and when clipping, an interpreter area will appear in the extension window—click to trigger it.

Create Custom Templates

Web Clipper comes with a default template—it works, but it’s not great. Spend a few minutes creating your own template, and every clip will be much more comfortable.

Why Customize Templates

Different types of content require different information:

Technical articles: you want title, link, AI summary, body
WeChat articles: you want title, author, publication date, AI summary
Product pages: you want title, price, link, no need for full text

One template can’t cover all scenarios. Create a few templates based on content type, and select the appropriate one when clipping—very convenient.

Access Template Settings

In Web Clipper settings, click “New Template” on the left to create a new one. I’m lazy so I only use one.

Give the template a name, like “Article Collection”, then start writing the content.

Template Variables

Web Clipper supports two types of variables:

Page variables—automatically extracted from the current webpage:

Variable	Description
`{{title}}`	Page title
`{{url}}`	Current page URL
`{{author}}`	Article author (if recognized)
`{{date}}`	Today’s date
`{{content}}`	Body content (Markdown format)

Interpreter variables—call AI in properties or content:

The interpreter syntax is straightforward: put the instruction you want to give AI in double quotes, wrapped in double curly braces, like this:

{{"Summarize the full article without using an H1 heading"}}

The inner text is your instruction to AI; the outer {{" "}} format should not be changed. Web Clipper recognizes this syntax and knows to call AI for processing when clipping.

Both properties and content can use it. If you want a property field to be auto-filled by AI, write this format in the property value; if you want to insert an AI summary in the content, write it there as well.

Complete Template Example

Here’s the template I use:

Template Properties:

URL: {{url}}
Saved: {{date}}

Template Content:


# Summary

There’s one thing worth mentioning: the author line uses {{author|split:", "|wikilink|join}}, not the plain {{author}}. This is a variable + filter combination—first split the author field by comma (some articles recognize multiple authors), then convert each name into Obsidian wiki-link format [[Author Name]], and finally join them back. This way, after clipping, clicking the author name jumps to the corresponding note. You don’t have to use this; {{author}} outputting plain text is perfectly fine, depending on your preference.

For the content area, I only left two empty lines: Topic Category/Link for manually adding related information, and # Summary as a heading placeholder—if you have the interpreter enabled, you can add {{"Summarize the full article without using an H1 heading"}} below it to let AI auto-fill the content; if not, you can write a couple of sentences manually after clipping.

Practice: Clipping an Article

All settings are done, let’s actually use it.

Suppose you see a WeChat article you like and want to save it.

Step 1: Copy the link and open it in a browser. In the WeChat article, tap the top-right menu and select “Open in default browser”.

Step 2: Click the Web Clipper icon. The gem icon in the top-right toolbar, click it to open the clipping panel.

Step 3: Check the properties. The panel will automatically recognize the article title and URL. If the author field isn’t recognized, fill it in manually. The date is today, no need to change.

Step 4: Select a template. Choose the “Article Collection” template you created. If you have the AI interpreter enabled, you’ll see a spinning animation—AI is generating the summary, wait for it to finish.

Step 5: Click “Add to Obsidian”. One second later, open Obsidian, go to your inbox folder, and the article is there. Title, link, date, AI summary—all present, and the content is clean Markdown.

Summary

What you learned today:

Web Clipper is Obsidian’s official browser extension that saves web pages as Obsidian notes with one click, clean formatting, and automatic metadata.
WeChat articles must be opened in a browser to be clipped; they can’t be used in the WeChat client.
The AI Interpreter requires an API Key; once configured, it can automatically generate summaries and extract information during clipping.
Custom templates = property variables + AI prompts; different templates for different content types make clipping more efficient.

Key points:

Create a dedicated inbox folder; don’t dump clipped content directly into the vault root.
First get the workflow working with the default template, then spend time customizing—templates can be changed anytime; getting started is more important.
AI summaries are a bonus, not a necessity—you can clip normally without an API Key; you just miss the AI processing step.

Image Hosting with PicList and Tencent Cloud

Mon, 01 Jan 0001 00:00:00 +0000

As the final chapter of the introductory section, we’ll set up image hosting. We briefly touched on this in Chapter 02 when discussing inserting images—upload images to the cloud, keep your local repository lightweight, and images will automatically follow your articles when you publish. This chapter covers it in depth.

An “image hosting service” stores your images on a cloud server and uses external links to reference them, rather than keeping them as local attachments. This has several benefits: first, your local repository stays lightweight and doesn’t bloat with a bunch of images; second, images have a permanent web link, making it easy to publish your articles to blogs, WeChat Official Accounts, and other platforms without re-uploading images.

However, there’s one important caveat: do not use image hosting for screenshots containing private information or API keys. Images on an image hosting service are publicly accessible, and leaks can be troublesome.

Tools Needed

To configure image hosting, you need two things:

Image auto upload: An Obsidian plugin. You can search for and install it directly from the community plugin marketplace.
PicList: Image hosting management software. Download and install it from https://piclist.cn/.

Once both are installed, we can start configuring.

Which Image Hosting to Choose?

There are many options for image hosting. In this tutorial, I’ll demonstrate Tencent Cloud because its interface is intuitive and suitable for beginners. However, I personally use Cloudflare R2 daily because it’s completely free and offers fast image loading worldwide. If you want to go completely zero-cost, GitHub can also serve as an image hosting service—just push images to a repository and reference them using raw links. All three are viable options. Today, we’ll focus on Tencent Cloud, but the configuration logic is the same for others—just change the image hosting type in PicList.

Step 1: Tencent Cloud COS Configuration

First, go to https://cloud.tencent.com/ and register an account. Then click “Console” in the top right corner.

After entering the console, search for “Object Storage” at the top or find it in the left menu.

Click “Create Bucket”.

Start configuring. For Region, select the one closest to you (for example, I’m in Shanghai, so I choose “Shanghai”). For Name, pick any name you like; I used obsidian-test. For Access Permissions, make sure to select “Public Read, Private Write”, otherwise others won’t be able to access your images. Check all the necessary boxes below, then click “Next”.

I left all advanced settings at their defaults and clicked “Next”.

Confirm the configuration is correct, then click “Create”.

After creation, you’ll see this page indicating the bucket has been created. We’ll leave it for now.

Next, create an API key so PicList has permission to upload images to your bucket. Go to https://console.cloud.tencent.com/cam/capi and click “Create Key”. A security prompt will appear—just confirm it.

After creation, you’ll see your SecretId and SecretKey. Save these, along with your AppID and bucket name, locally immediately. Do not share them with anyone.

Step 2: Configure PicList

Open PicList, select “Image Hosting” on the left, then click “Add”.

A configuration form will appear. For “Configuration Name”, you can enter any name you like. Fill in the other fields with the information you saved earlier: AppID, SecretId, SecretKey, and Bucket Name. One important thing: the region must be entered in pinyin format. For example, for Shanghai, use ap-shanghai; for Guangzhou, use ap-guangzhou. Do not use Chinese characters.

If you encounter issues after configuration, refer to the official documentation at https://piclist.cn/configure.html to check your parameters.

After configuration, it’s recommended to manually upload a test image in PicList first to confirm the image hosting works properly before using it in Obsidian. Troubleshooting is much more cumbersome if you only discover issues in Obsidian.

Step 3: Configure the Image Auto Upload Plugin

Open the Image auto upload plugin settings in Obsidian. Set the image hosting type to “PicGo”, then fill in the two API endpoints:

Upload endpoint: http://127.0.0.1:36677/upload
Delete endpoint: http://127.0.0.1:36677/delete

I’m not sure if selecting PicGo automatically fills these in, so I’m including them here. You can refer to my screenshot for other settings.

How to Use

Once configured, just take screenshots and insert local images as usual while writing—no need to worry about the image hosting. After you finish writing and reviewing your article, use the command palette to search for “Upload all images”. This will upload all local images in the article to the image hosting service in one click. The links will be automatically replaced, and the original local attachments will be deleted.

One common pitfall: if your article contains both images already uploaded to the image hosting service and newly added local images, it’s recommended to first click “Download all images” to download the hosted images back, then click “Upload all images” to upload everything together. If you upload directly, you might encounter image misalignment issues.

Note for WeChat Official Account Users

There’s an important point to clarify: Obsidian writes in Markdown, but the WeChat Official Account backend does not support Markdown. If you copy content directly, the formatting will be completely messed up, and images won’t display—not because the image hosting links are blocked, but because there’s no rendering at all.

There are two solutions. One is to use an online formatting tool like doocs-md: paste your Obsidian content into it, and it will render the Markdown into a format that the WeChat backend recognizes. Then copy it to the WeChat backend, and images will display correctly. The other is to use my WeChat Publisher plugin, which works directly within Obsidian. It supports one-click draft pushing after rendering, or you can manually copy the rendered content. See Chapter 20 of this book for details. Starting from v0.1.13, it is completely free for individual users.

Summary

Image hosting is a broad topic, and there are many things we didn’t cover in this chapter, such as image format conversion, automatic naming rules, binding custom domains, and more. However, with the configuration outlined in this chapter, you should be able to get started and explore further on your own.

What you learned today:

Image hosting stores images in the cloud, keeping your Obsidian vault lightweight and making it easy to publish to blogs.
You need to install the Image auto upload plugin and PicList software. Image hosting options include Tencent Cloud, Cloudflare, or GitHub.
After configuration, manually test uploading an image in PicList first to ensure everything works before using it in Obsidian.
Insert local images as usual while writing, then upload all images to the image hosting service with one click after finishing; links are automatically replaced.

Key points:

Do not upload screenshots containing private information or API keys to image hosting.
The bucket must be set to “Public Read”, otherwise images cannot be publicly accessed.
API keys (SecretId/SecretKey) must be saved locally and not shared.
The region must be entered in pinyin format, e.g., ap-shanghai.
If your article contains both hosted and local images, download all first, then upload together.
WeChat Official Account users: WeChat blocks external image links. Use doocs-md to convert or my plugin for one-click processing.

Local Backup: The Best Backup Plugin for Beginners

Mon, 01 Jan 0001 00:00:00 +0000

Friends, today let’s talk about backing up Obsidian.

The importance of backups goes without saying—they prevent accidental deletions and slip-ups, especially now that many operations are AI-driven. If something goes wrong, it can trigger a chain reaction. Backups can help you recover partially or even completely.

Backup Options

There are two main approaches: local backup and cloud backup.

Local backup means exactly what it sounds like: you create one or more copies in another folder on your local computer, which you can restore whenever needed. Common methods include manually copying files, using plugins, or using tools like Kopia.
Cloud backup stores your backups in the cloud, including but not limited to your NAS, VPS, GitHub, or services like Cloudflare.

As for me, I choose both. My documents are backed up locally and to the cloud every morning at 9 AM—double protection!

But today, we’ll start with the most beginner-friendly method: using the Local Backup plugin for local backups.

How to Use the Plugin

As mentioned earlier, open the official plugin marketplace, search for the plugin, and install it.

Then open the plugin settings. Note that a corresponding icon also appears on the left sidebar for quick access.

Seeing a bunch of English might be intimidating? Don’t worry—I’ve translated everything for you. Pretty thoughtful, right? 😊

The settings are straightforward. Just choose what you need. If you’re unsure, you can refer to my configuration: backup on every Obsidian exit, keep backups for the last 7 days (auto-delete old ones), and save a maximum of 2 backups per day.

Also, remember to set the backup path according to your system; otherwise, it will default to your vault directory.

Once configured, click the icon on the left to test if it works. You can see that a backup has been successfully created.

If you see a green notification or a new backup file in the target folder, the configuration is successful.

Common Issues

Also, note that I encountered an error before because my vault folder contained a virtual environment.

The solution is simple: add exclusion patterns in the option shown in the screenshot. If you’re not sure, you can copy my list:

.venv, __pycache__, node_modules, .git, .trash

Tip: Convert PDFs to Markdown to Reduce Backup Size

If your backup package keeps growing, first check if you’ve added a lot of PDFs to your vault.

PDF files are large, so having many of them will bloat your backups. Converting reference PDFs to Markdown preserves the content while significantly reducing backup size. For example, a 504KB PDF becomes only 13KB after conversion (the ratio varies by file).

And don’t worry about images—the conversion tool automatically inserts them as image hosting links.

Currently, there are free online tools available:

Usage is simple: just drag and drop the PDF to convert it.

After conversion, the left side shows the original, and the right side shows the converted format. Click the download button on the right to save it locally.

You can see the original PDF is 504KB, while the converted version is only 13KB.

The image below compares the PDF and Markdown versions—they look very similar.

Note that these images are hosted on the website’s own image hosting service, and it’s uncertain how long they will be preserved. It is recommended to migrate them to your own image hosting as described in the chapter on image hosting, so that even if the website removes their hosting, your usage won’t be affected.

When taking notes, you can use a split-screen view: open the same document on both sides, viewing the converted Markdown on one side while writing notes on the other. A dual-monitor setup makes this even more convenient.

Summary

What we learned today:

Local Backup is the simplest local backup plugin for Obsidian—just install it, set the path, and it works without any command line.
Only three steps to set up: Install the plugin → Set the backup path and rules → Click the left icon to verify.
Test before you rely on it—click “Try” to confirm the path is writable. Don’t wait until you lose data to verify.
Common error fix: Check the exclusion list and add temporary directories like .venv, node_modules, .git, etc.

Key takeaways:

Local backup + cloud backup for double protection—this is the most reliable approach.
Beginners can start with local backup only—no need to dive into NAS or GitHub sync right away.
Verify once before relying on backups to ensure the path and exclusions are correct.

Part 2 · Workflow: Make You Open It Every Day

Obsidian Base: Build Your Own Gallery and Data Table

Mon, 01 Jan 0001 00:00:00 +0000

Many people used to compare Obsidian and Notion, and the biggest regret was often this: Obsidian is free, but it always felt lacking in tables, cards, and databases.

In the past, if you wanted to build a decent database in Obsidian, you usually had to rely on plugins or manually cobble together properties and Dataview. It was possible, but the barrier was high. Now the official Base feature has largely filled that gap.

It hasn’t turned Obsidian into another Notion, but it’s enough to let you create tables, lists, card libraries, movie galleries, media libraries and more in your own vault.

This article will explain what Base is, how to create one, and the two most practical and beginner-friendly directions: making tables and making a movie gallery.

What is Base?

First, the most important point: Base doesn’t turn your notes into a mysterious new system; it adds a database view layer to your existing Markdown files.

Its file format is .base, which you can think of as a “database configuration file”. The file defines:

Which notes to display
Which view to use
How to filter
How to sort
Which properties to show

That is, your data is still those Markdown files; Base just organizes them in a more intuitive way.

This is also where it differs greatly from Notion.

Notion’s database is essentially the database itself; while Obsidian’s Base is essentially still file-oriented. A row, a card, an entry you see usually corresponds to a real file.

This has pros and cons:

The benefit is that your content is still local, in your own folders, not locked into a platform.

The cost is that it’s better suited for databases, lists, reading lists, media libraries, project lists, but if you want to use it for a system that “records every second with complex structure”, you’ll need to adjust your approach a bit.

How to Create a Base?

Creating one is actually very simple. Right-click on a folder in the left file explorer, and you’ll see a new option: New database.

After clicking, Obsidian will generate a .base file. This file is not your data itself, but the “instruction manual” for this database view.

This step is important because many first-time users mistakenly think they are “creating a table”. Actually, you are not. You are creating a new way to view files.

For example, if you create a Base in a folder, it will often pull in many notes from the scope. Don’t panic. The next step is not to enter data, but to learn how to control it.

Once you understand these buttons in the top right, you’ve basically got the hang of Base:

Sort: Decide what to see first
Filter: Decide what enters this view. For example, which folder’s files this database displays is set here; otherwise, by default, all notes might come in.
Properties: Decide what this column shows
Search: Search within the current Base results
New: Add a new entry directly to this Base

How I Use Base?

For demonstration, I created a Demo-Base.base file with three most common views:

Table
Card
List

This approach is actually great for daily use. Because most of the time, we don’t need a “super complex database”; we need: the same set of content, viewed in different ways for different scenarios.

For example, when organizing article materials, tables are good for batch viewing properties; when making a media library, cards are most intuitive; when you just want to quickly scan titles, lists are fastest.

First, the Most Practical: Table View

The table view is the easiest to understand; it essentially arranges a bunch of notes in rows and columns.

It’s very similar to Excel, and also to the classic table database view in Notion.

This mode is especially good for:

Viewing titles, dates, tags, categories of files
Batch checking if properties are filled correctly
Quick sorting, e.g., by date, rating, priority
Doing lightweight data management, like book lists, project lists, expense records

If you’re new to Base, I suggest not thinking about formulas, links, complex structures yet. First, get familiar with the three functions: filter, sort, and property display.

Because the most valuable thing about Base right now is not showing off skills, but finally allowing you to manage content in a more human-friendly way in Obsidian.

List View: The Most Plain, But Also the Fastest

Many people overlook the list view because it doesn’t look as professional as a table or as fancy as cards. But it has a huge advantage: lightweight.

When you just want to quickly browse a batch of file titles, or scan through content based on filter results, the list view is actually the most convenient.

It’s especially good for:

Scanning what you’ve written recently
Seeing which articles are under a certain tag
Quickly checking if a folder has unwanted content
Using it as a “search results page”

Sometimes the simpler the tool, the more frequently it’s used. The list view is that kind of thing.

Card View: This Is Where It’s Most Like Notion

If the table view solves the “management problem”, then the card view solves the “display problem”.

Looking at this interface, you can immediately feel that it’s different from the old Obsidian. Once the cards are laid out, the entire vault’s content instantly transforms from a “file list” to a “content panel”.

This mode is especially good for:

Movie library
Book library
Image library
Project kanban-style browsing
Article topic pool

Personally, I think the most valuable part of Base is not the table, but the card. Because many tools can do tables, but what Obsidian previously lacked most was this ability to “turn notes into a visual material library”.

If you want to make a movie gallery similar to Notion, the idea is simple:

Each movie gets its own note
Add a few basic properties to each note
Specifically prepare a “Cover” property to hold the poster image
Then in the card view, set the cover image source to this “Cover” property

The result will be very close to Notion’s gallery-style display.

Complete Hands-on Example: Build a Movie Gallery from Scratch

I’ll use the example I just made. The files are very simple, just two:

The Shawshank Redemption.md
Farewell My Concubine.md

The goal is clear: Make these two notes display as two movie cards with posters in Base.

Step 1: Prepare Two Movie Notes

The simplest way is one file per movie. For example, create two notes in 00-Inbox:

The Shawshank Redemption
Farewell My Concubine

Don’t worry about writing long content at this step; even if the file only has a title, it’s fine. For Base, the most important thing is not the body, but properties.

Step 2: Add “Cover” and “Category” Properties to the Notes

Open one of the notes, e.g., Farewell My Concubine.md, then in the “Note Properties” area at the top, add two properties:

Cover
Category

Where:

Cover is for the movie poster
Category is to mark it as “Movie”

You can do this directly in Obsidian by clicking “Add note property”, no need to write YAML manually.

Here’s a point where beginners often get stuck, so let me be clear: The poster in the card view doesn’t look at regular images inserted in the body; it looks at the image in the property.

In other words, if you just insert the poster into the body, Base may not treat it as the card cover; but if you put the poster into the Cover property, it will reliably read it.

For example, this movie note essentially ends up with this structure:

---
Cover: "[[05-Archive/Gallery/PixPin_2026-04-02_10-05-21.webp]]"
Category:
  - Movie
---

You don’t have to write it manually like this, because Obsidian’s property panel will do it for you. But knowing what it looks like underneath will make troubleshooting easier later.

Step 3: Create a Dedicated Base File

Then right-click in the left folder, create a new database, and you’ll get a .base file. I’m using Demo-Base.base here.

You can think of this file as the “exhibition hall itself”, while the two movie notes are the “exhibits”. Base is responsible for display; the actual data is still stored in their respective Markdown notes.

Step 4: Narrow Down the Scope to Only These Two Movies

Many people have a problem when first using Base: when they open it, all notes from the entire vault come in. So this step is essential—filter the scope first.

You can click “Filter” in the top right of Base to keep only the content you want to show. For example:

Only notes in a certain folder
Only notes with a certain tag
Only notes where category equals “Movie”
Or, like in my demo, directly only these two specific files

For beginners, I recommend using “folder scope” or “category = Movie” first, as they are more intuitive.

Step 5: Switch to Card View and Specify the Cover Source

This is the most critical step. After switching to card view, you need to tell Base: Which property’s image should be used for the card cover.

Here, select the Cover we created earlier.

As long as this step is correct, the cards will instantly transform from plain text blocks into a real movie poster gallery.

Here’s another point that can easily confuse beginners. When you click “Properties” in the top right, you’re selecting which fields to display below the card, like Name, Category, etc. But whether the poster shows or not is not controlled here.

The poster is part of the card cover, and its source is the Cover property you specified separately in the card view. So even if you don’t check Cover in the “Properties” menu, the poster above will still display normally.

In other words, there are two sets of settings:

Cover: Controls the poster at the top of the card
Name, Category: Control the text information displayed below the card

See, at this point, Farewell My Concubine and The Shawshank Redemption have become a movie gallery very similar to Notion. The top of the card shows the poster, and the bottom shows the file name and properties. Even if you only have two movies now, you can already see the value of this pattern—as you add more movies later, the whole library will grow into a real media archive.

Step 6: What Else Can You Add Later?

Once you’ve got “Cover + Category” working, the rest is simple. You can continue to add these properties to each movie:

Year
Director
Country/Region
Rating
Watched or not
Rewatch count
One-line review

Then:

The card view handles “looking good”
The table view handles “easy management”

This is the most comfortable way to use Base: Separate display and management for the same set of content.

Why Is This Example Suitable for Beginners?

Because it has almost no barrier. You don’t need to learn formulas first, don’t need to learn Dataview first, don’t need to fiddle with complex templates. You only need to understand three things:

One movie = one note
Don’t just put the poster in the body; put it in a property
The card view’s poster source must be set to the “Cover” property

Once you understand these three things, movie libraries, book libraries, game libraries, travel photo libraries—they all follow the same pattern.

And because the underlying files are still Markdown, your movie library is essentially not locked in a database, but a real set of local notes. Later, if you want to migrate, back up, or hand over to AI for processing, it’s much more comfortable than a closed platform.

Filter, Sort, Properties: These Three Are the Core of Base

Many people, when first opening Base, stare at the “Table / Card / List” view switchers for a long time. But what really determines whether this thing is useful is not the view itself, but the three buttons in the top right:

Filter: Decides who comes in
Sort: Decides who you see first
Properties: Decides what you see

Once you understand these three, Base will transform from a “new feature” into a “tool that really works”.

For example, in my demo, the card view is great for a content gallery, so you can use filters to exclude certain folders and keep only the content suitable for display. This makes the cards look much cleaner.

The table view, on the other hand, is better for exposing fields, making it easy to batch check and adjust.

In other words: The same set of files, different views are not duplication, but division of labor.

This is where Base is most like Notion, yet still very Obsidian.

Can You Use It for a Ledger?

Yes, but in my opinion: It can be done, but it may not be the most comfortable.

If your ledger habit is “one record equals one independent entry”, then Base is suitable. You can add properties like amount, date, category, payment method to each record, then filter, sort, and calculate in the table. The logic works.

But if you’re used to recording a continuous stream in one Markdown file, then Base is less convenient. Because many of Base’s features assume: one row of content corresponds to one file.

So for me, it’s currently better for:

Image libraries
Book libraries
Movie libraries
Article material pools
Project lists

Rather than high-frequency transaction logs. This is also my long-standing view on Obsidian: Don’t try to go all-in-one from the start.

Base is certainly powerful, but the best way to use it is not to force it to replace everything, but to put it in its proper place.

How I Suggest You Start Using It

If you haven’t used Base yet, I suggest not building a huge system right away. The best way to get started is actually two things:

First, make a gallery. For example, movies, books, article covers, travel photos, collection materials—these are all great for card view. You’ll immediately understand Base’s value.

Second, make a lightweight table. For example, project lists, materials to organize, reading records. Then you’ll naturally use sorting, filtering, and property display.

Once you’ve run through these two scenarios, you’ll basically know Base.

Summary

With the release of Base, Obsidian is no longer just a “note-taking app that can write Markdown”; it has begun to have a bit of a real database feel. But its core advantage is not to compete with Notion on who is more like a database, but: It gives your local files, for the first time, a sufficiently convenient database view.

This is very important. Because before, many contents were not unmanageable, but hard to manage; not unviewable, but hard to view. Now with Base, many scenarios that previously required plugins can finally be done directly.

What we learned today:

The essence of Base is adding a database view layer to existing Markdown files
Creating one is simple: right-click a folder on the left to create a new database
The most important thing about Base is not flashiness, but the three core operations: filter, sort, and properties
Tables are good for management, lists for quick browsing, and cards are best for movie galleries and media libraries
It’s great for display-oriented databases, but not necessarily for all high-frequency transaction scenarios

Key points:

The .base file itself is not data, but a database view configuration
A row of content usually corresponds to a real note file
The card view is the closest to Notion’s gallery effect
To get started fastest, first make a movie gallery, then a lightweight table
Don’t think about all-in-one from the start; first use Base for the scenarios it’s best suited for

Obsidian Canvas: Organize Ideas Visually

Mon, 01 Jan 0001 00:00:00 +0000

We’ve covered folder planning—using a few simple folders to run a note-taking system. Now, let’s explore another core plugin that comes with Obsidian: Canvas.

What is Canvas, What It’s Good For, and What It’s Not

Simply put, Canvas is an infinite canvas.

Regular notes are linear—you write from top to bottom, with content in a sequential order. Canvas is different; it’s two-dimensional, with no boundaries. You can drag in notes, images, web links, and text cards, then use lines to establish relationships between them.

Scenarios where Canvas is useful:

Complex project breakdown: Break a large goal into multiple sub-tasks, using lines to indicate dependencies
Knowledge relationship map: When there are too many concepts in a field, use Canvas to see how they connect
Visual book notes: A book’s core arguments, supporting cases, and counterpoints are much more intuitive when laid out compared to linear notes
Flowcharts / Architecture diagrams: Product flows, technical architectures, workflows—drawing them is easier to understand than writing them

Scenarios where Canvas is not suitable:

Use regular notes for linear content. Don’t use Canvas just for the sake of using it.

If you’re writing an article, taking meeting minutes, or organizing a list—just use .md files. Opening Canvas adds an extra layer of operation. The value of Canvas lies in content that requires spatial awareness; only use it when there are complex relationships between content.

Enabling the Canvas Core Plugin

Canvas is a built-in core plugin in Obsidian, so no installation is needed. It’s disabled by default, so you need to enable it manually.

Path: Settings → Core Plugins → Find “Canvas” → Toggle the switch on the right.

After enabling, a Canvas icon will appear in the left sidebar. Click it to create a new Canvas file.

Creating and Using Canvas

How to Create a New Canvas

There are three ways:

Command Palette: Cmd+P (Mac) or Ctrl+P (Windows), search for “New Canvas”, press Enter
Left Sidebar: After enabling the Canvas plugin, the Canvas icon appears in the left sidebar; click it to create a new one

After creation, a .canvas file is generated (more on this later).

Common Operations and Shortcuts

The operation logic of Canvas is similar to regular drawing software, so it’s easy to pick up:

Operation	Shortcut
Create a new text card	Double-click on empty space
Exit card editing	Esc
Pan the canvas	Space + drag, or middle mouse button drag
Zoom the canvas	Ctrl/Cmd + mouse wheel
Fit all content to screen	Shift+1
Fit selected content to screen	Shift+2
Delete a card	Select and press Backspace or Delete
Connect two cards	Hover over the edge of a card, drag from the dot that appears

The most common two are: double-click to create a card, and drag from the edge dot to connect.

Keyboard Workflow: Creating Branches Without Leaving the Keyboard

Canvas also supports a pure keyboard workflow, ideal for quickly brainstorming and creating branches continuously.

Basic navigation (when not in edit mode):

Operation	Shortcut
Switch selection to next/previous card	Tab / Shift+Tab
Move to an adjacent connected card	← → ↑ ↓
Enter edit mode for the selected card	Enter
Exit edit mode, return to card selection	Esc
Select all cards	Ctrl/Cmd + A
Delete selected card	Backspace or Delete

Creating branches: Select a card (not in edit mode), then move the mouse to the edge of the card. There are circular connection points on all four sides. Drag one to an empty area—not onto an existing card, but into the blank space—release, and a menu will appear. Select “New text card”, and the new card is automatically created and connected to the current card.

Keyboard + mouse workflow for creating multiple parallel branches:

Double-click on empty space to create a parent card, enter content, press Esc to exit editing
With the card selected, drag from the right edge dot → create child card 1, enter content, press Esc
Use the arrow key ← to return to the parent card
Drag from the right edge dot again → create child card 2, enter content, press Esc
Repeat steps 3–4 to quickly generate a set of parallel child branches

The key to this workflow is: use the mouse to create cards, use the keyboard for input and switching, with low switching cost between the two. If you want to avoid the mouse entirely, Canvas currently can’t do that—Obsidian hasn’t yet supported pure keyboard creation of connected cards. For a pure keyboard mind map, you can wait for the next chapter on Excalidraw, or use a dedicated mind mapping tool.

Adding Things to the Canvas

You can add more than just text cards to Canvas:

Text cards: Double-click on empty space, type directly, supports Markdown format. Titles, lists, bold—same as in regular notes.

Existing note files: Drag from the file tree directly into Canvas, or right-click on empty space in Canvas → “Add file from vault”. After dragging in, the note content is previewed in the card, and you can edit it directly.

A specific paragraph from a note: Select the paragraph you want in the note, then drag it into Canvas—only that content is added, not the entire file. Great for breaking down book notes.

Images: Drag image files from the file tree or system folder into Canvas; they display directly.

Web links: Paste a link into Canvas, right-click and select “Convert to link card”, which shows the page title and preview.

Key Point! Using AI to Draw Canvas

Canvas can be drawn manually, but there’s an even easier way: let AI generate it for you.

Background

First, a brief introduction to Claude Code—Anthropic’s AI programming CLI tool. It can be extended with Skills (detailed usage will be covered in Part 5 of this book on AI collaboration). Obsidian developer kepano created a set of obsidian-skills specifically for Claude Code, including one called json-canvas that teaches Claude Code to create and edit .canvas files.

URL: https://github.com/kepano/obsidian-skills/tree/main/skills/json-canvas

Installation Method

Run in the terminal:

git clone https://github.com/kepano/obsidian-skills.git ~/.claude/skills/obsidian-skills

Or you can open the website to download it directly, then create this folder and place it in the skills directory.

Usage Method

In Claude Code, type /json-canvas, select this Skill, press Tab, then describe in natural language what you want to draw. Claude Code will directly generate a .canvas file in your Obsidian vault.

Practical Demonstration

I used the folder structure from the chapter on folder planning as a demonstration. I told Claude Code: “Draw the folder structure from the folder planning chapter as a Canvas, showing the function and flow relationships of each folder.”

After reading the article, Claude Code directly generated a .canvas file and placed it in the 00 Inbox. The file content is in standard JSON Canvas format—each folder corresponds to a card, with color coding and arrows indicating flow relationships:

You can see that the 00 Inbox serves as the entry point, organized content flows to 01 Notes and 04 Output, and content from 01 Notes then flows to 04 Output—the entire flow is clear at a glance. This relationship would take several rounds of explanation in text, but in a diagram, it’s understood in three seconds.

This is a practical combination of AI + Canvas: throw your notes or articles directly to Claude Code, let it automatically extract the structure and draw the relationship diagram, which is much faster than manually creating cards and dragging connections.

About the .canvas Format, One Thing to Clarify

Canvas files are not in .md format; they are in .canvas format.

.canvas files are plain text files in JSON format, storing the position, size, and content of each card, as well as the connections between cards. They are parallel to .md files—in the file tree, .canvas files appear separately, stored apart from note files.

This means: Canvas needs to be managed separately. You can’t both write text and embed a Canvas in a single .md file—Canvas is a separate file, text is another file, existing independently.

By the way, JSON Canvas is not a proprietary format exclusive to Obsidian; it’s an open standard (MIT license) and is already supported by many tools. But the “need to manage separately” issue remains.

Summary

What we learned today:

Canvas = infinite canvas: Suitable for content that requires spatial awareness and relationship building; don’t force it for linear content
How to enable: Settings → Core Plugins → Canvas → Toggle the switch
Core operations: Double-click to create a card, drag from edge dots to connect, Space+drag to pan the canvas
Keyboard workflow: Tab/Shift+Tab to switch cards, ↑↓←→ to move, Enter to edit, Esc to exit; creating connected cards requires dragging dots to empty space; pure keyboard creation is not yet supported
What you can add to Canvas: Text cards, existing notes, note paragraphs, images, web links
json-canvas Skill: Let Claude Code read notes and automatically generate .canvas files, much faster than manual drawing
Format note: Canvas saves as .canvas (JSON), not .md, and needs to be managed separately

Obsidian Keyboard Shortcuts: Build Muscle Memory

Mon, 01 Jan 0001 00:00:00 +0000

Earlier, we covered browser clipping plugins—saving web content into Obsidian with one click, clean formatting, and auto-filled metadata. This chapter takes a different angle: instead of how to put things in, let’s talk about how to use Obsidian itself more efficiently.

Why Bind Keyboard Shortcuts

Let’s start with the Command Palette.

Cmd+P is one of the best features in Obsidian. Open the palette, type what you want to do, press Enter, and it’s done. No need to remember where buttons are or dig through menus.

But after using it for a while, there’s a problem: too many commands. Obsidian comes with dozens of core commands, and with community plugins, the count easily exceeds a hundred. Every time you open the Command Palette, you have to think “what’s this command called?”, type it, wait for the list to filter, and then press Enter.

For low-frequency actions, this workflow is perfectly fine. But for high-frequency actions—like inserting a template or collapsing all headings—going through this every time gets annoying.

Keyboard shortcuts solve this: bind the most common actions to convenient keys, trigger them directly, without thinking.

Once you get used to it, you’ll find these actions become pure muscle memory—your hands press the keys before you even think.

Accessing Keyboard Shortcut Settings

Path: Settings (Cmd+,) → Find “Hotkeys” in the left sidebar.

Entering the Hotkeys page, you’ll see a long list of commands. Each row is a command with three columns:

Left column: Command name (including the source plugin)
Middle column: Currently bound shortcut (empty if not bound)
Right column: Action buttons

Searching and Binding

At the top of the page, there’s a search box that supports fuzzy search. For example, if you want to bind “Insert Template”, just type “template”, and the relevant commands are filtered immediately.

After finding the target command:

Step 1: Click the + button on the right.

Step 2: Press the key combination you want to bind, like Cmd+T. Obsidian automatically recognizes and displays it.

Step 3: Press Enter to confirm, or click elsewhere to close, and the binding is complete.

If you don’t want a shortcut anymore, click the × button on the right to unbind it, restoring it to empty.

Handling Conflicts

When binding shortcuts, you might occasionally encounter a conflict—the key you want to bind is already taken by another command. Obsidian will highlight the conflict and tell you which command currently uses that key.

The fix is straightforward:

Note the conflicting command name.
Search for that command, click × to unbind it.
Go back and bind your desired command, or choose a different key combination.

A small gotcha: After Obsidian 1.6, a few key combinations can’t be bound in the GUI and will show as invalid. If you encounter this, you can directly edit the .obsidian/hotkeys.json file in your vault directory to add them manually—but most keys don’t have this issue, so using the GUI is fine.

My Recommended Binding List

Not every command is worth binding a shortcut to. The criteria are simple: high frequency + multiple steps. For commands you use occasionally, just search with Cmd+P—no need to occupy mental slots for keys.

Here are the ones I use myself:

Command	Default Shortcut	Recommended Binding	Description
Insert Template	None	Cmd+T	One of the most frequent actions, must-bind
Toggle Reading/Edit Mode	Cmd+E	Use default	Default is already convenient, no need to change
Collapse All Headings	None	Cmd+[	Use when note structure is long
Expand All Headings	None	Cmd+]	Use together with the above
Toggle Left Sidebar	None	Cmd+\	Hide sidebar when focusing on writing
New Note	Cmd+N	Use default	Default is sufficient
Open Quick Switcher	Cmd+O	Use default	Quickly jump between different notes

If you have the Templater plugin installed (more powerful than the core template plugin, to be covered separately), it also has its own command—“Templater: Open Insert Template Modal”—and I recommend binding a shortcut for it too.

I don’t recommend binding all at once. Start with two or three of the most frequent ones, and add more as you get used to them. Binding too many keys can be confusing if you can’t remember them.

Summary

What you learned today:

Shortcut settings entry: Settings (Cmd+,) → Hotkeys, manage all shortcuts here
Binding method: Search command name → Click + → Press key combination → Confirm
Unbinding: Click ×, shortcut returns to empty
Conflict handling: Obsidian highlights conflicts, unbind the old one first then reassign

Key points:

Only bind high-frequency + multi-step actions, low-frequency commands are fine with Cmd+P
Start with two or three most common ones, expand gradually as you get used to them, don’t bind too many at once
Prioritize these: Insert Template (Cmd+T), Collapse/Expand All Headings (Cmd+[/]), Toggle Left Sidebar (Cmd+)

Obsidian Plugins: The Real Extension Universe

Mon, 01 Jan 0001 00:00:00 +0000

We’ve covered the basics of Obsidian—creating vaults, writing notes, using bidirectional links, and embedding images. Now let’s dive into the most exciting part of Obsidian: plugins.

What are plugins?

Plugins are add-ons that extend Obsidian’s functionality. Obsidian itself provides a clean note-taking environment, but you can make it much more powerful by installing plugins—add a calendar, a Kanban board, an AI assistant, you name it.

Obsidian plugins come in two types: core plugins and third-party plugins (also called community plugins).

Core Plugins

Core plugins are built into Obsidian by default. Go to Settings → Core plugins to see a list.

These are developed by the Obsidian team, for example:

Search: Search note content globally
Graph view: Visualize links between notes
Daily notes: Automatically create a daily note
Outline: Generate a table of contents based on heading levels

Some core plugins are enabled by default, others are not. You can toggle them on or off as needed.

Features: Officially maintained, stable and secure, but limited in number.

Third-Party Plugins (Community Plugins)

Third-party plugins are contributed by developers worldwide. Almost any feature you can think of has already been built by someone.

Features: Huge variety, rich functionality, maintained by community developers.

If core plugins can’t do what you need, chances are you’ll find a solution in the community plugin marketplace.

How to Install Third-Party Plugins

Two methods.

Method 1: Install from the Community Plugin Marketplace (Recommended)

The easiest way, just three steps.

Step 1: Turn off Restricted Mode.

Go to Settings → Third-party plugins. You’ll see that “Safe Mode” is enabled. Click “Turn off” and confirm.

Obsidian enables Restricted Mode by default for security—after all, third-party plugins are code written by others. However, plugins in the community marketplace have been reviewed by the official team, so it’s safe to use them.

Step 2: Browse and Install.

After turning off Restricted Mode, click the “Browse” button to open the community plugin marketplace. Search for the plugin you want, find it, and click “Install”.

Step 3: Enable.

After installation, the plugin won’t be enabled automatically. Go back to Settings → Third-party plugins, find the plugin you just installed, and toggle the switch on.

Some plugins work right after enabling, while others need configuration. Those with a gear icon next to them can be configured—click it to see the options.

Method 2: Manual Installation (Download from GitHub)

Some plugins haven’t been listed in the community marketplace yet (still under review), or you might want to use the latest development version of a plugin. In these cases, you’ll need to install manually. This method is generally not recommended for beginners, but it’s good to know.

Step 1: Download the plugin files.

Go to the plugin’s GitHub page, find the Releases section, and download the latest version. You’ll typically need three files:

main.js
manifest.json
styles.css (some plugins don’t have this; if not, ignore it)

Step 2: Place them in the plugins folder.

In your vault folder, locate the .obsidian/plugins/ directory (create it if it doesn’t exist). Create a folder inside it and place the downloaded files there:

Your Vault/
├── .obsidian/
│   └── plugins/
│       └── plugin-name/
│           ├── main.js
│           ├── manifest.json
│           └── styles.css

.obsidian is a hidden folder. On Mac, press Cmd + Shift + . to show hidden files. On Windows, check “Show hidden files” in folder options.

If you’ve already installed third-party plugins, you can click the button shown in the image to open this folder.

Step 3: Enable.

Go back to Obsidian, Settings → Third-party plugins, refresh the list, and the plugin you placed will appear. Toggle the switch to enable it.

Method 1 is usually sufficient. Method 2 is for advanced users or those who want to try the latest features.

How to Use Plugin Features

After installing and enabling a plugin, how do you access its features? Two ways.

The vertical row of small icons on the far left of Obsidian are shortcut entries for various features.

Many plugins add an icon here after installation. Click it to open the corresponding feature. For example, after installing the Recent Files plugin, a clock icon appears here; clicking it shows a list of recently edited files.

Method 2: Command Palette (Recommended)

Press Ctrl/Cmd + P to open the command palette, type the action you want to perform, and press Enter.

Almost all plugin features can be accessed via the command palette. Can’t remember where a feature is? Just press Ctrl/Cmd + P and search. For example, if you want to clear unused images, you don’t need to find a button—just type “Clear” in the command palette and you’ll find the corresponding action.

The command palette is Obsidian’s universal entry point. Just remember Ctrl/Cmd + P.

Four Must-Have Plugins for Beginners

The Obsidian plugin library is huge, but you don’t need to install many at the start. Here are four that I personally use all the time, each solving a real pain point.

1. Recent Files — Recent Files List

Obsidian doesn’t have a “recent files” list by default. As your notes grow, finding the file you just edited means digging through folders.

After installing: A new panel appears in the left sidebar, listing your recently opened files in chronological order. Click one to jump to it.

2. Easy Typing — Auto Formatting

Users migrating from Notion, Word, or other platforms may not be familiar with Markdown syntax. When mixing Chinese and English, formatting can be inconsistent, and manually adding spaces is tedious. Writing tables, adding color highlights, and other Markdown operations have complex syntax.

But this plugin—if you’ve used Word, you’ll find it familiar.

After installing:

Automatically adds spaces between Chinese and English text—type “我用Obsidian” and it becomes “我用 Obsidian”, instantly improving readability.
Editing enhancements—select text and press a symbol key (like *) to quickly wrap it, making it bold without manually typing two asterisks.
Smart full-width symbol conversion—automatically converts full-width punctuation to half-width in code environments, so you don’t have to switch input methods.

This plugin has many options; you can enable them according to your needs.

3. Clear Unused Images — Clean Up Unused Images

When writing notes, you often take screenshots and insert images. But sometimes you delete a section, and the images it referenced become “orphans”—no note references them anymore, but the image files still take up space. Over time, your attachments folder fills up with junk images.

After installing: Run it once, and it will scan your entire vault, find all images not referenced by any note, and clean them up for you.

How to use: Click the shortcut button on the left sidebar, or press Ctrl/Cmd + P to open the command palette, type “Clear Unused Images”, and press Enter.

4. Open In New Tab — Open Files in New Tab

Obsidian’s default behavior: when you click a file in the file list, it replaces the current tab. You’re editing A, want to check B, click B, and A is gone—now you have to go back and find it.

After installing: Clicking any file in the file list opens it in a new tab without overwriting the current content. Same logic as a browser. If the file is already open, it automatically jumps to that existing tab instead of opening a duplicate.

Works immediately after installation, no configuration needed.

Summary

What you learned today:

Two types of plugins: Core plugins (built-in) and third-party plugins (community-contributed)
Two installation methods: Directly from the community marketplace (recommended) or manually from GitHub
Two ways to use them: Left sidebar shortcut buttons, or the command palette Ctrl/Cmd + P (recommended)
Four must-have plugins:
- Recent Files — Quickly find recently edited files
- Easy Typing — Editing enhancements
- Clear Unused Images — Clean up unreferenced images
- Open In New Tab — Open files in new tabs

Key takeaways:

More plugins isn’t always better; just install what you need
Start with these four, then add more as needed
Remember Ctrl/Cmd + P—it’s Obsidian’s universal entry point

Obsidian Properties: Make Notes Searchable

Mon, 01 Jan 0001 00:00:00 +0000

In this chapter, we’ll talk about Obsidian’s Properties.

In the previous chapter, we covered plugins, which make Obsidian more powerful. This chapter covers something less flashy but very practical: adding metadata to each of your notes.

What Are Properties?

Open a note, click the three dots (⋯) in the top right corner, and select “Add property”.

You’ll see a table-like area at the top of the note: the left side is the property name, the right side is the property value. On the left, you can choose from Obsidian’s built-in properties (like tags, aliases) or create your own by typing a name. On the right, fill in the corresponding content.

It’s that simple. No coding required.

What’s That YAML?

If you switch to Source mode (Settings → Editor → Default editing mode → Source mode), you’ll see that properties actually look like this:

---
title: My Note Title
date: 2026-03-03
tags:
  - Obsidian
  - Tutorial
---

The content between the two --- lines is called YAML frontmatter, a data format. But you don’t need to write this manually—Obsidian’s visual editor handles everything. Click and select in the properties panel, and the underlying code is generated automatically.

Just know it exists; you don’t need to touch the source code in daily use.

What Are Properties Good For?

You might ask: why not just write everything in the body? Why add an extra layer of properties?

Three benefits.

1. More Precise Search

Normal search is full-text search—if you search for “tutorial”, all notes that contain the word “tutorial” in the body will appear, potentially a huge list.

But if you set categories: Tutorial in properties, you can use Obsidian’s search syntax to filter precisely:

[categories: Tutorial]

This will only return notes categorized as “Tutorial”, not notes that casually mention the word “tutorial” in the body.

Properties are structured data; the body is unstructured data. When you have hundreds of notes, this difference becomes increasingly significant.

2. Automatic Template Filling

This works together with templates. We’ll cover templates in detail in the next chapter, but here’s a sneak peek:

You can preset properties in a template, like date: {{date}}. Every time you create a new note from that template, the date is automatically filled with the current day. The same goes for repetitive properties like title and category—the template fills them in for you.

3. Automatic Metadata from Web Clipping and Imports

If you use a browser clipping plugin (like Obsidian Web Clipper) to save web articles to Obsidian, the clipped notes automatically include properties—the original title, link, save date, and other information are stored in properties, helping you keep track of where the content came from.

Commonly Used Properties

You can create any properties you like, but a few are most commonly used. It’s worth knowing about them.

1. title

As the name suggests, it’s the title of the note.

Note: The title property can be different from the file name. The file name is what you see in the file list; the title property is the note’s “official title”.

For example, I have a file named 2026-03-03 Obsidian-Properties.md, but the title property is Obsidian Properties: Make Notes Searchable—the date in the file name is for sorting, and doesn’t need to appear in the title.

My personal advice: If you don’t have special numbering needs, set the title and file name the same to avoid confusion.

2. date

Records the creation date or publication date of the note.

If filling manually, the format is YYYY-MM-DD, e.g., 2026-03-03.

But here’s a tip: If you’re setting the date property in a template, it’s recommended to write:

date: "{{date}}"

This way, every time you create a new note from the template, {{date}} is automatically replaced with the date you created the note. No manual input, no mistakes.

This feature will be covered in detail in the next chapter on templates.

3. aliases

This property is extremely useful—make sure you know it.

Aliases allow you to give a note multiple names. We often refer to the same thing by different names, and that’s where aliases come in.

For example, I have a note about Donald Trump with the file name “The Donald”. But in other notes, I might refer to him as “Trump”, “Donald Trump”, “President Trump”, or “Mr. Trump”.

Without aliases, if you use [[Trump]] to create a link, Obsidian would think you want to link to a note named “Trump”. But that note doesn’t exist—your note is named “The Donald”. The result: you’re referring to the same person, but the links point to different places.

With aliases, it’s different. In the properties of the “The Donald” note, I write:

aliases:
  - Trump
  - Donald Trump
  - President Trump
  - Mr. Trump

Now, no matter which note you’re in, when you type [[ and then “Trump”, “Donald Trump”, or “Mr. Trump”, Obsidian will suggest linking to the “The Donald” note. Multiple names, one entry.

This is especially useful when building a knowledge base. Many concepts have alternative names, abbreviations, or English names. Using aliases to manage them keeps your links organized.

4. categories

Mark notes with a broad category, like “Book Notes”, “Tutorial”, “Random Thoughts”, etc.

categories:
  - Obsidian Tutorial

Categories are mainly for your own reference, helping you quickly filter notes of the same type. If you later publish your notes to a blog, many blogging systems (like Hugo, Hexo) will read this property to generate category pages.

5. tags

Tags are familiar to most. In Obsidian, you can add tags in the body using #tagname, or you can write them uniformly in properties:

tags:
  - Obsidian
  - Tutorial
  - Note-taking

The advantage of writing tags in properties is centralized management—you can see at a glance which tags a note has, without searching through the body.

But to be honest, in Obsidian, the role of tags can largely be replaced by links. If you think a concept is important enough to tag, why not create a note for it and link to it? Links are more flexible and can carry more content.

Of course, if you’re used to tags, that’s perfectly fine. Tags and links don’t conflict—choose whichever works for you.

6. Other Useful Properties

Besides the five above, here are a few more you might find useful:

cssclasses — Assign special CSS styles to a single note. For example, if you want a note to use a different font or layout, you can use this property with custom CSS. Advanced feature; beginners can skip for now.

publish — If you use Obsidian’s official publishing service (Obsidian Publish), this property controls whether the note is published. true to publish, false to not publish.

description — A brief description or summary of the note. When used with a blogging system, this property often appears as preview text in article lists.

You can also create any properties you need—like author, source, status (draft/complete), etc. Properties are fully customizable; add whatever you find useful.

Summary

What we learned today:

What are properties: Structured information at the top of a note. Add them by clicking the three dots—no coding required.
Why use them: Precise search, automatic template filling, automatic metadata from web clippings.
Commonly used properties:
- title — Can be different from the file name.
- date — Use {{date}} in templates for auto-fill.
- aliases — Multiple names pointing to the same note, essential for linking.
- categories — Group notes into broad categories.
- tags — Centralized management, but links can replace most use cases.
Properties are fully customizable: Add whatever you need.

Key takeaways:

Aliases are the most valuable property—a great companion for the linking system.
Tags work, but in Obsidian, links are more powerful.
Don’t set too many properties at the start; add them as needed.

Obsidian Templates: Write Faster with Reusable Formats

Mon, 01 Jan 0001 00:00:00 +0000

We’ve covered note properties—adding title, date, categories to each note. But you’ll quickly notice a problem: every time you create a new note, you have to manually fill in these properties and set up the format again. Templates are designed to solve this repetitive work.

Why Do You Need Templates?

You might think: manually filling in a few lines of properties isn’t a big deal. But let’s do the math. Every blog post needs title, date, categories. Every book note also needs author, publisher, my rating. One or two notes, you don’t feel it. But when you have dozens or hundreds of notes, having to type out these fixed fields from scratch every time becomes annoying. More importantly, manual typing is error-prone—wrong date format, inconsistent category names, leading to mismatched search results later.

Templates solve this problem: Write your note format in advance, save it, and apply it with one click when needed—no manual typing required.

Step 1: Enable the Templates Core Plugin

Templates is a core plugin in Obsidian. It is not enabled by default, so you need to turn it on manually. Go to Settings → Core Plugins → find “Templates” → toggle the switch on the right.

After enabling it, a small gear icon will appear on the right of the “Templates” row in the Core Plugins list. Click it to configure.

Step 2: Set the Template Folder Location

Open the Templates plugin settings. The most important setting is the Template folder location. Enter the name of the folder where you store your template files. For example, in my vault, I use a folder called 02-Templates, so I enter that. All files in this folder will be recognized as templates. When you invoke a template, Obsidian will list all files from this folder for you to choose from.

If you don’t have this folder yet, create one first, then come back to fill in the path.

Step 3: Create Your First Template

Create a Template File

In your designated template folder (e.g., 02-Templates), create a new file—use the shortcut Cmd+N, or right-click the folder and select “New file”. This file is exactly like a normal note; just write the content as usual. Once saved, it becomes your template.

Template Variables

The most crucial part of templates is variables. As mentioned earlier, writing {{date}} in properties automatically fills in the date. Let’s detail the three built-in variables:

Variable	Description	Example
`{{date}}`	Date when template is inserted	2026-03-04
`{{time}}`	Time when template is inserted	14:30
`{{title}}`	File name of the current note	My Book Note

Focus on {{date}}.

This variable is dynamic—every time you use the template, it is replaced with the current date. Compare the two approaches:

Writing date: 2026-03-04 (hardcoded) → all notes created with this template will have the date 2026-03-04, forever.
Writing date: {{date}} → use it today, it fills in today; use it tomorrow, it fills in tomorrow.

So, always use {{date}} for the date property instead of hardcoding it. This is the trick I hinted at earlier.

Step 4: Using Templates

Insert a Template After Creating a Note

First create a new note, then insert the template.

After creating a blank note, there are two ways to insert a template:

Method 1: Command Palette (Recommended)

Press Cmd+P to open the Command Palette, type “Insert template”, press Enter, and select the template you want from the list.

Method 2: Sidebar Button

If you enabled the template button in settings, a template icon will appear in the left toolbar. Click it to select a template directly.

Both methods work; use whichever feels more comfortable. The advantage of the Command Palette is that you don’t need to remember where the button is—just press Cmd+P and search.

Practical Template Examples

Now that we’ve covered the theory, let’s look at some actual templates.

Blog Post Template (consistent with this book’s format):

---
title: {{title}}
date: {{date}}
categories:
  -
---

Book Note Template:

---
title: {{title}}
date: {{date}}
categories:
  - Reading Notes
---
Publisher:
Date finished: {{date}}

# Core Ideas

# Memorable Passages

# My Review

Diary Template:

---
date: {{date}}
---

## What I Did Today

## Problems I Ran Into

## Plan for Tomorrow

These three templates cover the most common scenarios. You can use them directly or modify them to your liking. Start with a few commonly used ones, and add new templates when you encounter repetitive formats. Don’t try to think of all possible cases from the start—overthinking often leads to not using them at all.

Summary

What you learned today:

Enable the “Templates” core plugin (Settings → Core Plugins → toggle on)
Set the template folder (all files in this folder are recognized as templates)
Three built-in variables: {{date}} / {{time}} / {{title}}
Insert a template: Cmd+P, search “Insert template”, select the desired template

Key takeaways:

Use {{date}} for the date property instead of hardcoding it—it automatically fills in the current date each time you use the template.
Templates are just normal notes—place them in the designated folder, no special setup needed.
Start with a few commonly used templates, just enough for your needs—don’t overdesign.

Obsidian Themes: Change the Look in Five Minutes

Mon, 01 Jan 0001 00:00:00 +0000

We’ve covered Excalidraw for drawing, flowcharts, and mind maps—plenty of practical content. This chapter is something lighter: changing themes to make Obsidian look great.

The last few chapters have been dense, so consider this a break. Theme settings are simple, but they deserve their own chapter because a good-looking interface genuinely makes you want to open the app and write more.

This chapter covers three things:

Installing themes via Obsidian’s built-in marketplace
Manually installing themes from GitHub (advanced, rarely needed)
My personal recommendation: the Nord theme

What is a theme and why change it?

Obsidian’s default interface… how to put it, plain. It’s functional, but visually it has that “it works” feel without much appeal.

After switching themes, it’s a completely different experience. Some themes are minimal and clean, some have high information density for organizing lots of notes, some are dark and easy on the eyes for long sessions. Color schemes, font styles, sidebar layouts—everything changes.

Themes aren’t just about “looking good.” That moment when you open the app each day—if the interface feels pleasant, subconscious resistance drops significantly. When it comes to sticking with note-taking, the tool’s “feel” and “aesthetics” really do matter.

So spending half an hour picking a theme you like is well worth it.

Installing themes via the built-in marketplace

This is the most straightforward way. The marketplace has hundreds of community themes, all free, one-click install.

Path: Settings → Appearance → Themes → Browse

Once inside, you’ll see a list. You can sort by downloads or search for a specific theme name. Find one you like, click into it, click “Install and use,” and the theme switches. It’s that simple—no extra steps needed.

Summary of steps:

Open Settings
Click “Appearance” on the left
Find the “Themes” section, click “Browse”
Search or browse to find a theme you like
Click “Install and use”

If you want to switch back to the default theme, do the same here and change the theme to “Default.”

Manually installing themes from GitHub

This method is unnecessary for most people, but I’ll briefly cover it in case you ever encounter a theme that’s only on GitHub and not in the marketplace.

Manual installation steps:

Go to the corresponding GitHub repository and download the theme files (usually a folder containing theme.css and manifest.json)
Place the entire folder in your vault’s .obsidian/themes/ directory
Restart Obsidian
Then go to Settings → Appearance → Themes, and you’ll see the newly installed theme

Note: The .obsidian folder is hidden by default. On Mac, press Command + Shift + . to show hidden files.

Again: Most people will never need this method. The built-in marketplace already has hundreds of themes, more than enough for daily use. Just know that this method exists.

My choice: the Nord theme

Now that we’ve covered the methods, let me share my personal choice—Obsidian Nord. It’s the theme I’ve used the longest, and I’ve barely switched since installing it.

Nord’s color palette comes from the “Nord color system,” inspired by Nordic auroras and polar ice and snow. It’s a cool-toned deep blue scheme. Not flashy or loud, but a very steady, enduring set of colors.

Why I chose it:

Dark and easy on the eyes: Comfortable for long sessions—not a harsh pure black, but a deep color with blue-gray tones
Soft color scheme: Highlight colors, link colors, and heading colors are all restrained, keeping the interface from looking busy
Timeless appeal: I’ve been using it for two years, and every time I open Obsidian it still looks pleasant—no urge to switch

Installation: Just search for “Obsidian Nord” in the theme marketplace, then install and enable it.

Summary

What you learned today:

Entry point for changing themes: Settings → Appearance → Themes → Browse
The built-in marketplace has hundreds of free themes—find one you like and install/enable it directly
Dark/light mode can be switched in Settings → Appearance → Base color scheme
For the rare theme not in the marketplace, you can manually download from GitHub and place it in the .obsidian/themes/ folder
Recommended theme: Obsidian Nord

Key takeaways:

For daily use, the built-in marketplace is sufficient—simple and convenient
A good-looking interface reduces the mental resistance to opening your notes every day—worth choosing carefully
Nord is the theme I’ve used for two years, great for those who prefer dark, cool tones

Publish from Obsidian to WeChat: How I Built the Plugin

Mon, 01 Jan 0001 00:00:00 +0000

📌 Editor’s Note: This chapter was originally written when WeChat Publisher still had free and paid versions. Since v0.1.13, WeChat Publisher is completely free for personal users—all features (format preview, copy HTML, publish drafts, multi-account, cover system, etc.) are unlocked directly without any activation code. This chapter has been updated accordingly to remove paid/activation code references; some screenshots in the original text still show the “Purchase Activation” button, but that entry has been removed in the new version—please ignore it.

The previous chapters covered the tools you can use in Obsidian for management and operations. This final chapter shifts gears—publishing what you’ve written in Obsidian to WeChat.

You’ve written your article. Now how do you publish it to WeChat?

This step trips up many people. It’s not that they can’t write—it’s that after writing, they can’t get it published, or the formatting is completely messed up.

This chapter addresses that problem and introduces a plugin I built myself: WeChat Publisher.

To be honest, it took me several days of on-and-off work to build this plugin. I thought it wouldn’t be complicated, but once I started, I found far more pitfalls than I expected—various limitations of the WeChat API, image format conversion, compatibility issues with HTML inline styles—I hit them one by one. Fortunately, the end result is pretty good, and after using it for a while, it really saves a lot of hassle.

I never knew publishing a plugin publicly could be such a hassle!

What’s the Trouble with Writing for WeChat in Obsidian?

Let’s start with a scenario many people have encountered.

You write an article in Obsidian. It has code blocks, bold headings, tables—it looks great in Obsidian. Then you copy the content and paste it into the WeChat Official Account editor—everything is a mess. Code blocks become plain text, heading hierarchy is lost, and images have to be uploaded one by one manually.

It’s like formatting a beautiful document in Word, only for the recipient to open it and see garbled text.

There are usually two paths:

Path 1: Write directly in the WeChat editor. No formatting issues, but the editor doesn’t support Markdown, making it painful to write.

Path 2: Write in Obsidian, copy and paste into the editor, then manually fix formatting. The formatting ends up correct, but each article takes 20-30 minutes just for this step.

Is there a better way? Yes.

What is WeChat Publisher?

In a nutshell: Write in Obsidian, preview the WeChat formatting directly, and publish to your WeChat draft box with one click.

What it does for you: Renders Markdown into WeChat-compatible HTML, uploads local images to WeChat’s CDN, converts Mermaid diagrams and math formulas into images, and pushes the entire article to the draft box. You only need to do the final step in the WeChat backend: send the article.

Take a look at the results.

Code block (syntax highlighting):

Math formulas & Mermaid diagrams:

Ruby annotations & horizontal scrolling images:

All of these were sent directly from Obsidian without any manual formatting adjustments.

Core Features at a Glance

Feature	Description
🎨 Format Preview	Real-time Markdown rendering in WeChat style, WYSIWYG
📋 Copy HTML	One-click copy of rendered HTML, paste into WeChat editor
🚀 One-Click Publish	Push directly to WeChat draft box, no browser needed
🖼 Cover System	Auto-set cover from article images, supports custom covers
👥 Multi-Account	Manage multiple WeChat accounts from one plugin
🎨 Theme Switching	8 built-in themes, customizable styles

Completely free for personal users. For commercial use (companies, training institutions, redistribution, etc.), please contact the author via the WeChat account ‘HelloRanceLee’ for authorization.

How to Install

The plugin is not yet on the Obsidian official plugin marketplace. There are two installation methods.

Method 1: Install via BRAT (Recommended)

BRAT is a plugin management tool in the Obsidian community, specifically for installing plugins not yet on the marketplace, and it automatically manages updates.

Step 1: Install BRAT.

In Obsidian, go to ‘Settings’ → ‘Community plugins’ → ‘Browse’, search for BRAT, install and enable it.

Step 2: Add WeChat Publisher.

Open ‘Settings’ → ‘BRAT’, click Add Beta plugin, and enter the repository URL:

RanceLee233/wechat-publisher

Click Add Plugin, select Latest version, and BRAT will download it automatically.

Step 3: Enable the plugin.

Go back to ‘Settings’ → ‘Community plugins’, find WeChat Publisher, and toggle it on.

When new versions are released, BRAT will detect them automatically, or you can manually click Check for updates.

Method 2: Manual Installation

If accessing GitHub is inconvenient, you can download the zip directly from my blog:

https://blog.discoverlabs.ac.cn/downloads/wechat-publisher/

After unzipping, place the folder in your Obsidian plugins directory:

your-vault-path/.obsidian/plugins/wechat-publisher/

The directory structure should look like this:

.obsidian/
  plugins/
    wechat-publisher/
      main.js
      manifest.json
      styles.css

Then enable it in ‘Community plugins’ as well.

Opening the Plugin

After installation, a WeChat Publisher icon will appear in the left sidebar of Obsidian. Click it to open. You can also press Cmd+P (Windows: Ctrl+P) and search for WeChat Publisher.

The top toolbar from left to right: Format · Account Name · Account Config · User Guide · Refresh Render · Copy HTML · Go to WeChat Paste · Publish Draft.

Below the toolbar is the publish info area (title, author, cover), and further down is the article preview area.

Screenshots from older versions may still show the ‘Purchase Activation’ button, but it has been removed in the new version—all features are directly available.

Usage 1: Copy HTML and Paste (No API Configuration Needed)

The simplest usage, no account configuration needed—write and publish directly.

Step 1: Adjust formatting (optional).

Click the Format button at the top to expand the style control bar. You can switch between built-in themes, or go into Style Config to adjust font size, line spacing, colors, and other details.

It’s recommended to set up a style you like the first time and save it. For future articles, you can directly ‘Apply Saved Style’ without reconfiguring each time.

Step 2: Click ‘Copy HTML’.

The plugin copies the rendered HTML to your clipboard with complete formatting.

Step 3: Click ‘Go to WeChat Paste’.

Your browser automatically opens the WeChat backend, and you can paste it into the editor.

The whole process takes about ten seconds, much faster than manual formatting.

Usage 2: One-Click Publish to Draft Box

If you publish articles frequently, you can configure the WeChat API so the plugin pushes articles directly to the draft box without ever opening a browser.

Step 1: Configure Your WeChat Account

Click Account Config at the top to open the configuration popup. The top of the popup lists all added accounts as tabs; click to switch.

Fields to fill in:

Field	Description
Account Name	Any name you choose, to distinguish multiple accounts
AppID	Your WeChat account’s AppID, obtained from the WeChat Developer Platform
AppSecret	Developer secret key, must be manually enabled on the platform
Default Author	Optional, auto-filled when publishing
Default Cover	Optional, set a fixed cover for this account

At the bottom, there are two buttons: Add Account Manually (fill in the form) and Quick Paste New Account (one-click auto-recognition from copied WeChat platform content). After filling in, click Save.

Quick Paste New Account

Don’t want to fill in forms? There’s a faster way: Open the ‘Basic Information’ page on the WeChat Official Account platform, select all and copy the content, then in the WeChat Publisher account config popup, click ‘Quick Paste New Account’, paste the content, and the plugin automatically recognizes the account name, AppID, and AppSecret—one-click addition.

The pasted content format is roughly as follows, and the plugin parses it automatically:

Official Account
Your WeChat Account Name
AppID
wxb3f8a2e9c7d10456
AppSecret
e4a27f3c1b9d8056f2e8a3c7b4d90561

How to Get AppID and AppSecret

Step 1: Open developers.weixin.qq.com and click ‘Go to Console’.

Step 2: In ‘My Business’, find your WeChat account and click into it.

Step 3: Enter the WeChat account management backend, find the AppID on the ‘Basic Information’ page (copy it directly), then click Enable next to AppSecret, scan the QR code to authorize, and you can obtain it.

AppSecret is only displayed in full once at the moment of enabling. Copy and save it immediately, otherwise you’ll have to regenerate it.

Configure IP Whitelist

The WeChat API requires that the IP address of the machine calling the interface must be on a whitelist. WeChat Publisher calls the API directly from your computer, so you need to add your public IP to the whitelist.

The plugin has a helper feature: In the account config popup, click ‘Detect Local IP’ to automatically get your public IP, click ‘Copy’, then go to the WeChat platform’s ‘API IP Whitelist’ and paste it to save.

If you use it both at home and at work, the public IPs of the two networks are different, so add both.

Step 2: One-Click Publish Draft

Open the note you want to publish, fill in the title and author in the publish info area, set the cover as needed, and click Publish Draft at the top.

The plugin automatically:

Uploads local images in the article to WeChat CDN
Renders Mermaid diagrams and math formulas into images
Submits the rendered HTML along with title, author, and cover to the draft box

After completion, go to the WeChat backend draft box, check it over, and if everything is fine, send it.

The draft is not sent directly; you need to manually send it from the backend.

Re-publishing automatically updates, no duplicate articles: If this note has been previously published as a draft, after making changes and clicking ‘Publish Draft’ again, the plugin will automatically find the existing draft on the WeChat platform and update it, without creating a new duplicate article.

How to Set the Cover

The publish info area has three cover buttons:

Button	Description
Select Cover from Computer	Manually choose an image from your local computer each time
Default Cover	Use the cover preset in the account configuration
Clear Cover	No cover, uses a placeholder blank image when publishing

Cover priority: Manual selection > Account default cover > Placeholder image.

It’s recommended to set a default cover in the account configuration so you don’t have to manually select one each time you publish.

Supported Formats

Format	Support
Code blocks	✅ Syntax highlighting, preserves indentation and spaces
Math formulas	✅ Inline and block formulas, rendered as images
Mermaid diagrams	✅ Flowcharts, sequence diagrams, etc., rendered as images
Tables	✅ Full style restoration
Local images	✅ Auto-upload to WeChat CDN when publishing (supports `../` relative paths)
Remote images	✅ Auto-processed
Ruby annotations	✅ Multiple syntax formats
Alert blocks	✅ `> [!NOTE]` / `[!WARNING]` etc.
Horizontal scrolling images	✅ Multiple images displayed side by side
#Tags	✅ Rendered as capsule style
Obsidian Callout	✅
Bold, italic, strikethrough, highlight	✅

The more complex your article, the more time you save. If your article contains code blocks, math formulas, or Mermaid diagrams, the time spent handling them manually adds up to a significant amount.

Summary

What you learned today:

The biggest problem with writing for WeChat in Obsidian is format conversion—WeChat Publisher solves this
Two usage methods: Copy HTML and paste into WeChat backend (no configuration, 10 seconds); or configure the API for one-click publish to draft box (even more convenient)
Configuring the API requires AppID + AppSecret + IP whitelist, a one-time setup
Supports complex formats like code block highlighting, Mermaid, math formulas, automatic local image upload, etc.
Completely free for personal users since v0.1.13, all features unlocked directly, no activation code needed

Key points:

Completely free for personal users, feel free to download and use
For commercial use (companies, training, redistribution), please contact the author via the WeChat account ‘HelloRanceLee’
Configuring the WeChat API is a one-time task, not difficult if you follow the tutorial
Remember to configure the IP whitelist before publishing, otherwise API calls will error
It’s recommended to set up and save your style the first time, then apply it directly for each article

Get the latest version of the plugin:

GitHub: https://github.com/RanceLee233/wechat-publisher
Direct download: https://blog.discoverlabs.ac.cn/downloads/wechat-publisher/

Part 5: AI Collaboration: Turn Obsidian into an AI Workbench

The Karpathy Method: Build a Personal Wiki with LLMs

Mon, 01 Jan 0001 00:00:00 +0000

Recently, a Gist by Andrej Karpathy has been spreading widely in the tech community. After reading it, my first thought was: this idea has a deeper connection with Obsidian than most people realize. This article is about that.

Who is Karpathy

If you follow the AI world, this name should be familiar. But if you don’t know much about him, I think it’s worth explaining first.

Karpathy is not the kind of “AI leader managing products at a big company”; he is truly one of the own in the deep learning field.

He did his PhD at Stanford under Fei-Fei Li—the person who led ImageNet and essentially launched modern computer vision. After leaving Fei-Fei Li’s group, Karpathy went to OpenAI as one of its co-founders. In 2017, Tesla poached him to lead the vision perception system for Autopilot.

During his years at Tesla, many people now know the outcome: Tesla was almost the only autonomous driving company at the time that insisted on a pure vision approach—no lidar, just cameras + neural networks. This approach was heavily criticized at the time as too radical. The results later became clear to everyone.

He left Tesla in 2022, briefly returned to OpenAI in 2023, then left again to start his own AI education project, karpathy.ai.

What I find interesting about him is not just his resume, but that he maintains a rare state: able to do world-class engineering, yet willing to spend time writing articles and recording courses to explain the underlying logic of technology to ordinary people.

His nanoGPT and micrograd on GitHub are minimal reimplementations of GPT and backpropagation, specifically designed for ordinary people to truly understand. His CS231n course on YouTube has taught countless people deep learning.

So when he wrote a Gist on GitHub about “using LLMs to manage knowledge bases,” it quickly spread through the tech community. I think it’s worth a careful read.

What He Said

The Gist is titled LLM Wiki: A pattern for building personal knowledge bases with LLMs. The original link:

https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f

His starting point is a feeling many people have had: Your knowledge base keeps growing, but what you can actually use keeps shrinking.

You bookmark articles, take reading notes in Notion, build a pile of notes in Obsidian, but the next time you need a certain piece of knowledge, the probability of finding it is not high. It’s not that you can’t find it—it’s too scattered, with no connections between them. Even if you find them, they are fragments that you have to piece together yourself.

He attributes this problem to the shortcomings of two existing solutions:

First: The bookmark approach.
You dump the original text in, do nothing, and rely entirely on search. The problem is that search finds documents, not answers. You still have to read, understand, and synthesize yourself.

Second: The RAG approach (Retrieval-Augmented Generation).
You provide a bunch of documents to the AI, which retrieves and generates answers on the fly. This is much better than bookmarks, but it’s always temporary, starting from scratch each time, with no accumulation.

His proposed LLM Wiki is a different idea: Don’t let the AI organize temporarily during search; instead, let the AI continuously maintain an ever-updating Wiki.

How LLM Wiki Works

The entire architecture has three layers:

Raw Sources
These are the things you usually read: articles, books, video subtitles, meeting notes. They are stored here as-is, as raw material.

The Wiki
A set of Markdown files, each corresponding to a topic, concept, or entity. For example, you might have a “Machine Learning - Overfitting” page, a “Reading Notes - Being in the Game” page, and a “People - Feynman” page.

These files are not written by you; they are written and continuously maintained by the AI. Each time new material comes in, the AI updates relevant pages; cross-references are established between pages; if contradictions arise, they are flagged.

The Schema
A configuration that tells the AI “what this Wiki should look like.” For example, what fields each note should contain, how to organize, what constitutes an orphan note, which concepts need their own page.

Then three core operations:

Ingest
Each time new material comes in, the AI reads it and updates 10 to 15 Wiki pages. Not just creating new ones, but also updating existing content, adding cross-references, and flagging areas that need further confirmation.

Query
You ask a question, and the AI synthesizes an answer from the Wiki. The key is: if the query itself produces valuable new integrations, the AI also writes them back into the Wiki. In other words, the more you use it, the richer the Wiki becomes.

Lint
This is an operation he specifically mentions, and I think it’s the smartest part of the scheme. The AI periodically performs a health check on the entire Wiki:

Are there two pages with contradictory content?
Are there statements that are outdated?
Are there orphan pages with no other pages linking to them?
Are there obviously missing cross-references?

Doing these things manually would be tedious and almost impossible to sustain. But for the AI, it’s pure grunt work.

The division of labor is as follows:

Humans are responsible for: curation (choosing what is worth including), critical judgment (is this conclusion correct?), supervision (periodically reviewing the AI’s updates)
AI is responsible for: bookkeeping—cross-references, consistency maintenance, orphan node cleanup, formatting

He uses the term: bookkeeping. This word is well chosen. It’s not about letting the AI think for you, but about handing over the maintenance tasks you know you should do but keep putting off, to the AI.

Why Obsidian Users Should Pay Special Attention

I’ve noticed something recently: some of my friends in the programming community, who were not interested in Obsidian before, have started using it one after another.

When asked why, the answers are mostly the same: because it’s so suitable for working with AI. Local files, plain Markdown, no lock-in—these used to be niche preferences, but now they’ve become advantages. Tools like Claude Code can directly read and write an Obsidian Vault without any extra configuration; what the AI can do, it can do directly.

Karpathy’s Gist, in a way, makes this even clearer.

I’ve been using Obsidian for a while myself, and after reading this Gist, I had a strong feeling:

The Wiki he describes is essentially an Obsidian Vault actively maintained by an AI.

Think about it: what is the core of Obsidian? A bunch of local Markdown files, connected by bidirectional links.

What is the core of LLM Wiki? A bunch of Markdown files, plus an AI that helps you create and maintain links, integrate content, and perform health checks.

The underlying medium is exactly the same. An Obsidian Vault is almost the most natural implementation of an LLM Wiki.

The things you do manually now—creating bidirectional links for notes, writing Maps of Content (MOCs), periodically organizing and archiving—a significant portion of these can be done by the AI as “bookkeeping work” in the LLM Wiki design.

Let me give you my own example: after I finish writing an article, the step of creating and organizing bidirectional links is now handled by a Skill. The AI scans my note vault, finds related articles, and automatically adds bidirectional links. I used to procrastinate on this step every time, but now I hardly worry about it.

Karpathy’s LLM Wiki just takes this further: not just running it once after writing an article, but keeping the entire knowledge base in a continuously maintained state, with Ingest, Query, and Lint all automated.

Of course, there are also voices that think this approach has problems.

Some in the tech community have drawn a comparison to Zettelkasten: traditional Zettelkasten emphasizes that the act of actively writing notes is itself the process of understanding—not collecting, but building connections through writing. If the AI summarizes and creates associations for you, doesn’t that understanding process disappear? You get a tidy knowledge base, but is there nothing in your brain?

This is a real question, and I think there is no standard answer.

But for Obsidian users, my own judgment is: these two things are not contradictory, provided you clarify which tasks are “truly need thinking” and which are “annoying bookkeeping.”

For example:

Reading an article, extracting core ideas, writing your own feelings and reflections → this is thinking, should be done by yourself
Checking which notes haven’t been linked in three months → this is bookkeeping, perfectly reasonable to delegate to AI
Synthesizing multiple sources under a concept → can have AI draft, you review
Maintaining frontmatter fields for a bunch of notes → this is pure grunt work, AI does it

The real risk is not that you stop thinking because you use AI, but that you equate “having the AI summarize this article” with “I have read this article.”

As long as you can distinguish this, the LLM Wiki approach is actually a quite valuable extension for Obsidian users.

Next Steps

Karpathy’s Gist is currently at the stage of “proposing a good pattern, but not providing an out-of-the-box tool.”

A few people in the community have started implementing this idea in different directions, but it’s still very early.

I plan to seriously upgrade my own setup: first reorganize my Obsidian note vault according to the LLM Wiki approach, then push my existing bidirectional link Skill further, trying to add Ingest and Lint logic to make it a more complete Skill.

Using Claude Code + Obsidian Vault, I’ll run through the entire process from start to finish—see what works, what the pitfalls are, and what needs redesign. If it works out, I’ll package the whole thing and share it, so others can use it directly without building from scratch.

The next chapter will cover this hands-on process.

Summary

What we learned today:

Karpathy is a deep learning researcher from Stanford, the leader of Tesla’s pure vision approach for Autopilot, and a co-founder of OpenAI, currently focused on AI education.
LLM Wiki is a pattern where “the AI actively maintains the knowledge base,” as opposed to passive retrieval in RAG.
The core architecture has three layers: Raw Sources → Wiki (collection of Markdown files) → Schema (structure definition).
Three operations: Ingest (ingest and update) / Query (query and write back) / Lint (health check).
The core division of labor: humans do curation and judgment, AI does “bookkeeping”—cross-references, consistency maintenance, orphan node cleanup.

Key takeaways:

An Obsidian Vault is itself a collection of Markdown files, highly consistent with the medium of LLM Wiki, making it almost the most natural implementation.
The bidirectional links and MOCs you manually create now are exactly the cross-references automatically maintained by AI in LLM Wiki.
Worrying about “AI thinking for you” is reasonable, but that’s different from having AI do “bookkeeping”—don’t conflate them.
This pattern currently has no out-of-the-box tool; you need to build it yourself.
The next chapter will walk through a hands-on implementation; if it works, it will be packaged as a Skill and shared.

Turn a Karpathy-Style Wiki into a Reusable Skill

Mon, 01 Jan 0001 00:00:00 +0000

The past couple of days have been a real struggle to get this skill working.

I started with Opus 4.6. I burned through more than $20. Still couldn’t get it to work. I even wondered if the new model that dropped on the morning of April 8, 2026 had sucked up all their compute. Otherwise, how could it understand one moment and then go off track the next?

Later I switched to Codex, and I did manage to build it.

But a new problem emerged: building it doesn’t mean it works reliably.

Especially when you start testing it seriously, it would occasionally ignore instructions and make changes on its own, which drove me crazy.

So in this article, I don’t just want to say “I built a skill, feel free to download it.”

I want to make something else clear: how to actually implement the LLM Wiki method Karpathy proposed in an Obsidian vault.

The previous chapter covered the method. This chapter is about practice.

If you want to download the current sanitized version of my skill, here’s the link:

https://blog.discoverlabs.ac.cn/downloads/obsidian-wiki-skill/

I’ve already removed the API keys, local paths, etc. But let me say this upfront: don’t copy it verbatim.

You can learn from this method. You can also modify this skill. But don’t expect it to work out of the box. Everyone’s note vault is too different.

What I built is not “AI organizing my notes,” but “AI doing my bookkeeping”

Let’s first revisit Karpathy’s Gist.

Original link:

https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f

The core idea is actually simple:

Most people currently use LLMs for document processing via RAG: dump a bunch of files in, and when querying, retrieve and generate answers on the fly.

That works, of course.

But the problem is that it’s all ad hoc.

Ask once, assemble once. Ask again, start from scratch. No accumulation.

So he proposed an intermediate layer: instead of assembling answers on the fly for each query, continuously maintain a Wiki.

When I read this, my first reaction wasn’t “this is cool.”

It was: isn’t this exactly the kind of task Obsidian is best suited for?

Because Obsidian is inherently a local Markdown file vault.

The Wiki Karpathy describes is essentially a collection of Markdown files.

The underlying format is almost identical.

The difference is:

Previously, you manually maintained backlinks, topic pages, and structure pages
Now AI helps you with this “bookkeeping” work

Note: bookkeeping, not thinking.

I increasingly agree with this.

Reading articles, making judgments, writing your own opinions—these are still for you to do.

But tasks like completing backlinks, normalizing author names, checking formatting, and refreshing derived pages are essentially grunt work. AI can handle them.

How I Implemented Karpathy’s Three-Layer Structure in Obsidian

The most important part of Karpathy’s method is the three layers:

Raw Sources
The Wiki
The Schema

My obsidian-wiki skill is also built around these three layers.

First Layer: Raw Sources

In my vault, this layer consists of:

01-Notes/
04-Output/

That is, raw collections, raw notes, and articles I’ve written.

I keep this layer very restrained.

Its only responsibility is to preserve the original content.

I don’t let it take on extra functions.

I don’t mix in derived content.

I don’t let a raw article become half topic page, half index page.

Because once mixed, it becomes hard to maintain.

This is one of the deepest lessons I learned while building this skill: the cleaner the raw layer, the easier everything else becomes.

Second Layer: The Wiki

This layer is separate in my vault:

01-Notes/wiki/

This holds the structural layer derived by AI, such as:

Author pages
Topic pages
Index
Log
Backlink directory

In other words, the original text remains the original text.

The Wiki is the Wiki.

The two layers are separate.

This sounds trivial, but it’s actually very important.

Because if you don’t separate layers, every time AI organizes, it tends to make the original text messier.

Today it adds a topic block.

Tomorrow it inserts an index.

The day after, it adds an auto-generated summary.

Eventually, the whole vault looks like a room that’s constantly being tidied but gets messier.

Third Layer: The Schema

Many people overlook this layer.

Karpathy mentions schema in his original post. My understanding is: you need to tell AI what the vault should look like.

In my case, this includes:

SKILL.md
A bunch of scripts/
Frontmatter conventions
Constraints on how authors and topics are written
Process constraints for lint and ingest

For example, I now enforce:

Authors must be in backlink format
Topics must be a backlink list
Author pages and topic pages can only go in 01-Notes/wiki/
00-Inbox/ is only a processing inbox, not directly mixed into the Wiki
Raw articles no longer contain derived paragraphs

You’ll find that what makes the skill work isn’t how beautifully the prompt is written. The real key is that these constraints are established first.

Translating the Three Actions into Runnable Workflows

Karpathy also has three core actions:

Ingest
Query
Lint

I followed the same approach.

In terms of the actual workflow in this skill, it looks like this:

Ingest: wiki_lint.py --preflight + ob_shuanglian.py suggest/apply + wiki_ingest.py
Query: First read wiki/index.md, authors/*.md, topics/*.md, then go back to original text for details
Lint: wiki_lint.py, wiki_migrate.py, wiki_build_skeleton.py

Ingest: Check new content before adding it to the vault

I don’t let AI “see an article and improvise” right away.

My current workflow starts with a preflight check.

First check if the frontmatter is correct.

Then check for historical contamination.

Then make backlink suggestions.

After user confirmation, actually apply.

Finally, refresh the Wiki derived layer.

Why go through all this trouble?

Because the models have taught me many times.

If you don’t add these guardrails, it will eagerly “make decisions” for you.

The problem is, its decisions may not be what you want.

So I added strong confirmation gates.

Don’t let it write topics arbitrarily.

Don’t let it apply backlinks directly.

Don’t let it decide on author aliases on its own.

Give suggestions, I confirm, then write.

This may seem less efficient.

But with a knowledge base, the biggest fear isn’t slowness; it’s quietly writing something wrong.

Query: Not fishing in the sea of original text, but reading the Wiki layer first

For queries, my approach is not “search the entire vault and hand it to AI for summarization.”

Instead, it first goes through:

wiki/index.md
authors/*.md
topics/*.md

Let AI look at the structured layer first.

When necessary, go back to specific articles for details.

The benefits are clear:

It doesn’t have to reassemble from scattered original text every time.

Instead, it answers from an already organized layer.

This is closer to what Karpathy means by “accumulation.”

Lint: The most important and most underestimated step

Many people focus on Query when they see LLM Wiki.

But the more I work on it, the more I feel that Lint is where the real value lies.

Because once the knowledge base grows, your biggest headache isn’t “can’t get answers,” but:

Frontmatter is messy
Author names are inconsistent
Topics are scattered
Historical structures remain in original text
Derived pages grow increasingly distorted
The same concept appears under several different names

If you try to maintain these manually, it’s maddening.

And you won’t be able to keep it up.

This is exactly what AI is best at.

Not understanding the world for you.

But patrolling the vault, reconciling, finding dirty data, and filling in cross-references.

That’s why Karpathy’s term is so apt: bookkeeping.

The Real Pitfall Isn’t the Model, It’s My Old Note Vault

This is also what I most want to warn everyone about.

Many people read an article like this and instinctively think:

“Oh, I can just download the skill, install it, and AI will manage my knowledge base.”

That’s not the case.

The biggest challenge with this skill isn’t the prompt, the scripts, or even the model.

It’s that I have too many old notes, and their formats are inconsistent.

When I run lint now, here’s the scale I see:

Article-type Raw Sources: 457
Total Raw files: 833
Pending queue: 249
The backlink directory already has 471 topics

Think about that volume.

This is no longer about “organizing a few notes.”

It’s more like taking over an old system with a long history and no consistent standards.

Some articles have full author names.

Some have aliases.

Some topics are very detailed.

Some are very scattered.

Some old files still contain remnants of previous structures.

So I became increasingly certain of one thing:

If you want to build an LLM Wiki, the first step isn’t to let AI take over. The first step is to clean up your vault to a state “worth taking over.”

Otherwise, the more diligent AI is, the more it spreads the mess.

So What Extra Things Does This Skill Actually Do?

If you only read Karpathy’s original post, you’d think it’s a very elegant methodology.

But when actually building it, I found many engineering details to fill in.

For example:

Frontmatter standardization
Author alias normalization
Enforcing backlink format for topics
Completely separating raw and derived layers
Using 00-Inbox/ as a processing inbox
Adding user confirmation gates at key steps
Breaking down the workflow with scripts like lint, migrate, ingest

It’s not that Karpathy didn’t think of these.

It’s that his Gist describes a pattern, not the specific implementation for your vault.

When actually implementing, you must fill in this layer yourself.

My current obsidian-wiki skill is essentially doing this:

Translating an abstract pattern into a workflow that runs on my own Obsidian vault.

So if you download it, the most important thing to learn isn’t “copy my directory structure.”

It’s to understand why I layered things this way, why confirmation is needed here, why lint is done here, why auto-apply isn’t used here.

If You Want to Do This Too, Modify These Things First

I’ve put the sanitized version on my blog’s download page:

https://blog.discoverlabs.ac.cn/downloads/obsidian-wiki-skill/

But after downloading, the first thing isn’t to run it.

It’s to modify it.

At least check these things:

Is your vault path the same as mine?
Is your 01-Notes/, 04-Output/, 00-Inbox/ structure the same?
Are your frontmatter fields consistent with mine?
Are your author names and topic names already fairly consistent?
Do you want to keep my “suggest, confirm, then write” workflow?
If the scripts involve APIs, have you replaced them with your own keys?

The version I released has already sanitized API keys and local paths.

After you get it, you must adapt it to your own environment.

And I still recommend: don’t treat my method as a template, just as a reference.

If your vault is mainly reading notes, the rules may differ from mine.

If your vault is mainly project notes, the granularity of topics will differ.

If your vault is still in the “collect first, organize later” phase, you probably shouldn’t focus on Query first, but should get Lint and Ingest running smoothly.

So don’t copy verbatim.

Modify based on the approach, that’s more reliable.

Summary

By the end of this article, my own feeling has become clearer.

Karpathy’s proposal is not just an idea that “AI can help you organize your knowledge base.”

Its real value is that it redefines the division of labor between humans and AI in knowledge management.

Humans handle judgment.

AI handles bookkeeping.

The more I work on this, the more I believe in that statement.

What I learned today:

The key to Karpathy’s LLM Wiki is the three-layer structure and three operations, not a single prompt
The key to skills like obsidian-wiki isn’t “can it summarize,” but whether it can separate Raw Sources, Wiki, and Schema
In practice, Lint is often more important than Query, because historical data cleanup is the bulk of the work
The more old notes and the messier the format, the less you should directly copy someone else’s skill
Downloading a skill is easy; the real challenge is adapting it to fit your own knowledge base

Key takeaways:

AI is best suited for bookkeeping, not thinking for you
Raw and derived layers must be separated, otherwise the knowledge base gets messier the more you organize
User confirmation gates are not extra steps; they are necessary guardrails to prevent AI from acting on its own
Standardize formats first, then talk about automation; if you reverse the order, you’ll suffer later
This skill can be modified, but it’s not recommended to copy it as-is

Why I Recommend Obsidian

Mon, 01 Jan 0001 00:00:00 +0000

Obsidian is a tool worth considering for anyone serious about their knowledge.

Let me start with a bold claim:

If I could only use one note-taking app for the rest of my life, I would choose Obsidian.

What is Obsidian?

In a nutshell: Obsidian is a local-first Markdown note-taking app.

Let’s break that down into three key points:

Local-first: Your notes are stored on your own computer as .md files. No internet required, no server dependency.
Markdown: Standard Markdown syntax works directly in Obsidian. Every note you write is a standard Markdown file.
Note-taking app: But it’s more than just note-taking. You can build a knowledge base, write articles, manage projects, or even use it as a blog editor.

You can think of Obsidian as a powerful local editor designed specifically for Markdown.

Wait, why talk about note-taking apps?

Good question. Why spend time in a guide about Obsidian discussing “why choose a note-taking app”?

It matters a lot.

First, AI needs a local knowledge base.

Your conversations with ChatGPT, Claude, and others are stored on someone else’s servers. If the service shuts down, your account gets banned, or chat history is cleared—it’s gone. You need a local place to preserve valuable conversations and content.

Moreover, AI needs to be “fed.” The more organized material you give AI, the better the results. A well-organized local note library is the most powerful arsenal for your collaboration with AI.

Second, output is the most crucial part of knowledge accumulation.

Many people’s learning style is: read → bookmark → think they know it → actually remember nothing.

Reading without writing is equivalent to not learning. You need to write things down, reorganize them in your own words, for knowledge to truly become yours. That’s what Obsidian does—it helps you turn fragmented information into systematic knowledge.

I’m using Obsidian to manage all my material right now. The chapter you’re reading was written in Obsidian.

So a note-taking app is not the opposite of AI; it’s the infrastructure for your AI workflow.

Why Obsidian?

There are plenty of note-taking apps out there: Notion, Evernote, Feishu Docs, Yuque… Why specifically recommend Obsidian?

Many people use Notion, and it’s indeed good. But after comparison, I still chose Obsidian.

	Obsidian	Notion
Data Storage	Local files, your own hard drive	Cloud, stored on Notion’s servers
File Format	Standard Markdown (.md files)	Proprietary format, exportable but lossy
Offline Use	Fully supported	Supported but mediocre experience
Speed	Very fast (local operations)	Depends on internet speed
Free Tier	Core features completely free	Free tier has limitations
Plugin Ecosystem	2000+ community plugins	Mostly official integrations
AI Tool Integration	Local files, AI can read/write directly	Official paid service
Data Security	Data is in your hands	Data is in someone else’s hands

The most critical point: data is in your own hands.

Notion’s notes are stored on its servers. If the service shuts down, policies change, or they suddenly start charging—your notes become hostages.

I’m also a heavy Notion user, but after putting a 130,000-word novel into a page and ending up unable to open or export it, I realized that local is truly your own.

Of course, Notion has its unique strengths and can complement Obsidian. We’ll talk about that later.

Obsidian’s data is just a folder on your computer. Even if Obsidian the software goes out of business tomorrow, your notes remain—you can open them with any text editor.

Your knowledge base is one of your most important digital assets. Don’t leave it in someone else’s hands.

Five Core Advantages

1. Bidirectional Links: “Hyperlinks” Between Notes

This is Obsidian’s most famous feature.

Ordinary note-taking apps just record notes without connections between them. But real knowledge isn’t isolated—economics and psychology intersect, programming thinking can be applied to writing, an article you read yesterday might relate to an idea from last week.

Obsidian’s bidirectional links (backlinks) allow you to reference another note from any note. In reading mode, backlinks don’t show the [[]] brackets, only a change in font color, so you don’t have to worry about it looking ugly:

Today I learned about [[Feynman Technique]], the core idea is to test your understanding by teaching someone else.

Feynman Technique becomes a clickable link that takes you to that note. What’s even more powerful—in the “Feynman Technique” note, you can also see which notes have linked to it. The value of backlinks: your notes are no longer isolated documents, but an interconnected knowledge network. The more you write, the denser the network becomes, and the more you discover connections you hadn’t noticed before.

You can even see the relationships between all your notes in the graph view, like a galaxy!

2. Local Storage: Data Always in Your Hands

As mentioned earlier, Obsidian notes are just .md files in a folder.

This means:

Won’t get lost—you can back them up any way you like (iCloud, OneDrive, even a USB drive)
No vendor lock-in—when switching apps, just move the folder
AI can read and write directly—this is extremely important, more on this later

3. Plugin Ecosystem: Whatever Feature You Need

Obsidian has over 2,000 community plugins. Almost any need you can think of has been addressed:

Calendar plugin: Manage daily notes and journals by date
Kanban plugin: Turn notes into a task management board
Database plugin: Give Obsidian database capabilities similar to Notion
AI plugin: Call AI conversations directly within Obsidian
Publish plugin: Sync notes to a blog with one click

You don’t need to install plugins from the start. First, write notes with the native features, then look for plugins when you have specific needs.

4. Cross-Platform Support: Seamless Switching Between Devices

Windows, macOS, Linux, iOS, Android—Obsidian supports them all.

And because notes are just regular folders, you can place them in an iCloud or OneDrive sync directory, and all devices will sync automatically and quickly. Notes written on your computer are immediately visible on your phone; inspiration captured on your phone during the commute is there when you open your computer at home.

No need to pay for the official sync service—just use your existing cloud drive.

5. Completely Free

Obsidian’s core features are completely free for personal use.

It has two paid services:

Obsidian Sync (official cloud sync): $4/month—but you can completely replace it with free alternatives like iCloud or OneDrive
Obsidian Publish (publish as a website): $8/month—but you can use free solutions like Hugo instead

Actual cost of use: $0.

Why Does Obsidian Work So Well with AI?

This is the core reason for recommending Obsidian in an Obsidian tutorial.

First, AI can directly operate on your notes.

Because Obsidian notes are local .md files, AI tools (like Claude Code) can directly read and edit these files. You can have AI help you organize notes, generate summaries, batch modify formatting, and extract key information from notes.

Notion isn’t completely incapable—it can handle this through the MCP protocol or official Notion AI, but MCP has a high configuration threshold and isn’t very convenient; the official AI requires an additional fee. With Obsidian’s local files, AI can use them directly with zero barrier.

Second, your note library is AI’s material library.

The reading notes, article excerpts, and ideas you accumulate daily can all be fed to AI as context. The more notes you accumulate and the better organized they are, the more accurate AI’s results will be.

For example, the writing process of this guide involved me giving AI the material I had accumulated in Obsidian, and we completed it together. Without a material library, relying solely on AI to write from scratch would result in much lower quality.

Third, Markdown lossless integration.

AI’s input and output are both Markdown. Obsidian is natively Markdown. This means:

Content output by AI, when pasted directly into Obsidian, becomes formatted notes
Notes in Obsidian, when given directly to AI, are perfectly understood
No format conversion hassles like with Word—zero loss

How to Download?

Official website: obsidian.md Supports all major platforms: Windows, macOS, Linux, iOS, Android. Open the official website, click “Download”, select your system, and install it just like any other software.

We’ll cover setup and getting started in detail in the next chapter.

Summary

What you learned today:

What Obsidian is: A local-first Markdown note-taking app, data stored on your own computer
Why an Obsidian guide talks about AI: AI needs a local material library, output is key to knowledge accumulation
Why choose Obsidian: Data in your hands, AI can operate directly, completely free
Five core advantages: Backlinks, local storage, plugin ecosystem, cross-platform, free
Why it works well with AI: Local files AI can read/write directly, note library = material library, Markdown lossless
How to download: obsidian.md, choose your platform and install

Key takeaways:

If you can only choose one note-taking app, choose Obsidian
Data in your own hands is the most important principle
Obsidian + AI = your personal knowledge engine

Obsidian Handbook on RanceLee的博客

AI Collaboration in Obsidian: From Conversation to Action

Directly Give AI the File Path

Obsidian CLI

How to Use

Skill: Turn a Workflow into a Single Command

Summary

Claudian: Put Claude Code in the Obsidian Sidebar

How the Plugin Approach Differs from Using the Terminal Directly

What is Claudian

How to Install

What Claudian Can Do

Sidebar Chat, Directly Operate on Your Vault

Automatically Aware of the Current Note

Inline Edit: Select Text and Edit Directly

Image Support

Slash Commands

Plan Mode

Permission Modes

Model Selection

Summary

Clip YouTube Videos into Obsidian

First, a Quick Refresher on Web Clipper

Entering YouTube Clipping Mode

What This Interface Offers

After Saving to Obsidian

What If You Don’t Understand English?

Unfortunately, Bilibili Is Not Supported

What We Learned Today

Key Takeaways

Command Plugin: Customize Your Context Menu

Install the Commander Plugin

Open the Plugin Settings

Access the Editor Menu

Search and Select a Command

Name the Command

See the Result

Summary

Create Your First Obsidian Vault

What is a Vault?

Why Create Multiple Vaults?

How to Create a Vault

Apple Ecosystem Users (Recommended)

Windows / Android Users

What Does the Obsidian Interface Look Like?

Left Sidebar: File Management

Center: Editor Area

Right Sidebar: Info Panel

Write Your First Note

Connect Your Notes with Backlinks

Edit View vs. Reading View

How to Insert Images

Where Are Images Stored?

Recommended Attachment Settings

Better Solution: Image Hosting Service

Summary

Custom CSS: Make Obsidian Feel Like Your Own

What is CSS

Why Still Need CSS with a Theme?

No Need to Write It Yourself—Let AI Write It for You

Where to Put the CSS? How to Make It Work?

How I Use CSS Myself

Summary

Daily Notes: The First Habit for Obsidian Beginners

Why Write Daily Notes

Step 1: Enable the Daily Notes Core Plugin

Step 2: Configure Daily Notes

Step 3: Create a Daily Note Template

Step 4: Start Writing Daily Notes

Summary

Excalidraw in Obsidian: Hand-Drawn Diagrams in Notes

What is Excalidraw and How is it Different from Canvas?

What is Excalidraw?

Differences from Canvas

Installing the Excalidraw Plugin

Creating and Using Excalidraw

How to Create a New File

Common Operations and Shortcuts

Keyboard Workflow: Drawing Without Leaving the Keyboard

Adding Content to the Canvas