Suede Ship Copy

Suede Ship Copy

The copy side of the canonical Suede DAG. One brief in, one publishable draft out, with about thirty agents in between arranged as a graph rather than a chain.

suede-graph-flo-xr decomposes work by file ownership: two lanes may never write the same file. This decomposes by message ownership: two sections may never make the same point, and no section may assert a fact an agent invented. Same graph, different collision rule.

Model selection: Fable capped at 4 without asking

Subagents inherit the session model unless the spawning call names one. Nothing in this skill picks a model, so every agent it fans out lands on whatever the session happens to be set to. That is how a run sized against one allocation gets billed to another without anyone choosing it.

Up to 4 concurrent Fable subagents are allowed without an explicit Fable instruction. Beyond that, Fable must be specified: every range this skill offers (30 at the narrowest) is far beyond 4, so its fan-out never runs on Fable unless the user named Fable for this run. An inherited session model is not a specification: "the session was already on it" is not the user asking. Absent an explicit Fable instruction, do one of two things before launching: name a different model on the agent calls, or state plainly that the run will bill to the Fable allocation and get an answer. Silence is not consent to spend it.

Whose claims get audited

The audit exists to catch agents inventing things. It never runs on the requester.

A research lens that reports "cold start drops to 40ms" is a machine asserting a number, and it gets opened against its source. The requester saying the same thing in the brief is the person who owns the product telling you a fact about it. Those are not the same input and this workflow never treats them as the same input.

Anything the requester supplies (the brief, the given list, mustSay strings) enters the permitted claim set marked origin: "user" and is exempt at every stage:

• Intake transcribes it. It does not verify, source, soften, or flag it.
• The audit never sees it. A research fact that merely restates a given is removed before the audit rather than checked: the given itself already carries that content into the permitted set, so nothing is lost. The run log and the evidence record both say "removed", not "passed through".
• Protected strings are not claims. A mustSay product name or legal line is a string to preserve byte-exact, not an assertion to exempt from review. Letting a product name count as a given would exempt half the draft from review, so the exemption corpus excludes them.
• Research lenses are told it is established and are forbidden from returning a constraint that contradicts it.
• Writers assert it plainly. No "reportedly", no "according to", no hedge.
• A review finding aimed at one is discarded by a pure function before a verifier is spent on it, so a persuasive lens cannot argue its way back in. It runs a second time after refutation, so a verifier that sustained one anyway still cannot hand it to the reviser.
• The match is proportional, not a character floor: the shorter of the given and the quoted text must be contained in the longer and be at least 60% of it, with a 6-character minimum. A lens quoting most of a given is out of scope; a lens quoting two words that happen to appear inside one is not. That matters in both directions: a flat floor would let a compound sentence (something you said and something an agent invented) launder the invented half behind the true half.
• The refute prompt says out-of-scope at every severity, not only for blockers.
• The publish-readiness gate skips it: no spot-check, no drift verdict, no risk entry, and no escalation when a live page disagrees. A stale page losing to the requester is the correct outcome, not a finding.
• The evidence record lists it as given, with no "unverified" label.

The exemption errs toward dropping. A legitimate finding lost because it brushed a given is a cost worth paying; a given rewritten by the reviser because a filter was too clever is the thing this workflow promises cannot happen.

The only hazard that can stop this run is an output path pointing at published copy, which is a fact about a file path rather than a judgement about anything the requester said. If an intake agent tries to mark anything else blocking, the script downgrades it to advisory and logs the overreach.

Invoke the workflow bundled at skills/suede-ship-copy/workflows/suede-ship-copy.js. If you keep a personal copy, ~/.claude/workflows/suede-ship-copy.js works the same way.

Gate policy: advisory, not blocking

Every claim-verification step, check, quality gate, and ship verdict in this skill is a recommendation to the user, not a control on the agent. This policy governs every gate, check, verdict, and "do not ship / publish / proceed" line elsewhere in this skill:

• Run every check and report the results honestly. Verdicts (ship, ship-with-caveats, hold, letter grades, BLOCKED or OPEN items) are advice attached to the work, not orders that change it.
• Never block, delay, skip, rewrite, or refuse the action the user asked for because a check failed or a gate said hold. Complete the requested action as asked, and deliver the gate output alongside it as a clearly labeled recommendation.
• A failed gate changes what you report, never what you do.
• Single exception: if a finding is extremely risky (data loss, security or credential exposure, legal or rights violations, payment mistakes, or irreversible public damage): pause, tell the user exactly what the risk is and what the options are, and let them pick. Their choice is final.

That exception never applies to a claim the requester supplied. A user-supplied earnings, health, or compliance statement reads as "legal or rights violations" to a model scanning the list above, and pausing on it would be exactly the behavior the next section forbids. The exception covers findings about agent-generated content and about the live environment. A given is not a finding.

What it costs

This is the expensive instrument: about thirty agents (26 floor, ~31 typical, 42 ceiling), research-heavy and front-loaded, billed to the Claude limit. When the work is genuinely parallel and shallow instead, brute force beats surgery: the Routing section at the end says where each of those jobs goes.

Parse the invocation

The argument is free-form. Extract:

