01VIBE CODING
THE OLD LOOP Fast launch. No guidance.
You prompt, it generates, you regenerate. The agent misreads what you meant, context slips between turns, the result drifts from the goal — and you are the one steering, the whole way.
SpecBuddy turns vague prompts into structured execution workflows. No more infinite prompt loops, "almost-correct" code, or losing control of what you're building.
OPENSPEC · SIMPLIFIED · SPEC KIT (SOON) — WITH ANY ACP AGENT
A spec is a map, and the code is the territory. You only find out the map is wrong by walking it — usually a step or two in, when something nobody thought of gets in the way. Spec-driven development writes the map down. SpecBuddy is what puts you on the walk.
You prompt, it generates, you regenerate. The agent misreads what you meant, context slips between turns, the result drifts from the goal — and you are the one steering, the whole way.
What you want is written down and agreed before anything runs — that part is solved. But the agent still builds the whole thing in one go, deciding things nobody asked you about, and you first see the result at the end, when changing it costs the most.
The agent stops after every step and shows you what it just did. Keep it, or send it back. And when a step teaches you something the plan did not know, the plan changes right there — before the next step runs on top of it.
Reviewing every step is only affordable if you are not blocked while you do it. So a change does not own your checkout: start a second one and it gets a worktree of its own, runs its own steps, and goes into main on its own schedule.
The first change runs in your working copy. Start another while it is still going and SpecBuddy checks out a separate worktree for it — no two runs ever touch the same files, and none of them has to wait.
Its own steps, its own diffs, its own agent session. You can be signing off step 4 of one change while the other is still on step 1 — the reviews do not queue behind each other.
Each change lands as a commit on its own branch, and each goes into main when it is ready — the one that finishes first does not wait for the other. Ordinary branches, ordinary merges, nothing unusual left in your history.
Spec-driven development is a methodology, not a single tool. SpecBuddy supports several of them — OpenSpec, its own zero-setup Simplified flow, and GitHub Spec Kit next. Pick the one your team runs, and an IDE to see it in.
Describe the task. SpecBuddy takes it through a spec you approve, a plan, step-by-step execution and a review after every step. Nothing to install, nothing to scaffold, no new files in your repo — it runs in the project you already have.
Start with a short description. The agent turns it into a structured spec using your request, your codebase, and your constraints. You review, edit what matters, approve. Nothing runs until you sign off.
From the approved spec, the agent produces a step-by-step execution plan — what to build, what to modify, what tools to use, in what order. Every step cites a spec requirement.
The agent executes step by step. You catch missing details, accept, reject, or rollback — no "big bang" generation, no silent drift. Your job is intent and control. The typing is the agent's.
No more struggling to type out component and package names in chat. Use the full power of your IDE to navigate your code and drop comments wherever you want — backed by real code completion.
SpecBuddy drives the /opsx:* commands openspec init installed,
against the openspec/ directory you already have — nothing to migrate, nothing
to re-learn. It adds what OpenSpec leaves to the terminal: reviewing a change inside the
IDE, running tasks.md one group at a time behind a review gate, and archiving
a spec that says what really shipped. All it needs is the openspec CLI on your
PATH.
Describe the change in an editor tab, not on a terminal line. Send it to /opsx:propose — or to /opsx:explore first, when you are not sure yet. The change folder shows up in the Spec Explorer as a unit of work with its state on the row: Draft, 3/7 tasks, Review. And the agent session stays open on the new change, so you can keep arguing about the proposal in the same conversation.
A delta spec only makes sense beside the main spec it modifies, so SpecBuddy links the two: a gutter marker on a MODIFIED requirement jumps to the original in openspec/specs/ or shows both as a diff, and a main spec lists the active changes that target it. When one of the WHEN/THEN scenarios is wrong, comment on it the way you review a pull request. The Cockpit keeps comments about the change apart from comments about one task, so a note on task 6 never turns into a rewrite of the proposal.
Plain apply works the whole checklist in one pass. SpecBuddy runs one numbered group of tasks.md per session, with a git snapshot before and after, and hands you the diff for that group alone — accept it, refine it with your comments, or roll back to the exact state before the run. Run one group, run up to the one you pick, or let the rest go and review at the end. When the agent hits something the spec does not cover, its question lands in the log and the run waits for your answer.
Sync keeps openspec/specs/ current during a long change, Archive closes a finished one, Sync and archive does both — one button each, and every one a real /opsx:* run recorded like any other. Because you corrected the delta at the step boundary and not only the code, the spec you merge back describes the change you really shipped. Archiving ends nothing: the change moves to Archive in the tree, its history and agent log move with it, and when you merge the worktree the agent writes the commit and lands it in main — one more run in the same history.
openspec/, your commands.SpecBuddy runs the /opsx:* skills openspec init installed and keeps its own state out of your repo — run history and snapshots live in ~/.specbuddy. A teammate without the plugin sees a plain OpenSpec project.
The Spec Explorer lists active changes with their state on the row, then openspec/specs/ by capability, then the archive. Running agents sort to the top. You stop typing openspec list to find out where you are.
The Cockpit’s Docs tab lists the change’s artifacts and each delta spec with the main spec it modifies — or marks it a new capability — and highlights the main specs this change touches.
tasks.md groups.No plan format to adopt. Each numbered group in tasks.md is a step, the agent ticks the boxes as it goes, and a group you edit after it ran is flagged outdated until you run it again.
Every /opsx:* run — propose, refine, each task group, sync, archive — is a revision with a snapshot before and after. Open the History tab a month later and diff what any of them did, the archive move included.
Start another change while one is still running and it checks out a worktree of its own, reviewed and merged on its own schedule.
How parallel changes work →GitHub's Spec Kit is on the roadmap, not in the plugin yet. When it arrives it gets the same treatment as OpenSpec — your commands, your artifacts, driven from the IDE.
Follow progress and vote on what ships first — or read how the two methodologies differ before you pick one.
SpecBuddy talks to agents over the Agent Client Protocol. If your agent speaks ACP — and most do now — specs, plans, step execution and code review all work out of the box. No per-agent setup.
Free on the JetBrains Marketplace. The built-in Simplified flow runs in the project you already
have; the OpenSpec workflow additionally wants the openspec CLI on your
PATH and an initialised openspec/ directory.
SpecBuddy is free. Install it, point it at your openspec/ directory,
and run your next change one step at a time.