OpenCode on Yanmu

OpenCode + Obsidian: Build Your AI-Powered Knowledge Management Workflow

Thu, 30 Apr 2026 02:00:15 +0800

📋 Table of Contents

1. What is the opencode-obsidian Plugin?

opencode-obsidian is a third-party community plugin that embeds the OpenCode AI assistant directly into the Obsidian window. Unlike traditional terminal integration solutions, this plugin uses OpenCode’s Web view for direct embedding — what you see is the complete OpenCode interface, with no need to switch back and forth between terminal and Obsidian.

Core Features:

🖥️ OpenCode interface directly embedded in Obsidian sidebar or main editor
🔄 Automatic server management — starts when panel opens, stops when closed
📄 Experimental context injection — automatically passes current notes and selected text to AI
⌨️ Shortcut Ctrl/Cmd + Shift + O for quick panel toggle

Use Cases:

Summarizing and distilling long-form content
Drafting, editing, and polishing writing
Querying and exploring your knowledge base

Generating outlines and structured notes

⚠️ The plugin author is not affiliated with OpenCode or Obsidian — this is an independent third-party project. Current version is 0.2.1 (Beta stage), desktop only.

2. Environment Preparation

Before starting, ensure you have the following ready:

Item	Requirement	Notes
Obsidian	≥ 1.4.0	Download
Node.js	≥ 18+	Download, for OpenCode installation

Once ready, follow the steps below.

3. Installing the BRAT Plugin

BRAT (Beta Reviewer’s Auto-update Tool) is an Obsidian community plugin specifically for installing Beta plugins not yet listed in the community plugin marketplace. opencode-obsidian isn’t officially listed yet, so installation via BRAT is required.

Step 1: Open Community Plugin Marketplace

In Obsidian, click: Settings → Third-party plugins → Turn off “Safe mode” → Community plugin marketplace

Step 2: Search and Install BRAT

Search for BRAT (full name: Obsidian42 - BRAT) in the community marketplace, click “Install” → “Enable”.

💡 BRAT stands for Beta Reviewer’s Auto-update Tool, developed by TfTHacker. It automatically checks for Beta plugin updates and notifies you to upgrade.

4. Installing opencode-obsidian via BRAT

Once BRAT is installed, use it to install the opencode-obsidian plugin.

Step 1: Open BRAT Settings

Settings → Third-party plugins → Find installed BRAT, click the gear icon on the right to enter settings.

Step 2: Add Beta Plugin

In the BRAT settings page, click the “Add Beta plugin” button.

Step 3: Enter Repository Address

In the popup input box, enter:

`1`	`mtymek/opencode-obsidian`

Click “Add Plugin”.

BRAT will automatically pull the latest release version from GitHub and install it.

Step 4: Enable the Plugin

After installation, go to Settings → Third-party plugins → Find OpenCode-Obsidian in the “Installed plugins” list and toggle it on.

✅ Once enabled, a terminal-style icon appears in Obsidian’s left sidebar — this is the OpenCode entry point.

Auto-Update

BRAT periodically checks GitHub for new versions. When an update is available, it shows a notification in Obsidian — just click to confirm and auto-upgrade.

5. Installing OpenCode CLI

The plugin itself is just a “shell” — it starts opencode serve in the background and embeds OpenCode’s web interface into Obsidian. So you only need to install the OpenCode CLI via npm.

Open your system terminal (PowerShell for Windows, Terminal for macOS/Linux):

`1`	`npm i -g opencode-ai`

Verify installation:

1
2

opencode --version
# Expected output like: 1.14.39

⚠️ Windows users: If the plugin shows “Executable not found at ‘opencode’”, jump to Section 10 for the solution.

6. Plugin Settings Explained

After enabling the plugin, go to Settings → Third-party plugins → OpenCode-Obsidian gear icon to see these configuration options:

Basic Settings

Setting	Default	Description
OpenCode executable path	`opencode`	Enter full path if not found in system PATH
Port	`14096`	Port number the OpenCode service listens on
Hostname	`127.0.0.1`	Address the service binds to
Project directory	(Auto from Vault path)	Working directory for OpenCode
Startup timeout	`45000` (45s)	Max milliseconds to wait for service startup

Interface Settings

Setting	Default	Description
Default view position	`sidebar`	`sidebar` = sidebar, `main` = main editor area
Auto-start	`Off`	Auto-start OpenCode service when Obsidian opens

Context Injection (Experimental)

Setting	Default	Description
Inject workspace context	`Off`	Auto-pass current note info to OpenCode
Max notes	`20`	Maximum notes included in context
Max selection length	`2000`	Character limit for text passed to AI

Custom Commands

Setting	Default	Description
Use custom command	`Off`	Enable to customize OpenCode launch command
Custom command	(empty)	Custom launch command (see Section 9)

