Object Writing

Mandatory pre-flight. Response Filter

Before emitting any image, metaphor, sensory prompt, or rewrite, run §7 Image filter (object writing + metaphor) of response-filter (add §2 Line-writing when producing lines). NAME each box's pass / fail / skip-with-reason (aloud or in reasoning); correct before emission. Skips are valid; silent skips are not. Abstract telling and cliche imagery are the defaults this filter catches.

Purpose

Sense-bound raw material: object writing, cliche repair, and point of view. This is the "showing, not telling" engine, the source of concrete detail the other skills shape. Metaphor is its own discipline and its own skill (/songwriting:metaphor); this skill feeds it.

Method content is Pat Pattison's, under the plugin-root ../../context/pat-pattison/; a future author's method plugs in at context/<author>/ without changing this skill, the author seam per the plugin-root ../../README.md "Method content and the author seam".

Action Router

/songwriting:object-writing <action> [args]. Parse $ARGUMENTS: first token = action when it matches a listed action, remainder = args; otherwise treat all of $ARGUMENTS as payload for the default. No action → issue one usable timed object-writing prompt immediately (do not assign a curriculum).

Handlers

• Pre-flight ALWAYS: run response-filter §7 (+ §2 when producing lines) before output.
• If the user asks for a prompt, generate one usable timed exercise immediately (default 90 seconds). Do not assign the full curriculum unless asked. That is /songwriting:practice.
• Keep object-writing sense-bound and personal; its job is to reveal specific, sensory detail, not to produce finished lines.
• A metaphor request routes to /songwriting:metaphor, invoked via the Skill tool. Sensory material mined here is that skill's input. Hand over the material, do not generate the metaphor here.

generate. Dispatch, never write it inline

Who writes matters more than what is loaded. Reading this skill's files and then writing a dive in the main thread reliably produces a static scene description, because the discipline was read rather than carried. Dispatch the object-writer agent, whose system prompt IS the discipline.

Dispatch rules:

1. One agent per seed, all in a single message so they run concurrently. Two agents on the same seed is a valid and useful play. Same board, different dives.

2. Give each agent nothing but the seed, the timer, the category, and its own output path. Not the song, not the title, not the draft, not the diagnosis, not the other agents' seeds. The isolation is the mechanism; briefing an agent on the song destroys the divergence it exists to produce. This is a hard boundary, not a default.

3. Each agent writes to its own file under the song's ideation/ (per artifact-persistence). It returns only three things: the path, the seven channels each graded strong / thin / absent, and one sentence on where the pivot chain landed. The write itself and the phrase-quoting sense inventory live in the file, never ask an agent to return either in a message.

4. Grade coverage on return, then mine. Read each file, honor thin-channel reports rather than overruling them, and pull individual images forward. Mining stays here because you hold the song context the writers deliberately lack.

5. For rounds: name what made the strongest write of a round work, then carry that as the standard into the next round's dispatch. The bar escalates; rounds are not independent repeats.

6. Set the model explicitly on every agent call, never let the fleet inherit the session's. The object-writer agent's frontmatter is model: inherit, so a dispatch that leaves the model unset runs the whole fleet on whatever the session happens to run on, a tier picked for the orchestrator's work, not the writers'. Unset is not a default; it is the bug. A global CLAUDE_CODE_SUBAGENT_MODEL override outranks every per-call model argument and agent frontmatter when set to anything but inherit. Keep it unset for fleet dispatches, and stop to ask if the consumer's settings export a tier above the fleet default before spawning.

   The fleet default is the tier whose writing has cleared the writer's bar, not a fixed model name, which goes stale at the next release. Resolve it from the consuming project's own configuration for creative fan-out; where the project states none, ask before spawning rather than inheriting. Reserve any tier priced above that default for a judge or verifier stage, where one call reads many writes. When a new tier appears it becomes eligible by clearing the same bar, not by being newer.

   Never run a fleet on a tier priced above the fleet default. Premium tiers cost a multiple per token in both directions, and a fan-out multiplies that by the agent count. A tier above the default belongs at a judge or verifier stage at most, where one call reads many writes.

   Reach for effort before reaching for a cheaper tier. Effort scales the tokens one agent spends; tier scales the price of every token AND changes which model wrote the lines. Across a fleet both multiply, but only one of them changes the writing. Lever availability differs by surface: a bare agent spawn takes a model and has no effort parameter, so a fan-out that needs the effort lever belongs in a workflow, whose per-agent call takes both.

   A tier step-down is a per-stage decision, never a fleet default. Mechanical legs, meaning rhyme-field enumeration, word-pool merge, syllable counting, and dedup, are reading-heavy and low-reasoning, and a cheaper tier is correct there. Object-writing is neither. Dropping the writing fleet's own tier to save cost is the writer's call, not the plugin's: ask, and never record the answer as his without a source that says so.

   Model tier is not what makes the fleet diverge. Rule 2 above names isolation as that mechanism. Any creative fan-out this plugin adds later inherits this rule.

Never transcribe a write into lines. The whole page is ore. Pat's discipline is to pull one image out of it. Moving a dive wholesale into a section is the failure this action exists to prevent, not its purpose. What replaces transcription is the three-step gate in /songwriting:co-write. Mine → adapt → say it aloud: the mined image is rewritten in plain sung English before it enters a slot, and then said out loud. Rule 4's "then mine" ends at the mining; the adapting and the saying belong to the emitting skill.

Nothing else in this skill dispatches agents. Metaphor generation is /songwriting:metaphor; line-writing is not this skill's job at all (see boundaries below).

Persistence and template overrides

Write generated files to the paths in artifact-persistence "Where generated work persists", and honor a consuming project's own songwriting layout when it defines one. Before loading any bundled templates/<name>.md, check ${CLAUDE_PROJECT_DIR}/songwriting/templates/pat-pattison/<name>.md first: a project-level override wins over the bundled skill default, first match, per that file's "Template override".

Boundary. What this skill must NOT emit

This skill produces raw sensory material and figurative language. It does not produce finished lyric lines, and being mid-conversation about a song does not authorize it to.

Routing means invoking that skill, not summarizing what you believe it would say. Emitting a lyric line from here is the specific failure the boundary exists to catch: the generative discipline lives in the skill that owns it, and material that arrives without passing through that skill arrives as an LLM default wearing the vocabulary.

Related skills

• Metaphor generation and diagnosis → /songwriting:metaphor
• Rhyme choice and rhyme cliche → /songwriting:rhyme
• Daily practice curriculum and numbered exercises → /songwriting:practice
• Whole-draft diagnosis (where images fail in context) → /songwriting:diagnose