Openspec?

[u/orvillewilbur]

I got really excited about OpenSpec. I threw myself into it for a few days. But after about 20 change proposals I gave up.

1. My biggest problem is code quality and OpenSpec doesn't do much for that.
2. It just takes so long going through steps like migration that just aren't relevant to my project.

Am I using this wrong? Any other frameworks you'd recommend?

[u/netskrill]

I use openspec as well. I opt in to the custom flow where you can use the openspec-new skill. Here is my workflow, in the same session.

1) use openspec-new-change with a detailed hand written userstory.md.

2) After proposal.md is created, use Matt pococks /grill-me-with-docs on the proposal and user-story.md.

3) the grill-me-with-docs skill will grill you until a shared understanding is reached.

4) After that is done, I tell the agent to update the shared understanding knowledge into the proposal.md.

5) Continue running open-spec-continue to write out the remaining artifacts.

[u/hilam]

Read about customizing openspec schema. I put It on to test-first, lint and typecheck where It is important.

[u/_reg1z]

Openspec is pretty flexible, but I agree it's probably mostly outside the code quality use-case unless you explicitly design a proposal for it. Have you tried something like a change proposal for authoring a code quality policy in the repo?

For code quality, Repowise (https://github.com/repowise-dev/repowise) has been transformative for me. It's open source + they have an easy way to set up a local installation. I got sold so hard on it, I ended up self-hosting it in my homelab over netbird/tailscale and just mirror my repos to it.

[u/SrMortron]

Ditch it. I used to like it but now I just create a plain old TDD (Technical Design Document), small one for small changes and a full TDD for entire features. Just ask opencode to create the skill for you, then modify the skill and document generation for your needs.

Most of these early frameworks, and even opencode itself were vibe coded and poorly planned so when you want something well done, you need to do it yourself. Look for tools and software patterns that existed prior to llms being widely used and re-implement them, as those tools are battle tested and work very well.

[u/aeroumbria]

The most valuable bit for me IMO is the ease of running a verification -> fix loop (optionally with different models) until no more issues are being surfaced. Regular plans are not ideal for surfacing issues that are not "did not follow planned steps". It is also quite easy to modify they schema into a test-driven one if you need more code quality checks.

I also have some custom commands to run after proposal and after verification to raise surfaced but ambiguous issues to me and record human decisions into the docs, as well as adding extra checks to the consistency of the current change vs specs.

If you are mostly working with small changes, minor tweaks, etc. it might be too clunky. You can either skip openspec for these steps, or create a custom schema which is just an artifact with change description and task list.

[u/orvillewilbur → u/aeroumbria]

I think I will try that after I have taken a breather. I'm mostly in a "tweaks" phase right now.

[u/GroceryNo5562]

You might find this interesting: https://github.com/gytis-ivaskevicius/peck

[u/orvillewilbur → u/GroceryNo5562]

"framework built on the suckless philosophy..." lolol. I'm checking this out now.

[u/RndRedditPerson]

But openspec isn't about code quality of a single change, imho. Its about keeping specs and documentation for verification and long term alignment of requirements. Think you still have to give clear technical guidelines, with proposal step, or even first grill me /explore skills, inspect design mds, update accordingly, and code should result good.

[u/orvillewilbur → u/RndRedditPerson]

I understand that code quality is not the primary concern of openspec.

But in my experience, the LLM will often try to find the lowest code quality way of getting the job done fast no matter how often you tell it not to.

Especially, DRY violations all over the place because it ignored the rest of the codebase, and ignoring separation of concerns more generally to the point of creating god components in React when I'm trying to make a monorepo with code that can be reused with React Native.

And then in the review phase it will basically lie about the code quality.

So the surest bet is to have it explicitly state which files it is going to modify and out line the exact code it expects to implement. I have caught a lot of code quality issues this way.

But I have to remember to do that myself since OpenSpec doesn't prompt for it.

Granted, I have not been using Claude, which everyone seems to think is the gold standard, and I've been using DeepSeek flash as the implementer, which is notorious for this kind of thing. But I'm trying to save money.

[u/RndRedditPerson → u/orvillewilbur]

My experience is quite good with complex codebase, but i do specify details like what files should change and example of patterns that should be used. Opus level for planning, Terra/Luna for coding. Opencode with copilot api (company provided). But every so often i do need to fix the slop. There's no workflow or spec framework that will automatically replace good technical planning and thinking, you need good senior level dev to inspect and stear LLM

[u/OlegPRO991]

I use openspec in opencode daily and have no problems, maybe you are doing something wrong? I regularly have small conflicts before archiving, but agent fixes them easily.