Spec-driven development
Harmonic is built for a particular way of working: you decide what to build and write it down, then let coding agents do the building. The writing-down is the spec. The building is a queue of tickets. Harmonic is what drains the queue.
The idea
Section titled “The idea”Handing an agent a vague “add billing” rarely ends well. Spec-driven development breaks the work down first:
- Write a spec. What you’re building, and why. The durable artifact that outlives any single agent run.
- Break it into tickets. Small, well-scoped issues in your tracker, each one a self-contained piece of the spec with enough context for an agent to finish it alone.
- Let the tickets run. The ones that are ready for an agent get implemented, reviewed, and merged, one after another, without you in the loop for each one.
You stay where your judgement matters, on the spec and the decisions, and the mechanical work of implementing each ticket runs itself. A backlog stops being a list you chip away at and becomes a queue that empties on its own.
Where Harmonic fits
Section titled “Where Harmonic fits”Harmonic is designed to work alongside Matt Pocock’s Skills, a set of
Claude Code skills for spec-driven development. The Skills are what turn a
spec into tickets: /research and /wayfinder to chart the work and make
the decisions, /to-tickets to turn a plan into issues, /implement to
build one. They author the tickets in your tracker and label them as they
go.
You wire the two together once, in your repo, with the Skills’ own
/setup-matt-pocock-skills command: it installs the Skills and sets up the
issue tracker that Harmonic then reads. From there the Skills write tickets
and Harmonic runs them.
Harmonic is the layer that runs those tickets. It watches your tracker, and when a ticket is labelled ready for an agent it starts one, hands it the right command for that kind of ticket, and takes the result all the way to a merged branch. The Skills stay the source of truth for what each ticket is; Harmonic owns running it.
So the division of labour is:
| You | Matt Pocock’s Skills | Harmonic |
|---|---|---|
| Decide what to build; approve the plan | Turn the spec into labelled tickets | Run the ready tickets to merged code |
| Answer the questions agents can’t | Define what “done” means per ticket | Retry, escalate, and merge |
What “runs it” means
Section titled “What “runs it” means”For each ticket that’s ready for an agent, Harmonic:
- starts a coding agent (Claude Code, Codex, Copilot, or OpenCode) on it,
- gives it the ticket and the command that ticket calls for, like
/implement, - lets the agent do the work and review it, then
- merges the branch and marks the ticket done, or hands it back to you if it got stuck.
Nothing here is bespoke to one ticket. The same line runs every ready ticket the same way, which is what lets a whole spec’s worth of work go through unattended while you watch a board.
Not every ticket runs itself
Section titled “Not every ticket runs itself”Some tickets are decisions, not builds, research, a prototype, a design call. Those are marked for a human and stay on the board for you to work through with the Skills directly; Harmonic surfaces them but won’t run them. Only the build tickets you’ve marked ready for an agent run automatically. See Feeding it work for exactly what gets picked up.
Where to go next
Section titled “Where to go next”- Feeding it work — the labels that decide what runs and what waits for you.
- Watching & steering the fleet — the board, live activity, and taking over a stuck ticket.
- Reviewing & merging — the checks between an agent’s work and your main branch.