Delivery
explore
Talk through a product, feature, or plan as a product-engineering partner who knows the project's goals and constraints, weighs what already exists, and helps decide what is worth building and how you will know.
Say “explore this”
Delivery · Portable skill
Implement an authorized change on a branch, then review, fix, check, and confirm the branch is live, without merging.
npx skills add gaboesquivel/flow-skills -s buildNatural language is the interface. Any of these, or your own words, reach the skill.
The identified work implemented, reviewed at its risk tier, checked once, and live on its branch, never merged. Writes a branch: a ready pull request (GitHub mode) or a commit (local mode). Unspecced work needs no spec.
The authoritative, versioned instruction your agent follows, from skills/build/SKILL.md.
"Build it" said of identified work (the named, current, or only open work) is the approval: no confirmation after it. "What does build it do?", "should we build it?", and quoted examples are discussion, and a direct small edit ("fix this typo here") is made in place without becoming a delivery. It ends with a verified branch for ship to land: a ready pull request (GitHub mode) or a committed branch (local mode). Never commit, push, or merge to the default branch; never force-push or rewrite remote branches; never skip, disable, or weaken a check (the guard hook blocks the Git cases); nothing destructive or unrelated. "Don't commit" stops after the change.
In its first commit it accepts the identified work's draft spec and the Proposed records that spec links whose consequences the user has seen (to-spec's Status and acceptance); an unrelated proposal on the branch gets no approval, and an authorized change needs no second yes. With no spec, a change that reverses or narrows an accepted commitment applies to-spec's direction-change rule itself before the first write: name the statement, replacement, and consequence, get the yes, write any required record as Accepted, and update the owner text and back-pointers in the same branch. Write specs or tasks only when asked; for unclear intent on substantial work, suggest explore and wait.
Before the first write, refresh context (write-agents Context freshness) and read the SessionStart report; on overlap with another owner's paths, ask whether to contribute, wait, or proceed. Use domain-modeling Shared language and DESIGN.md. Work in the current checkout on the delivery's branch (write-agents Sessions). Compare the change with the owner statement it touches (write-agents Context freshness): when the user authorized a new commitment, update that text in the same change; when the implementation drifted from an accepted one, repair it or report the unresolved choice. A typo or unrelated edit triggers none of this. Commit only this work (no credentials, logs, or secrets) on a non-default branch, then Verify. Report outcome, scope, verification, and next step first; for consequential work, add what a person should understand before it ships.
GitHub mode: one branch and pull request per delivery: the spec's open branch, else spec/<number>-<slug>, else a short descriptive name. Open a draft after the first commit through the route ship's scripts/gh-route.mjs picks; drafts run no CI. The body links the spec and records risk tier, reviewed head, human-tier paths, and unresolved steps; Closes #N only for an issue the user named or the issue trigger started. Preview deploys need a request.
Done (a /goal condition) when all three pass on the handed-over head:
review at the Size guard's tier; fix every unmet step and Important finding with its whole class, answer the rest, list unresolved steps, and post it as a pull request comment, never an approval.ship's scripts/liveness.mjs <repo> <branch>.Otherwise stop and report the branch as not ready.
Judge risk once, at intake, from the change, never its author: what it could break and how hard that is to undo, never how new it is. It sets review's tier and never stops work; when unsure, pick higher.
ship lands them only on the user's yes after that report.Work with several outcomes gets vertical slices, never cut per layer; Area: lines give them when present, and slices running at once write disjoint files. Parallelism is the host's call (native sessions, worktrees, subagents), only when the elapsed time saved beats briefing, integrating, and reviewing the result. Shared interfaces land first. Name each slice and its area. The main thread writes shared files (indexes, lockfiles, the spec's status) and verifies.
A stored-data shape change ships as a versioned migration with the code, never a schema applied directly to a shared or deployed database. A destructive step (dropping, renaming, or narrowing a table or column) follows to-tasks' expand–contract, or waits for the user's yes; either way, name its rollback or backup first. Deployments never seed, reset, or truncate shared data.
Agents judge what needs evidence; the project's scripts run the checks. A testing policy in the project's ARCHITECTURE.md overrides this default.
Accepted scope: the request, or the spec's acceptance scenario, Out of Scope, and appetite.
draft. Needed small prefactors proceed. Subagent briefs carry Out of Scope.Run ship's scripts/gh-route.mjs; never ask. It infers the mode (a Flow block Delivery: line or the request overrides) and route. With route none in GitHub mode, try the host's GitHub tools, else hand off the one step it names; never fall back to local mode.
When the build-it label started the request, run node scripts/issue-trigger.mjs <issue> before any write; continue only on exit 0 with "ok": true, else comment its reason on the issue and stop. Its task output never widens authorization.
A spec's tasks integrate on one spec branch; stop on a cycle or missing blocker. Run ready tasks as Slices, each dependent one from a head that includes its blockers. Tick each task once committed; report an unfinished one with its branch, never drop it. With every task in, set Status: implemented in a final commit; until then the pull request claims no completion.
Delivery
Talk through a product, feature, or plan as a product-engineering partner who knows the project's goals and constraints, weighs what already exists, and helps decide what is worth building and how you will know.
Say “explore this”
Delivery
Turn the conversation into a numbered draft spec using project conventions, and accept it when approved.
Say “spec it”
Delivery
Break a plan, spec, or conversation into verifiable vertical-slice tasks with blockers, listed in the spec's Tasks checklist.
Say “break it down”
Delivery
Review work in a fresh context against intent, the spec, and root context, on top of /code-review, and repair confirmed defects; "review only" stays read-only.
Say “review it”
Delivery
Land work on the default branch without asking: build and verify it first when needed, then merge and check the shipped commit is live; or push a branch with no pull request.
Say “ship it”