I’ve been using OpenCode for about six months now. Started out just treating it like a chat box. Took a while to figure out what actually works.
The default mode is Build. You say something, it starts changing code. Problem is, most of the time I don’t know exactly what I want yet.
So I started using Plan mode first. It’s read-only. You describe what you need, it gives you a plan. You read it, think about it, then switch to Build and let it do the work.
Saves a ton of back-and-forth. “Wait, that’s not what I meant. /undo. Let me rephrase.”
Now I do this even for small changes. Quick mental plan first. Complex stuff goes straight to Plan mode. Takes an extra minute, saves ten.
Run /init Once, and It Pays Off Every Time
When I clone a new project, the first thing I do is run /init. OpenCode scans the whole codebase and generates AGENTS.md.
Think of it as a README for the AI. What language, what framework, how the folders are structured, code style rules.
Later when I ask it to change something, it already knows the project uses Vue. It doesn’t guess. This matters a lot when the project mixes multiple languages or has weird folder structures.
It’s a one-time setup. Takes maybe a minute. Saves me from explaining context over and over.
Parallel Agents Are Not a Gimmick
OpenCode can run multiple agents at the same time. I thought it was a marketing feature at first. Now I can’t go back.
Say I’m adding a feature that touches the frontend component, the backend API, and test files. I spin up three agents, each handles one file. They work in parallel.
It’s not 3x faster, but it’s noticeably faster. No waiting for one agent to finish before starting the next.
One rule: don’t let two agents touch the same file. Split by file, keep it clean.
LSP Integration Cuts Out the Compile Step
After every change, OpenCode runs LSP checks automatically. If there’s a type error or syntax problem, it sees the error message and fixes it on its own.
With other AI tools, I’d edit code, switch to terminal, compile, see errors, copy-paste back, ask it to fix. Repeat.
OpenCode does that entire loop without me. Not a flashy feature, but I probably skip 20–30 manual compiles a day. That adds up.
/undo Is More Useful Than You Think
Messed something up? /undo. You can go back multiple steps.
Real scenario: I ask an agent to rewrite a function. It does it. I look at it and realize the approach is wrong. /undo. Back to square one. Rephrase the request. Try again.
No manual git checkout. No copy-pasting backups.
And you can /redo to jump forward again. Helps compare two different approaches side by side.
Cheap Models for Searching, Good Models for Coding
OpenCode supports switching models. I use two agents.
One with cheap models like DeepSeek or Groq for exploring code. Search for relevant files, understand the structure, find where something lives. Doesn’t cost much.
Then switch to Claude or GPT for actually changing code. Better quality on the important part.
Works well. Cheap for the grunt work, expensive for the decisions.
Custom Commands Cut Repetitive Work
There are things I do every week. Run lint before a PR. Format code. Run tests.
I turned those into custom slash commands.
Just write a markdown file with a prompt. For example, I made review.md that says “check the current branch changes, run lint and tests, list results.” Now in OpenCode I type /review and it’s done.
Good for any routine you do multiple times a week.
MCP Extensions Are Worth the Setup
OpenCode supports MCP, so you can hook up external tools.
Connected the database MCP. Now it can query table schemas before writing code. No need to describe fields manually.
Connected the browser MCP. It can open a page, take a screenshot, check if UI changes actually look right.
Not required for everyone. But if your workflow involves checking docs, databases, or visual output, it removes a lot of back-and-forth.
Session Sharing Saves Meeting Time
/share generates a link. Send it to a teammate and they can see your whole conversation.
Scenario: I make an agent change a chunk of logic. My colleague asks “why’d you do it that way?” I send the session link. They see the whole thread — the original requirement, different approaches we considered, why we settled on this one.
Saves a 15-minute verbal explanation.
Real Combinations I Actually Use
Here’s how these things come together in practice:
Picking up an old project: /init to scan → Plan mode to ask about structure → Build mode to make changes.
Fixing a bug: Spin up an explore agent (cheap model) to find relevant code → read it → switch to Build (good model) → LSP auto-checks → done.
Adding a feature: Plan mode for a high-level approach → split tasks by file → parallel agents → run tests.
Code review: Two agents. One checks logic. One looks for obvious issues.
Final Thoughts
OpenCode isn’t that complicated. Core is just agent + LSP + multiple models. Each feature alone looks like “that’s it?” But used together, in the right order, they save more time than I expected.
The key shift for me: don’t treat it like ChatGPT. Let it read the code itself, check types itself, run checks itself. You’re not there to read the code and feed it back to the AI. You delegate the work, you don’t teach it step by step.
That’s where the real time savings are.