7. First Use

Opening the OpenCode Panel

Three ways to open OpenCode:

Click sidebar icon: Click the terminal icon in the left sidebar
Shortcut: Ctrl + Shift + O (macOS: Cmd + Shift + O)
Command palette: Ctrl/Cmd + P → type Toggle OpenCode panel

First Launch Flow

After opening the panel, the plugin automatically:

Detects the OpenCode executable path
Starts the OpenCode service (opencode serve)
Loads the OpenCode interface in an embedded web view

Once started, you’ll see the complete OpenCode dialog interface — type prompts directly.

Verify Everything Works

In the OpenCode interface, type:

/help

If you see the command list, everything is working. You can also type:

/models

to view available AI models. OpenCode has built-in free models (GLM-4.7, MiniMax-2.1) — no configuration needed.

Shortcut Reference

Shortcut	Function
`Ctrl/Cmd + Shift + O`	Toggle OpenCode panel

8. Context Injection (Experimental Feature)

This is one of the opencode-obsidian plugin’s most unique features — it can automatically pass Obsidian’s working context to OpenCode.

How to Enable

In plugin settings, toggle on “Inject workspace context”.

What Gets Injected

When enabled, the plugin automatically passes this information to the running OpenCode instance:

📂 Currently open notes list: Which files you’re editing
📝 Selected text: Text you’ve highlighted in notes

Use Cases

Select some text, open the OpenCode panel, say “polish this paragraph” — AI already knows which text you mean
Open multiple notes, ask AI “compare the differences between these two notes” — AI already knows which files are open

Limitations

⚠️ This is an experimental feature with some current limitations:

Context doesn’t auto-inject when creating a new Session in the OpenCode interface

Context updates have some latency

9. Custom Command Mode

By default, the plugin calls opencode serve to start the service. If you need more control, enable custom command mode.

When Do You Need Custom Commands?

Adding extra CLI arguments
Using custom startup scripts
Running OpenCode through containers or virtual environments
OpenCode installed in non-standard paths

Configuration Steps

In plugin settings, turn on “Use custom command”
Enter the complete command in the “Custom command” input field

Command Template

`1`	`opencode serve --port 14096 --hostname 127.0.0.1 --cors app://obsidian.md`

⚠️ Important Notes

Port and hostname must match the values in settings
Must include --cors app://obsidian.md — otherwise Obsidian cannot embed the OpenCode web interface

10. FAQ and Troubleshooting

❌ OpenCode Executable Not Found

Symptom: Panel shows “Executable not found at ‘opencode’”, but opencode works fine in terminal.

Cause: Electron (Obsidian’s underlying framework) doesn’t fully inherit system PATH environment variables on Windows.

Solution:

Find the full path of opencode.cmd in terminal:

`1`	`where opencode.cmd`

Paste the full path into the plugin setting “OpenCode executable path”, e.g.:

`1`	`C:\Users\YourUsername\AppData\Roaming\npm\opencode.cmd`

❌ Service Startup Timeout

Possible causes: Network issues, slow model loading, port in use.

Solution:

Check if port 14096 is occupied by another program
Try changing the port number (e.g., to 15096)

Increase the startup timeout

❌ Panel Shows Blank

Possible cause: CORS configuration incorrect.

Solution:

If using a custom command, ensure it includes --cors app://obsidian.md.

❌ Panel Cannot Embed

Possible cause: OpenCode version too old.

Solution:

`1`	`npm i -g opencode-ai@latest`

❌ Chinese Filename Garbled (Windows)

Solution: Run in PowerShell:

`1`	`chcp 65001`

Then restart Obsidian.

❌ Plugin Needs Reconfiguration After Update

BRAT preserves your settings data when updating. If settings are lost, just re-enter the settings page to reconfigure.

Summary

The entire installation flow in one diagram:

┌──────────────────────────────────────────┐
│         Install BRAT Plugin              │
│   Settings → Community marketplace       │
│   → Search BRAT → Install               │
└──────────────────┬───────────────────────┘
                   │
                   ▼
┌──────────────────────────────────────────┐
│    Install opencode-obsidian via BRAT    │
│   BRAT Settings → Add Beta plugin        │
│   Enter: mtymek/opencode-obsidian        │
└──────────────────┬───────────────────────┘
                   │
                   ▼
┌──────────────────────────────────────────┐
│         Install OpenCode CLI             │
│   npm i -g opencode-ai                  │
└──────────────────┬───────────────────────┘
                   │
                   ▼
┌──────────────────────────────────────────┐
│       Enable plugin, start using         │
│   Ctrl+Shift+O to open panel             │
│   Use OpenCode directly in Obsidian      │
└──────────────────────────────────────────┘

One-line summary: Install BRAT → Search mtymek/opencode-obsidian → Install OpenCode CLI → Ctrl+Shift+O and you’re set. It’s that simple.