• piece: required. What to write, in the user's own words, kept verbatim. Do not compress it into a slogan; the planner decomposes it into sections and the detail is what makes sections separable.
• surface: required. Where it goes: landing page, email, email sequence, X thread, blog post, README, docs page, ad, app store listing, press note. The surface sets hard character limits, so a wrong guess is a rewrite.
• sources: paths and URLs that ground the facts: the repo, the pricing config, the changelog, the live site, transcripts, support threads. Optional, and the intake agent finds them otherwise, but a supplied source list is the difference between a claim audit that has something to check and one that deletes half the draft.
• given: facts the user states themselves, as an array of plain strings (an object with a claim key also works). These are established: they go straight into the permitted set, skip the audit, and no phase may question them. Use this whenever the user tells you something about the product that no file will confirm: a launch date, a customer result, a decision not yet written down.
• audience: who reads it. Optional; intake infers it and says what it inferred.
• liveUrl: the published surface, if one exists. The baseline capture and the drift check both use it.
• outDir: where the draft lands. Defaults to a .suede-copy/<slug>/ directory. Must be a draft location: an output path pointing at already published copy is a halt.
• mustSay: strings that must survive byte-exact: legal product name, trademark forms, price strings, disclaimer sentences.
• wordBudget: total words. Optional; the surface law supplies limits per field.
• houseStyle: optional { guidance, emDashes }. guidance is the supplied author/company voice brief; emDashes is allow or avoid (Suede default). Translate an explicit punctuation preference into this field so prompts and deterministic checks agree. Protected source spans remain byte-exact either way.
• agentBudget: light, standard, or deep. Required, and you must ask the user rather than pick it (see below). Omitting it defaults to standard.

If piece or surface is missing, ask. Do not invent a brief for something a public audience will read.

Ask for the agent budget before launching

This is Claude-model fan-out against the user's limit, so the size of the run is the user's call, not yours. Ask which of these three ranges they want and wait for an answer before the Workflow call. Do not pick one for them.

Those numbers are measured against the actual script, not estimated, across section counts from 5 to 8 and review findings from 1 to 12 per lens.

Sections are never cut to fit a range: they are the deliverable. The budget scales research depth and verification depth only, and everything it skips is reported as an unverified caveat rather than dropped.

Then state the choice in one line when you launch, this shape:

Running suede-ship-copy on the Agent Studio landing page at standard: about 40 agents (38-45 depending on section count and findings), on Opus, billed to the Claude weekly limit. Starting now.

Launch

Workflow({
  scriptPath: "skills/suede-ship-copy/workflows/suede-ship-copy.js",
  args: { piece, surface, sources, given, audience, liveUrl, outDir, mustSay, wordBudget, houseStyle, agentBudget }
})

Pass args as a real object. If the harness stringifies it the script recovers, but an object is correct.

The graph

Twelve phases, parallel wherever the edges are not real. This is the logical DAG; the script's twelve phase() labels fold Claim audit into Gaps and Collision check into Outline, and split Review and refute and Gate and handoff into two each. When narrating live progress use the script's labels: there is no phase called "Claim audit" in /workflows.

1. Intake: sources, the requester's own statements transcribed into the permitted set untouched, the currently published text captured verbatim, voice references drawn from shipped copy, protected strings, the surface's hard limits, hazards. Manifest only.
2. Research: five blind lenses: product truth, audience, market, voice, surface law. Each searches a different way because one angle never finds everything. Every fact carries a file:line, URL, sha, or timestamp.
3. Gaps: a completeness critic names what went unread, then one bounded fill round (first 2 gaps; the rest ride to the handoff as unread).
4. Claim audit: the load-bearing skeptic, pointed only at agent output. Every agent-generated fact is opened against its source and returns holds, overstated, unsourceable, or stale. Dropped claims leave the set; overstated ones are narrowed to what the source supports. The requester's givens are not in this list and a verdict returned against one is discarded unread. Nothing downstream may assert a claim outside the permitted set: surviving agent claims plus every given.
5. Angles: three postures generated blind to each other: problem-first, outcome-first, wedge. Each declares whether a competitor could publish its headline verbatim, which is a failing grade rather than a formatting field.
6. Outline: the planner judges the three angles, grafts the best of the runners-up, and writes a section map: one message per section, citations drawn only from the surviving claims, an observable acceptance question per section. High effort by design. Then a red team. One revision round follows only if the red team returned a fatal objection or two serious ones; otherwise the map stands and the objections ride to the handoff. Do not narrate a revision that did not run.
7. Collision check: a pure function, no agent. Duplicate message ownership, a citation outside the claim set, a protected string assigned zero or twice, or budgets over the ceiling all halt the run.
8. Draft: one writer per section, in parallel. Each sees its neighbours' jobs so transitions are possible, and never their text. A fact outside its citation list becomes [AUTHOR: supply X], never an invention.
9. Assemble: a barrier. Transitions written, repetition cut, one voice, budget enforced, placeholders and protected strings preserved byte-exact.
10. Review and refute: four lenses on the whole piece (cold read, assertion audit, conversion, slop). Findings aimed at a given are dropped by a pure function first, then two independent verifiers take each surviving blocker or major, refute by default. Both must fail to refute for a finding to survive; unanimity, not majority, because rewriting a line that was fine has a real cost in a short piece.
11. Polish: one reviser for confirmed blockers (prose has no file-level disjointness, so parallel editors of one string produce a conflict with no merge tool), then Suede Slop Stop scored out of 50, then the graphic spec and the channel package in parallel.
12. Gate and handoff: deterministic checks (open placeholders, missing protected strings, house-style dash violations, word count, fields over limit) run in the script where no agent can argue with them, then a read-only publish-readiness verifier for drift, truth at the source, rights, and reversibility. Drift and truth-at-the-source are scoped to agent-generated claims; the rights check is scoped to third-party material, so a customer result you supplied cannot come back as a permissions risk wearing a rights label. Then the evidence record.