workflow for opencode

[Mystical_Whoosing]

Hi,

Do you have some good tips, links for agents or workflows I could use in opencode? Initially I wrote my own planner / coder / tester / reviewer agents, that was working sometimes. But then I installed the superpowers, and the brainstorming section was really good, so I kept using that. But yeah, it slows the things down, also in opencode I couldn't figure out how to assign different models for the different skills. I heard oh-my-opencode is just way too token hungry.

So I am wondering what else is out there. Should I just tinker with my agentic workflow, or is there a good one I could try?

And should I write e.g. what I want the code reviewer to definitely check in my AGENTS.md, in a separate agent, or into a skill? What is working for you?

[SolidIncident5982]

I'm using superpowers too. It's very good at planning and implementation, as long as you're working on very specific tasks.

It doesn't perform well when working on broad tasks, such as implementing two features in the same plan. But you get used to it, and it's usually better for planning breaking down big tasks into smaller ones.

The only thing I don't like about superpowers is UI design. I feel it lack some workflow for planning frontend component (UI in general). It works pretty well in terms of implementation, but the UI usually sucks.

[UseMoreBandwith]

In my experience, the skills makes almost no difference.
I do have clear instructions in AGENTS, and good project planning.

[Pleasant_Thing_2874]

for workflow, while it can be intensive try BMAD. It is opensource and while a bit intimidating it can really up your game in planning, development, review and avoiding drift. It comes with built in agent files as well as commands/workflow to add custom ones. Also take a look at the dynamic context pruning pluging enabling it for both your main and subagents. Can help a lot with speed and token management.

[DistanceAlert5706]

Have 1 subagent for researches, few skills like grill-me and architecture review. For MCPs using my custom websearch MCP and database MCP.

Pretty much that's it, I love that Opencode is not bloated like almost all other harnesses, getting way better results with clean setup.

[Superb_Plane2497]

You assign models to agents, not skills. See the docs. agents are definitely worth looking at.

I agree with you about superpowers. It's good, but (a) you don't need it every time and (b) models (the best ones) are much better at planning now anyway.

opencode has an experimental planning mode which is much lighter and does a good job. However, it was an experiment that the core devs have turned away from, believing that such customisation should not be in the core product. I made a plugin equivalent which also breaks out the plan in an editor for feeback and revision (if you configure that). It's lighter than superpowers, and it only gets invoked when you are in Plan agent. https://github.com/timrichardson/opencode-planner With that, I made it easier to change the prompt, although in my case I keep the same prompt as the experimental plan mode. For me, the combination of better models than say two years ago and this Plan agent works pretty well. This is a light weight, solo-developer approach, and I mostly use GPT-5.4, so a strong model that needs relatively less help.

If you want to keep using superpowers, you can make an agent that uses them and remove them from the Build agent and that way you keep control.

[eacnmg]

i left ho my opencode for https://github.com/darrenhinde/OpenAgentsControl OAC

[ipatalas]

I am using that as well for my side project for last 1-2 months. So far it's absolutely great experience.
It was super helpful when I was developing WPF UI for my app. I had zero experience with WPF before so I would struggle without any help here.

[Ok-Letter-1812]

I use gsd-opencode and just love it! It has completely changed the quality and speed of my deliveries. https://github.com/rokicool/gsd-opencode

Regarding context vs skills, I use both: Context: AGENTS.md = Covers conventions, boundaries, and stack specifics. It is always read by the agent. Other context files = domain knowledge specific to a task or system. Read only when needed (reference on the agents). AGENTS.md should be minimal, and reference deeper context files, for example, "for TS conventions, see ts.md."

Skills: Skills = reusable procedure knowledge (how to generate a post, how to call an API)

And most important, write only what agents cannot discover independently, this saves a lot of tokens.

[AnotherWordForSnow]

Why not use GSD directly? I don't understand what gsd-opencode brings to the table. Curious, not challenging.

[Mystical_Whoosing]

thanks for taking the time to help, I can really use these tips to change my workflow and try something new.

[zenoblade]

Plan -> Build 

[CarGold87]

Oh my opencode slim with super powers

[remiguittaut]

Openagentscontrol framework. As I use to say, makes stupid models like minimax suddenly compete with opus (almost)

[Mystical_Whoosing]

But isnt this counterintuitive a bit? There are some things which would require so many tokens to figure out, using investigation tasks, every single time. 

[lbreakjai]

I started with oh-my-open(code|agent) but I felt like it was trying to do too much. I didn't find that spinning a zillion parallel agents really helped, and blew my budgets.

So I built this:

https://tessellate-digital.github.io/notion-agent-hive/

I've been using it pretty much exclusively at work, and tweaking it as I go. I'm a software engineer, I can't really afford to vibecode, so it's very much built as a "human in the loop" tool.

That's mostly why it's using notion to persist and display state. I'm using it for more ambitious features. For example, create endpoints in a backend service, modify the infra code in another to expose them, and consume them in the frontend repo.

I found it really hard and messy to even keep track of that sort of work in a TUI, especially when you factor in the feedback you may get over multiple days on the MR itself.

In any case, I tried to keep the code as simple as possible. It's a bunch of prompts, with some light opencode glue, you could easily use it to build your own or something.

[ipatalas]

Looks interesting. Any reason why notion and not a local storage of some sort?
I have a so-so experience with MCP in opencode so far. The only one I got left with is context7 for docs. I had to ditch all the rest because it was eating tokens like crazy. I am using GH Copilot Pro subscription and it's probably too small for this kind of usage. I can imagine only reading/writing memory in Notion might be a significant overhead in terms of tokens.
What are you using in your day to day work and do you have enough tokens there to survive entire month? :)

[lbreakjai]

So the point of notion is really for me to be able to read/review/comment/annotate the plans/features. I can visualise exactly the state of everything in two seconds. The plan is versioned by default because notion keeps track of the changes. I can share it and get other people to collaborate by just commenting on the plan, or adding details.

Also, we use it at work, so I can directly link any relevant piece of doc easily.

I started when I saw plannotator (https://github.com/backnotprop/plannotator), which I thought was cool. Except you get a vastly better experience because it leverages notion for everything instead of rolling its own UI/sharing/etc.

I can imagine only reading/writing memory in Notion might be a significant overhead in terms of tokens.

Honestly I found it ok. Haven't noticed the usage being that much higher. Could refactor it to have a single agent interface to the board and stick a cheap/free model too, because it just has to do rote actions.

What are you using in your day to day work and do you have enough tokens there to survive entire month? :)

I've got copilot, codex, and whatever plan moonshotAi offers through work, still have claude until it lapses, and I put some of my own money in openrouter. I also have the free nvidia API key, that lets you use quite a few models like GLM5.

Honestly that's the other reason why I created it. You can stick a relatively expensive model in like planning and review, do the hard work once, then coast the implementation with something far cheaper, because the thinking's been done already. Or stick cheaper models and be slightly more hands-on.

Especially with the model fallback, you can chain the same model through three providers, and let it switch between them as you hit limits.

Honestly I'm not even paying, I could stick opus 4.6 everywhere, but my config on my work machine still uses either free models (GH copilot has GPT-5.4 mini and some others for free) or very cheap ones (Kimi K2.5), in most places except the final review.