📚 Sources:

opencode-obsidian GitHub Repository

BRAT Plugin GitHub Repository

OpenCode Official Documentation

OpenCode Beginner to Advanced: A Complete Guide to Parallel Scheduling and Usage Tips

Thu, 30 Apr 2026 02:00:15 +0800

📋 Table of Contents

📌 Key Points Summary

Feature	One-Line Description
Session Parallelism	OpenCode’s killer feature — multiple tasks running simultaneously, no interference, double efficiency
Ultra Work Mode	Type `ULW`, the main agent auto-breaks tasks and dispatches sub-agents to work in parallel
@ Designate Agent	Let the frontend expert do frontend, the architect do reviews — everyone does what they’re best at
Timeline Time Machine	Roll back to any historical checkpoint anytime, zero-cost experimentation
Ralph Loop	Let AI work in loops for hours, tackling the hardest tasks

1. Session Parallelism: Let AI Handle Multiple Tasks Simultaneously

This is OpenCode’s greatest differentiating advantage over other AI programming tools. Traditional tools can only work sequentially — one task must finish before the next begins. OpenCode can run multiple Sessions simultaneously without interference.

Basic Operations

/new              # Create a new Session
/sessions         # View all Session statuses (spinning = running)
/session <id>     # Switch to a specific Session
/session prev     # Return to the previous Session

Real-World Scenario

Suppose you’re developing a “Draw and Guess” game with two independent requirements:

Requirement A: Add a timer that starts on first brush stroke, game fails after 20 seconds
Requirement B: Brush color adjustment

Traditional Approach

Finish A first, then B → Requirement B waits 5-10 minutes for nothing.

OpenCode Approach

1. Enter requirement A, AI starts working
2. Enter /new, create a new Session
3. Enter requirement B, AI starts working
4. Enter /sessions to check progress:

   Session 1  ◐  Adding timer logic...
   Session 2  ◐  Adding color picker...

Both requirements developed in parallel, total time compressed from 15 minutes to 8 minutes.

Notes

⚠️ Sessions are completely isolated — modifying the same file may cause conflicts, assign to different modules
⚠️ Background Sessions don’t auto-notify completion, manually check with /sessions
✅ You can /new anytime to open a third, fourth… no limit

2. Ultra Work: One-Click AI Programming Team

If Session parallelism is “manual transmission,” then Ultra Work is “full self-driving.” Enter a magic word and AI automatically splits tasks, assigns them to the most suitable agents, and executes in parallel.

Trigger Method

Include any of these keywords in your prompt:

1
2
3

ULW
ultrawork
Ultra Work

How It Works

Your requirement: Help me build a pet store website
        │
        ▼
  ┌─────────────────────────────┐
  │  Sisyphus (Main Agent)       │
  │  1. Break down → Todo List   │
  │  2. Assign subtasks          │
  └──────┬──────────┬───────────┘
         │          │
    ┌────▼───┐ ┌───▼────┐ ┌────────▼────┐
    │ Prophet │ │ Frontend│ │ Doc Writer  │
    │ Arch.   │ │ UI Dev  │ │ Docs Gen    │
    └────────┘ └────────┘ └─────────────┘
         │          │            │
         └──────────┴────────────┘
                    │
                    ▼
              Complete Project Delivery

Auto-split into Todo List
Launch 3 background tasks running in parallel
Main agent orchestrates from center
Final delivery of complete project

When to Use?

Scenario	Suitable	Notes
Create complete project from scratch	✅ Excellent	Auto-splits frontend, backend, docs
Multi-module parallel development	✅ Excellent	Clear agent division of labor
Single-file small changes	❌ Not recommended	Overkill, actually slower
Simple bug fix	❌ Not recommended	Regular chat is faster

💡 The higher the complexity, the greater Ultra Work’s value. Simple tasks get slower due to scheduling overhead.

Actual Results

Used Ultra Work mode to create a pet store website:

✅ Used emojis as decorations with no image assets
✅ Clean interface, smooth interactions, complete animations

3. @ Designate Agent: Let Experts Do What They Do Best

After installing Oh My OpenAgent (OMO), you have an AI programming team. Use @ to call specific agents.

Agent Capability Table

Agent	Specialty	Best Model	Example Usage
🧠 Sisyphus	Planning, task orchestration	Claude Opus	Complex multi-step tasks
🔮 Prophet	Architecture design, code review	GPT 5.5	Project structure design
🎨 Frontend Engineer	UI development, page layout	Gemini 3 Pro	Responsive layout optimization
🔍 Explorer	Web search, research	MiniMax	Find latest API docs
📚 Librarian	Literature review, doc retrieval	—	Analyze open-source codebases
📝 Document Writer	README, comments generation	—	Generate project docs
🖼️ Multimodal	Image/PDF understanding	—	Write code from design mockups

