· Synx Data Labs
The /drive Phase Chain, In Depth
How Synx Data Labs ships code with ccxp-skills' /drive — the six-phase chain from picking a task to merging it, the design-score gate, mandatory test-driven development, an independent review pass with no memory of the change it's reviewing, and why a blocked task gets driven to done rather than swapped for something easier.
Last week’s post covered the lock that keeps a human and an hourly cron from colliding on the same task, and closed with a promise: this post is about what actually happens once a task is safely claimed. That’s /drive, in ccxp-skills — the skill that turns one picked task into one shipped, merged pull request, end to end, with no human needed in the loop unless something it can’t resolve on its own comes up.
The six-phase chain
/drive owns one task at a time, all the way to merged. The phases:
- Pick —
/todo nextoff the priority-ordereddev/TODO/queue.md, or a task ID handed to it directly. - Claim — the merge-as-lock pull request from last week’s post, landing on
mainbefore any design or code exists. - Design — the task file itself grows a design section, goes up as its own small pull request, and has to clear a deterministic scoring gate before anything gets implemented against it.
- Implement — code-class work is test-driven, no exceptions; docs-class work skips straight to writing.
- Pull request, then
/address-pr— CI has to be green, an independent review has to come back clean or be answered, and every test-plan item has to be verified or left honestly unchecked. - Merge, then close — the task file moves from
dev/TODO/todev/JOURNAL/in the very same pull request that ships the work, not a batch job that runs later.
Claiming is covered in full in last week’s post, so this one picks up at design.
Design has to clear a score before any code gets written
A task’s design isn’t a free-text paragraph someone eyeballs for vibes. It’s scored by a deterministic script, design-score/scripts/score.sh, against a 100-point rubric split across seven checks: frontmatter completeness, whether the standard sections are actually present (TLDR, Problem, Solution, Test plan, Done criteria, and two more written at close time), whether a code change’s root cause is documented, whether the test plan has real checkboxes, whether each done-criterion actually maps to a specific test or file:line, how much of the prose is backed by a concrete anchor — a file path, a commit SHA, a pull-request number — rather than an unsupported claim, and whether alternatives were genuinely considered and rejected rather than the chosen approach being the only one on the page. The default pass mark is 70 out of 100, and it’s a hard gate: below it, /drive doesn’t start writing code, full stop. It fixes the gaps in a follow-up commit, re-scores, and only then moves on.
The deliberate choice here is “deterministic, not an LLM rubric.” A script either finds a ## Test plan heading or it doesn’t; either finds a file:line reference in the done criteria or it doesn’t. That’s a cheaper, more consistent signal than asking a model to judge its own design’s quality, and it catches the same decay a human reviewer would eventually catch — a stub design that never got filled in, a done-criteria list that doesn’t actually point at anything verifiable — before a single line of implementation is written against it.
Code gets written test-first, no exceptions
Once a design clears the gate, /drive classifies the change: anything that touches real code is “code-class,” and code-class work requires test-driven development before implementation starts — red, then green, then refactor, as a hard precondition, not a suggestion. Markdown, task files, and skill documentation are “docs-class” and skip that gate; a blog post doesn’t need a failing test written against it first.
For a substantive code-class task, the implementation phase itself runs as a short, strictly sequential chain of sub-agents, each handing the next a structured result rather than a wall of prose: a small implementation-level planning pass (not to be confused with the task-level design document from phase 3, already written and scored by this point), then the actual code change, then a test run, then a dedicated verification pass. No fan-out, no parallel branches exploring different approaches at once; the point isn’t speed, it’s that the verification step can adversarially check the actual diff against the actual done criteria before anything goes up as a pull request, using a fresh pass with the explicit job of trying to find what’s wrong. A one-line fix or a docs change skips all of this and runs the steps directly — the guard that decides which path applies is deliberately conservative, since a wasted sequential pass costs tokens but a skipped one costs nothing except running the steps by hand instead.
The reviewer has no memory of why you made the change
Every pull request gets an independent review pass before it can merge, and the independence is the whole point: the reviewing agent is a fresh session with no memory of the conversation that produced the change, told only to find real bugs, correctness issues, and quality problems — or to say plainly that the diff looks clean if it does. That’s deliberately the same property a human second reviewer brings that the original author can’t bring to their own work: distance. A clean bill moves straight to the next check; a real finding gets fixed, or answered with a specific, recorded reason the finding doesn’t apply — never silently dropped. If a repository has the automated approval workflow wired up, a clean review also files a real, mechanical GitHub approval pinned to the exact commit it covered, which is what lets a one-approval-required branch policy hold even when no human is in the loop for a given pull request — the judgment of whether to approve stays entirely with the review step; the workflow only records what that step already decided.
Underneath all of this sits a hard ceiling: /address-pr will fix CI failures and address review findings for up to five full iterations, and if the pull request still isn’t clean after that, it stops and asks instead of looping forever. Five is a deliberately finite number — a signal that something’s actually wrong, not just one more push away from green, deserves a person’s attention rather than a sixth automated attempt at the same problem.
Merge and close happen in the same pull request
Once every gate passes, the task file moves from dev/TODO/ to dev/JOURNAL/ as part of the very commit that merges the work — not a separate cleanup pass that runs later, and not something a Friday retrospective sweeps up after the fact. The practical effect: the backlog is never stale about what’s actually done, because “done” and “the file moved to the journal” are the same event, not two events that can drift apart.
Depth over throughput: why a blocker gets driven to done, not swapped out
If the task /drive is working turns out to depend on something else that isn’t finished yet, it doesn’t put the original task down and grab a different, easier one off the backlog to stay busy. It parks the original task in a clean, pushable state, recurses into the blocker, drives that blocker all the way to merged using this same six-phase chain, and only then comes back and resumes where it left off. That’s an explicit design choice — depth over throughput — and it’s not unconditional: a blocker that turns out to depend on the original task right back, a blocker that needs secrets or a human decision this session can’t make, or a chain of blockers three levels deep are all treated as signals that something about the task graph itself needs a person’s attention, not something to keep recursing through on the assumption that it’ll resolve eventually.
That’s the loop end to end: a task picked off an ordered queue, claimed durably before anything starts, designed and scored before any code exists, built test-first with an adversarial check before it ships, reviewed by someone with no stake in having written it, and closed in the same breath it merges — with one standing rule for what happens when it hits something it can’t finish alone: go finish that first. Next week’s post covers the other bookend to Monday’s planning meeting — the Friday retrospective that grades the week against what got committed, and what happens to a task that keeps losing the coin flip.