One-Click WeChat Formatting in Obsidian: From Writing to Draft Publishing

Many creators already write in Obsidian, but the steps after writing are still fragmented:

• manual formatting
• manual cover handling
• manual image upload
• manual copy-paste into the WeChat backend
• manual draft creation

This guide focuses on a more complete path:

keep writing in Obsidian, bring an agent into the vault with Claudian, and let md2wechat handle formatting, cover generation, asset upload, and draft creation.

Screenshot: Obsidian to WeChat workflow

What this combination actually is

Obsidian is already a strong local Markdown writing environment for:

• long-form writing
• note and source management
• topic organization
• knowledge-base style content work

Screenshot: What Obsidian is

Claudian is a community plugin that brings a Claude Agent into Obsidian itself.

Once installed, your vault becomes an agent workspace. The agent can:

• read the current note
• write files
• run commands
• call installed CLI tools

Screenshot: Claudian in Obsidian

With md2wechat added on top, the responsibility split becomes very clear:

• Obsidian for writing
• Claudian for bringing the agent into the vault
• md2wechat for formatting, covers, assets, and WeChat draft publishing

That means the workflow no longer needs to jump across multiple tools after the article is written.

How this differs from the existing Obsidian posts

This site already has earlier Obsidian-related posts that explain:

• the general Obsidian-to-WeChat path
• how to install and use md2wechat-skill inside Claudian

This article is narrower and more practical.

Its focus is:

how to move from an Obsidian Markdown draft into an actual WeChat draft entry with as little manual work as possible.

Step 1: install the md2wechat CLI

On macOS, the most direct path is still Homebrew:

brew install geekjourneyx/tap/md2wechat
md2wechat version --json

If version output appears, the CLI layer is installed correctly.

Screenshot: Install md2wechat CLI

This order matters.

The skill layer is not a replacement for the CLI. One of the most common failures is:

• the skill appears installed
• the UI looks ready
• but the underlying command is still missing

So the rule is still:

install the CLI first, then install the skill.

Step 2: install the md2wechat skill

Next, install the skill definition:

npx skills add https://github.com/geekjourneyx/md2wechat-skill --skill md2wechat

This gives the agent a reusable skill layer, but it does not install the CLI binary itself.

Screenshot: Install md2wechat skill

Screenshot: Select skill directory

If you want the installation-focused companion guide, continue here:

• How to Use md2wechat-skill Inside Claudian in Obsidian

Step 3: install the Claudian plugin

If Claudian is not installed yet, download the latest release from GitHub:

• GitHub: YishenTu/claudian

Place the plugin files into the Obsidian plugin directory, restart Obsidian, and enable it.

Screenshot: Install Claudian

At that point, the runtime layers are in place:

• Obsidian for writing
• Claudian for agent execution
• md2wechat for publish-related actions

Step 4: configure first, do not jump straight to draft creation

Open the Claudian sidebar, but do not start with “publish this draft.”

Start with configuration.

Screenshot: Open Claudian sidebar

Ask the agent to run:

That should guide you through:

• WeChat AppID
• WeChat AppSecret

If you also want automatic cover generation, add an image provider configuration as well, such as:

• ModelScope
• OpenRouter

Screenshot: Initialize config

After configuration, validate the runtime instead of guessing.

A safer approach is to run discovery-style checks first:

• md2wechat capabilities --json
• md2wechat themes list --json
• md2wechat providers list --json

If the environment can answer what it supports, you are no longer running blind.

Screenshot: Verify capabilities

Step 5: trigger formatting from inside Obsidian with one instruction

Now go back to the article you wrote in Obsidian.

Instead of manually chaining commands, start with a complete agent instruction such as:

If the configuration is complete, the workflow can continue into:

• reading the current Markdown note
• formatting it with md2wechat
• generating a cover or cover prompt
• uploading assets
• creating a WeChat article draft

Screenshot: Run md2wechat in Claudian

This is where the combination becomes genuinely useful:

writing still happens in Obsidian, but the post-writing operations no longer have to move through multiple manual tools.

What should appear in the WeChat draft box

If the run succeeds, the WeChat backend draft box should contain:

• formatted article body
• processed cover
• uploaded image assets
• the new draft entry itself

Screenshot: Draft created in WeChat

That distinction matters.

It means the workflow is not only converting Markdown into HTML. It is advancing the content into a reviewable, publish-ready draft state.

What still needs improvement in real use

This workflow is based on real use, not only on a polished demo.

In practice, I still saw a few issues worth improving:

1. some summary tasks did not emphasize length limits clearly enough
2. when summary text gets too long, the current workflow needs a clearer fallback behavior
3. local images should be more consistently replaced with actual WeChat media assets before final draft submission

Screenshot: Known issues

These are not “the workflow does not work” problems.

They are exactly the kind of details that show up when a workflow moves from “can run” to “can run reliably.”

Why this path matters long term

Once this workflow is in place, one thing changes immediately:

the most repetitive and interruption-heavy tasks after writing can finally be delegated to the agent.

That leaves more time for the parts humans should still own:

• topic judgment
• editorial opinion
• structure
• the content itself

Instead of:

• copying
• pasting
• styling
• re-uploading images
• creating drafts manually

This is also why I keep building around workflow layers rather than isolated features.

Where this article fits in the broader content pipeline

If you split Agent content creation into three stages:

• front stage: source retrieval
• middle stage: topic and draft creation
• back stage: formatting and publishing

then this article is about the last stage, the point closest to a usable publishing loop.

For the full chain, read these together:

• Retrieval layer: What jina-cli Is
• Toolchain overview: From Content Retrieval to WeChat Drafts
• Judgment layer: How to Design an Agent Content Topic Selection Workflow

Closing thought

If you already write in Obsidian, the stronger path is usually not to leave Obsidian.

It is:

1. keep writing Markdown in Obsidian
2. bring the agent into the vault with Claudian
3. use md2wechat for formatting, covers, assets, and WeChat drafts

That gives you more than “Obsidian can publish to WeChat.”

It gives you a workflow where the messy post-writing steps are finally handled by the system instead of by repeated manual work.

Related Links

• Project: geekjourneyx/md2wechat-skill
• Website: md2wechat.com
• ClawHub: clawhub.ai/geekjourneyx/md2wechat
• Claudian: YishenTu/claudian
• Original WeChat article: Read the original