Usage Examples

@Frontend Engineer Convert this login page to responsive layout, mobile should look good too

@Prophet Review the code under src/service/, find potential performance issues

@Explorer Look up the latest usage of React 19 Server Components

@Document Writer Generate API documentation for the entire project

Switch Main Agent

Press Tab to switch the main agent for the current conversation — great for extended use of a specific role.

4. Timeline Time Machine: Experiment Freely, Rollback Anytime

What’s the scariest thing in programming? Changing a ton of code, realizing the approach was wrong, and having no way back. Timeline is your undo button.

Basic Usage

`1`	`/timeline # List every conversation step in the current Session`

Select any node:

Revert: Roll back both code and chat content to that point, like nothing happened
View: See what modifications the AI made at that time

Real-World Scenario

1
2
3

1. You had AI refactor a module → Results are unsatisfactory
2. /timeline → Select pre-refactor node → Revert
3. Code returns to pre-refactor state, try a different approach

Tips

🕐 After completing a milestone, mentally note that checkpoint (which conversation step)
🕐 Boldly try radical approaches — one-click rollback anytime
🕐 Compare two approaches: Revert to Approach A → Check results → Revert to Approach B → Compare

This is the programming version of “save/load” — explore any possibility fearlessly.

5. Ralph Loop: Let AI Push Through to the End

This mode makes AI work in continuous loops until the task is truly complete. Perfect for tough tasks requiring iterative refinement.

Launch Method

`1`	`/ralph-loop`

Use Cases

"Refactor the entire project using the latest Spring Boot 4 standards until all test cases pass"

"Check every file under src/ for code standard violations and fix each one"

"Add complete unit tests to the project until coverage reaches 90%"

Difference from Ultra Work

Dimension	Ultra Work	Ralph Loop
Mechanism	Parallel split, multi-agent collaboration	Serial loop, continuous iteration
Best for	Building from scratch, multi-module projects	Refactoring, fixing, target-reaching tasks
Duration	Minutes to tens of minutes	Potentially hours
End point	Task breakdown complete	Termination condition met

⚠️ Ralph Loop may run for a long time — watch your API quota consumption.

6. Daily Speed Tips

1. Use `/compact` to Save Context

When you’ve chatted many rounds with AI and the context window is nearly full:

`1`	`/compact`

AI refines previous conversations into a summary, freeing space to continue working. No need to start a new chat and lose context.

2. Use `/init` to Get AI Up to Speed on New Projects

When entering a new project, have AI read through the code first:

/init

AI scans the entire project and generates agents.md as a system prompt. All subsequent conversations will be based on this understanding — massive efficiency boost.

1
2
3

/share      # Generate a share link showing complete conversation and code changes
/unshare    # Stop sharing, link becomes invalid
/export     # Export conversation history as a file

Great for:

Showing colleagues how you solved a problem with AI
Documenting pitfalls for team reference 素材 for blog posts

4. View Available Models

`1`	`/models # Models marked "free" are free to use`

GLM-4.7 and MiniMax-2.1 have decent programming capabilities, suitable for lightweight tasks.

5. Quick Code Paste (VS Code Plugin)

In VS Code, select a code snippet → Ctrl + Alt + K → Directly paste into OpenCode dialog.

Eliminates copy-paste switching costs, maintaining your flow state.

7. Recommended Workflow for Beginners

┌─────────────────────────────────────────────┐
│                 New Requirement              │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
          ┌────────────────┐
          │ Simple?         │
          └───┬────────┬───┘
              │ Yes     │ No (Complex/Multi-module)
              ▼         ▼
    ┌─────────────┐  ┌─────────────────┐
    │ Regular chat │  │ Enter ULW to    │
    │ handles it   │  │ trigger Ultra   │
    └─────────────┘  │ Work mode       │
                     └────────┬────────┘
                              │
                   ┌──────────▼──────────┐
                   │ Multiple independent │
                   │ subtasks?            │
                   └───┬──────────┬──────┘
                       │ Yes       │ No
                       ▼           ▼
              ┌─────────────┐ ┌──────────────┐
              │ /new open    │ │ Wait for Ultra│
              │ multiple     │ │ Work to auto  │
              │ Sessions     │ │ complete      │
              └──────┬──────┘ └──────────────┘
                     │
                     ▼
              ┌─────────────┐
              │ /sessions    │
              │ Check all    │
              │ progress     │
              └──────┬──────┘
                     │
                     ▼
              ┌─────────────┐
              │ Wrong        │
              │ direction?   │
              └───┬─────────┘
                  │
                  ▼
              ┌─────────────┐
              │ /timeline →  │
              │ Revert       │
              └─────────────┘

One-Line Summary

Small tasks chat directly, big tasks call ULW, parallel with Sessions, mistakes get Timeline rollback, stubborn problems activate Ralph Loop.

8. A Real-World Case Study

After installing Oh My OpenAgent, I wanted to adjust agent model configuration — making GitHub Copilot the primary and free OpenCode Zen the fallback.

First Attempt

Said directly in an OpenCode conversation:

“I also have your free OpenCode Zen, but I’ve already logged into GitHub Copilot — help me modify it”

AI set OpenCode Zen as primary — because the primary/secondary relationship wasn’t clear. ❌

Correction

“No, GitHub Copilot should be primary, and OpenCode Zen’s built-in free model as fallback”

AI immediately corrected it, updating oh-my-openagent.json so all Agents use github-copilot/* as primary and opencode/* as fallback. ✅

💡 Lesson: When describing requirements to AI, always make the primary/secondary relationship clear — “XX as primary, YY as fallback” — don’t just say “add YY for me.”

📚 Reference: OpenCode In-Depth Guide, Oh My OpenAgent 📅 Note generated: 2026-05-07

OpenCode In-Depth Guide: Installation, Configuration, and Advanced Techniques for the Open-Source Claude Code

Thu, 30 Apr 2026 02:00:15 +0800

📋 Table of Contents

1. What is OpenCode?

OpenCode is currently the hottest AI programming tool, essentially an open-source version of Claude Code. It has replicated almost all core features of Claude Code while solving common pain points for Chinese users such as rate limiting and account bans.

Comparison with Claude Code

Dimension	Claude Code	OpenCode
Open Source	❌ Closed source	✅ Open source
Free models	❌ Paid API required	✅ Built-in free models
China-friendly	⚠️ Rate limit/ban risk	✅ No restrictions
Skills/MCP	✅ Supported	✅ Fully compatible
Session parallelism	❌	✅ Core highlight

Core Positioning

Open-source Claude Code: Nearly all features, China-friendly, no rate limits or bans
Free models: Out-of-the-box GLM-4.7, MiniMax-2.1 and other free models, zero configuration needed
Top-tier model integration: Free access to Gemini 3 Pro and Claude 4.5 Opus via Antigravity plugin; GPT Codex via /connect
Killer features: Session parallelism, Timeline rollback, Share, Ultra Work multi-agent collaboration
Plugin ecosystem: Oh My Open Code (OMO) with seven programming agents + three MCP Servers + various tools

2. Four Installation Forms

⭐ 1. Command Line Version (Primary Recommendation)

The most stable and feature-complete way to use it.

# Install (Node.js required first)
npm i -g opencode-ai

# Launch
opencode

Prerequisite: Node.js must be installed (download from nodejs.org)

2. Desktop Client (Beta)

Download the client from the official website, install it, and select your project folder.

⚠️ Currently in Beta testing phase with more bugs — not recommended as your primary tool yet.

3. VS Code Plugin Version

Prerequisite: OpenCode CLI must be installed. The plugin’s core value lies in seamless IDE integration, letting AI directly perceive your code context.

Search for OpenCode in the VS Code Extensions marketplace and install it
Shortcut Ctrl + Shift + P → type open opencode and press Enter
The plugin automatically associates with code files open in the left panel
Select code and press Ctrl + Alt + K to quickly paste into the OpenCode chat window

4. Cloud Runtime Environment (GitHub Actions)

Perfect for automated Issue fixing in open-source projects:

Upload your project to a public GitHub repository
Configure API Key in the repository (Settings → Secrets and Variables → Actions)
Type /opencode + requirement description in an Issue comment
GitHub Actions automatically runs the OpenCode workflow
Automatically creates a Pull Request upon completion

3. Free Model Configuration

View Available Models

`1`	`/models # View all available models (ones marked "free" can be used at no cost)`

Recommended Free Models

Model	Features
GLM-4.7	Strong programming ability, zero configuration
MiniMax-2.1	Excellent programming skills, fast response

💡 These two free models are more than enough for beginners practicing AI programming.

Connect Top-tier Models

Method 1: Antigravity Plugin (Free Gemini + Claude Access)

Antigravity is Google’s AI programming IDE, generously providing Gemini 3 Pro and Claude 4.5 Opus for free.

Paste the installation prompt in OpenCode (copy from the Antigravity GitHub homepage)
Wait for AI to complete the installation automatically
Open a new terminal and run the login command, select Google → Antigravity login
Log in to your Google account, paste the generated URL
Restart OpenCode — Gemini 3 Pro and Claude 4.5 Opus will appear in /models

Method 2: GPT Codex (Official OpenAI Partnership)

OpenAI has officially partnered with OpenCode, enabling direct ChatGPT Codex integration.

`1`	`/connect # Select OpenAI → GPT Pro → Browser login`

Prerequisite: ChatGPT Plus subscription or higher required.

Method 3: OpenRouter (Universal Connector)

OpenRouter provides access to virtually every major model available, and Chinese users can easily obtain credits.

`1`	`/connect # Select OpenRouter → Enter API Key`

OpenCode supports 75 AI integration methods, covering almost all model providers.

4. Core Feature Highlights

1. Clarifying Questions Before Coding

Before starting to code, OpenCode will ask you a series of questions:

Do you just need a code sample, or a complete runnable program?
Which features are must-haves?
Which model should be used?
How should environment variables be stored?

This “ask first, act later” mechanism significantly reduces rework.

2. Command Line Code Diff Interface

OpenCode’s command line diff display is considered the best among all command line programming tools, making code changes clear at a glance.

⭐ 3. Session Parallel Processing

This is OpenCode’s most distinctive feature — multiple Sessions running in parallel:

# Start the first task (e.g., add a timer)
# While the task is running, create a new session
/new

# Start the second task (e.g., brush color)
# View all session statuses
/sessions

# Switch between sessions
/session <id>

The spinning symbol indicates a Session is running in the background. Two tasks can be developed in parallel without interfering with each other.

4. Timeline Checkpoint Rollback

`1`	`/timeline # View the complete conversation history of the current Session`

Select any historical node:

Revert: Roll back both code and chat content to that point in time
View: See what modifications the AI made at that time

Like a “time machine” for programming, allowing you to boldly try different approaches.

1
2
3

/share      # Share conversation history as a web page
/unshare    # Stop sharing
/export     # Export conversation history as a file

After sharing, a web link is generated displaying the complete conversation history and code modification process, convenient for collaboration or demonstration.

5. Skills Migration

OpenCode is fully compatible with Claude Code’s Skills directory structure, making migration extremely easy:

1
2

# Directory structure mapping
.claude/skills/<skill-name>/    →    .opencode/skills/<skill-name>/

Steps

Create a new .opencode folder in the project root directory
Create a skills folder inside .opencode
Copy the skill folders from .claude/skills/ directly into it
Restart OpenCode — the AI will recognize and call these Skills

Each Skill is essentially an instruction manual with its own directory, telling the AI how to complete tasks in a specific domain.

6. MCP Configuration

OpenCode supports two MCP (Model Context Protocol) modes:

Local MCP

Executed via local commands. Configure in ~/.config/opencode/opencode.json:

{
  "mcpServers": {
    "shed-cn": {
      "type": "local",
      "command": "npx",
      "args": ["shed-cn"],
      "enabled": true
    }
  }
}

Remote MCP

Called remotely via URL. Using Context7 as an example:

{
  "mcpServers": {
    "context7": {
      "type": "remote",
      "url": "https://context7-mcp-server-url",
      "headers": {
        "Authorization": "Bearer <your-api-key>"
      },
      "enabled": true
    }
  }
}

After configuration, restart OpenCode and enter /mcp to view configured MCP Servers.

7. Oh My Open Code (OMO) Super Plugin ⭐

OMO is the most popular programming plugin for OpenCode, essentially a bundled package of Tools + MCP + Programming Agents.

Seven Programming Agents

Agent	Role	Recommended Model
🧠 Sisyphus	Main agent, planning & orchestration	Claude 4.5 Opus / GPT 5.2
🔮 Prophet	Architecture design, code review	—
📚 Librarian	Literature review, document retrieval	—
🔍 Explorer	Web search	—
🎨 Frontend Engineer	Frontend development	Gemini 3 Pro
📝 Document Writer	Document generation	—
🖼️ Multimodal	Image/PDF understanding	—

Each agent is assigned the most suitable model for its work. The author reportedly spent $24,000 worth of Tokens to find the optimal combination.

Three MCP Servers

Web Search: Web search
Context7: Access latest technical documentation
Grep App: Fast code search across GitHub repositories

Integrated Tools

LSP Advanced: Helps AI quickly locate code through language syntax and semantics
AST Tool: Related search through code syntax trees
LOC Tool: Understand images and PDFs via multimodal vision
Delegate Task / Background Task: Agent task assignment and background scheduling

Installation and Usage

Configuration file location: C:\Users\<username>\.config\opencode\oh-my-opencode.json

Copy the install prompt from the OMO GitHub homepage
Paste it into OpenCode and answer configuration questions (subscription status, etc.)
Installation completes automatically

Two Core Usage Patterns

① @ Designate Specific Agent

`1`	`@Frontend Engineer Help me optimize the responsive layout of this page`

② Ultra Work Mode (Magic Word ULW)

`1`	`ULW Help me create a pet store application`

In Ultra Work mode, Sisyphus as the main agent will:

Break down tasks into a Todo List
Launch multiple background tasks running in parallel
Orchestrate all agents from the center
Deliver the complete project

Ralph Loop Mode

Forces AI to work in continuous loops, suitable for extremely difficult tasks:

`1`	`/ralph-loop`

Example: “Refactor the entire project using the latest Spring Boot 4 standards until all test cases pass” — can run for hours until the task is complete.

8. Other Useful Features

`/init` — Project Knowledge Initialization

Let AI read through the entire project folder, generating an agents.md file as a system prompt to help AI quickly understand the project.

`/compact` — Context Compression

Refine previous conversations into a concise summary, freeing up the model’s context window to avoid Token overflow.

Custom Commands

Create .md files under ~/.config/opencode/commands/ to define custom commands:

# Run Tests
Mode: build
Command: npm test
Description: Run all test cases for the project

Usage: /Run Tests to trigger.

Custom Agents

Create .md files under ~/.config/opencode/agents/:

# Code Review Agent
Type: subagent
Model: claude-4.5-opus
Description: Specializes in code review, checking code quality, security vulnerabilities, and best practices.

Primary Agent: Switch with Tab key, use directly in conversation
Sub Agent: Automatically dispatched by the main agent in the background

9. Summary and Recommendations

Use Cases

Scenario	Rating	Notes
Beginner AI programming	⭐⭐⭐⭐⭐	Free models, zero-cost start
Daily development assistance	⭐⭐⭐⭐⭐	Session parallelism + Timeline rollback
Complex project development	⭐⭐⭐⭐⭐	OMO plugin multi-agent collaboration
Open-source project maintenance	⭐⭐⭐⭐	GitHub Actions cloud automation
Skills/MCP practice	⭐⭐⭐⭐⭐	Fully compatible with Claude Code ecosystem

Recommended Configuration Path

Beginner → CLI installation + built-in free models
  ↓
Advanced → Configure Antigravity for Gemini/Claude access
  ↓
Efficient → Configure Skills + MCP
  ↓
Ultimate → Install OMO plugin, enable Ultra Work mode

OpenCode breaks down the high barriers of AI programming tools, allowing everyone to explore the infinite possibilities of AI-assisted programming at zero cost. Especially for Chinese users, there’s no longer any need to worry about rate limits and bans — you can “build freely, experiment freely.”

10. Hands-on Record: Installing Oh My OpenAgent

Below is the complete conversation record from personally installing Oh My OpenAgent (formerly Oh My Open Code), in a Windows + PowerShell environment.

Environment Check

1
2

opencode --version
# Output: 1.14.39

Installation Process

Tell AI directly in an OpenCode conversation:

“Install and configure oh-my-openagent by following the instructions here: https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/refs/heads/dev/docs/guide/installation.md"

AI will first ask about your model subscriptions:

Subscription	My Status
Claude Pro/Max	❌ None
OpenAI / ChatGPT Plus	❌ None
Gemini	❌ None
GitHub Copilot	✅ Student certified
OpenCode Zen	✅ Free available
Z.ai Coding Plan	❌ None
OpenCode Go	❌ None
Kimi for Coding	❌ None
Vercel AI Gateway	❌ None

⚠️ AI will prompt “Without a Claude subscription, the Sisyphus agent might not work ideally” — but GitHub Copilot will automatically take over as a fallback model.

After confirming subscriptions, AI automatically executes the installation command:

bunx oh-my-openagent install --no-tui \
  --claude=no --openai=no --gemini=no \
  --copilot=yes --opencode-zen=yes \
  --zai-coding-plan=no --opencode-go=no \
  --kimi-for-coding=no --vercel-ai-gateway=no

Successful installation output:

[1/4] Checking OpenCode installation...
[OK] OpenCode 1.14.39 detected
[2/4] Adding oh-my-openagent plugin...
[OK] Plugin added -> C:\Users\<username>\.config\opencode\opencode.json

Post-Installation Configuration Files

Main configuration file ~/.config/opencode/opencode.json:

{
  "plugin": [
    "oh-my-openagent@latest"
  ]
}

Agent model configuration ~/.config/opencode/oh-my-openagent.json:

AI automatically assigned models based on GitHub Copilot subscription:

Agent	Assigned Model
Sisyphus (Main agent)	`github-copilot/claude-opus-4.7`
Oracle (Prophet)	`github-copilot/gpt-5.5` (medium)
Other Agents	Auto-selected from Copilot available models

Authentication Configuration

After installation, you need to manually authenticate GitHub Copilot:

`1`	`opencode auth login`

Interactive steps:

Use arrow keys to select GitHub Copilot
Press Enter to confirm
Browser opens automatically, log in to your GitHub student account
Authorization complete, terminal shows successful authentication

How to Reconfigure Agent Models?

Method 1: Tell AI Directly

“Change Sisyphus’s model to claude-sonnet-4.6” “Oracle use gpt-5.5”

Method 2: Manually Edit Configuration File

Directly modify the model field for the corresponding agent in ~/.config/opencode/oh-my-openagent.json.

Additional Configuration: Add OpenCode Zen as Fallback

The free OpenCode Zen was missed during installation (--opencode-zen=no). In a new OpenCode conversation, ask AI to fix it:

“I also have your free OpenCode Zen, but I’ve already logged into GitHub Copilot — help me modify it”

AI’s first attempt set OpenCode Zen as primary (opencode/claude-opus-4-7), making GitHub Copilot the fallback. The actual need was the opposite:

“No, GitHub Copilot should be primary, and OpenCode Zen’s built-in free model as fallback”

After AI corrected it, the final configuration strategy:

1
2

Primary model: github-copilot/*     (paid, use first)
Fallback model: opencode/*          (free credits, auto-switch when Copilot unavailable)

Key configuration snippet (using Sisyphus as example):

{
  "sisyphus": {
    "model": "github-copilot/claude-opus-4-7",
    "fallback_models": [
      { "model": "opencode/claude-opus-4-7" },
      { "model": "opencode/gpt-5.5" }
    ]
  }
}

💡 Tip: When describing configuration needs, make the primary/secondary relationship clear — “XX as primary, YY as fallback” — to avoid AI getting it reversed.

Usage Tips

After installation, type opencode in the terminal to get started:

Include ultrawork or ulw in your prompt to trigger automatic parallel processing
Press Tab to enter Prometheus (planner) mode
Run /start-work to execute full orchestration

Appendix: Troubleshooting Notes

Issue	Solution
`doctor` command timeout (30s)	Some checks may hang; add `--verbose` to troubleshoot, or skip — it doesn’t affect usage
PowerShell `if` syntax errors	OpenCode’s bash commands need syntax conversion under PowerShell
Sisyphus performance drops with non-Claude models	This is a known limitation; experience is best with a Claude subscription
AI swaps primary/fallback models	State the primary/secondary relationship clearly: “XX as primary, YY as fallback” — don’t just say “add YY for me”

📚 Sources: Tech Shrimp - OpenCode Detailed Guide, Oh My OpenAgent Installation Guide

OpenCode on Yanmu

OpenCode + Obsidian: Build Your AI-Powered Knowledge Management Workflow

📋 Table of Contents

1. What is the opencode-obsidian Plugin?

2. Environment Preparation

3. Installing the BRAT Plugin

Step 1: Open Community Plugin Marketplace

Step 2: Search and Install BRAT

4. Installing opencode-obsidian via BRAT

Step 1: Open BRAT Settings

Step 2: Add Beta Plugin

Step 3: Enter Repository Address

Step 4: Enable the Plugin

Auto-Update

5. Installing OpenCode CLI

6. Plugin Settings Explained

Basic Settings

Interface Settings

Context Injection (Experimental)

Custom Commands

7. First Use

Opening the OpenCode Panel

First Launch Flow

Verify Everything Works

Shortcut Reference

8. Context Injection (Experimental Feature)

How to Enable

What Gets Injected

Use Cases

Limitations

9. Custom Command Mode

When Do You Need Custom Commands?

Configuration Steps

Command Template

⚠️ Important Notes

10. FAQ and Troubleshooting

❌ OpenCode Executable Not Found

❌ Service Startup Timeout

❌ Panel Shows Blank

❌ Panel Cannot Embed

❌ Chinese Filename Garbled (Windows)

❌ Plugin Needs Reconfiguration After Update

Summary

OpenCode Beginner to Advanced: A Complete Guide to Parallel Scheduling and Usage Tips

📋 Table of Contents

📌 Key Points Summary

1. Session Parallelism: Let AI Handle Multiple Tasks Simultaneously

Basic Operations

Real-World Scenario

Traditional Approach

OpenCode Approach

Notes

2. Ultra Work: One-Click AI Programming Team

Trigger Method

How It Works

When to Use?

Actual Results

3. @ Designate Agent: Let Experts Do What They Do Best

Agent Capability Table

Usage Examples

Switch Main Agent

4. Timeline Time Machine: Experiment Freely, Rollback Anytime

Basic Usage

Real-World Scenario

Tips

5. Ralph Loop: Let AI Push Through to the End

Launch Method

Use Cases

Difference from Ultra Work

6. Daily Speed Tips

1. Use /compact to Save Context

2. Use /init to Get AI Up to Speed on New Projects

3. Share Your Programming Process

4. View Available Models

5. Quick Code Paste (VS Code Plugin)

7. Recommended Workflow for Beginners

One-Line Summary

8. A Real-World Case Study

First Attempt

Correction

1. Use `/compact` to Save Context

2. Use `/init` to Get AI Up to Speed on New Projects

`/init` — Project Knowledge Initialization

`/compact` — Context Compression