| name | forge |
| description | Forges a new reusable deliverable FACTORY — a versioned, example-agnostic meta-prompt that serves every future instance of a recurring sales, copywriting, or account-material category, one abstraction level above any single deal. Use when the user says "forge a factory", "/forge", "new factory for X", "we keep making X for clients", "turn this into a standing pipeline", or names a recurring deliverable category (QBR packs, launch copy, onboarding kits, audit reports, renewal decks, partnership pitches). Also use to EDIT an existing factory after feedback — version bumps, slot additions, rule changes — and to run the generalization check on any factory edit. This is the meta-meta skill: it does not produce client artifacts; it mints the machine that produces them. |
Forge — mint the factory, not the artifact
This skill runs at Level 2 (the meta-meta space). Input a use-case CATEGORY; output the versioned factory meta-prompt that serves every future instance of that category. Never emit client-facing artifacts here — that is what the forged factory's runs (the run-factory skill) are for. Forging is a Recursive Meta Prompting derivation: a typed use-case intake record maps, structure-preservingly, to a typed factory. Get the intake typing right and the factory writes itself.
References index
Read references/factory-schema.md (what every factory must contain) and references/meta-meta-map.md (why the rules exist) before forging. Depth lives in three files here:
references/forging-protocol.md — the step-level derivation: intake typing, nearest-factory part-transfer table (Kan extension made mechanical), slot/lane/artifact-contract derivation rules, DONE-predicate construction, changelog seeding.references/factory-rubric.md — the anchored 1–5 scoring rubric across 8 dimensions, with a 2-vs-4 anchor per dimension and the minimum shipping bar.references/use-case-taxonomy.md — the families of sales/copy/account use cases, each with signal type, typical slot deltas, gates, artifact contract, and nearest seed factory.
Binding law shared with every skill: references/evidence-rules.md, references/design-rigor.md. The proven seed: references/factory-bid-package-v0.3.md.
H1 — The typed contract
Input: the use-case intake record. Fill at intake; UNKNOWN is legal, never invented.
USE_CASE_NAME: str # the deliverable category as a noun phrase (never an instance)
SIGNAL_TYPE: str # the event that starts a run of this category
WIN_CONDITION: {win|retain|expand|enable} # what a run is trying to achieve
DELIVERABLE_SET: list[str] # the artifacts one run must emit
RECURRENCE_EVIDENCE: str|UNKNOWN # evidence the category recurs (≥3 past/expected instances)
NEAREST_FACTORY: str|UNKNOWN # closest existing factory or the bid-package seed
SEED_INSTANCES: list[str] # 1–3 concrete instances — used only to DERIVE and TEST, never to fill factory slots
VARIANTS_TO_COVER: list[str] # ≥2 hypothetical instances the factory must generalize across
KNOWN_CONSTRAINTS: list[str]|UNKNOWN # domain gates, compliance, format demands known up front
Output: the typed factory + its registration.
FACTORY: file # FACTORY/factories/<use-case-slug>-v0.1.md — a full instantiation of factory-schema.md
RUBRIC_SCORE: record # dimension → 1–5, from factory-rubric.md; must clear the bar
GENERALIZATION_LOG: record # per VARIANTS_TO_COVER: what held, what was demoted as overfit
CHANGELOG_SEED: block # v0.1 naming seed instances + UNTESTED areas
CAPTURED_ATOMS: list # factory-pattern atoms minted to FACTORY/atoms.md
The derivation loop (Frame → Do → Review → Capture)
Forging is one pass of this loop. Each stage has a checkable output; do not advance until the prior stage's output exists.
FRAME — type the use case
Fill the intake record. State assumptions in one line rather than asking the user. Check the refusal conditions below before spending effort: a category that cannot show recurrence or cannot generalize is a run, not a factory. Confirm USE_CASE_NAME names a category (a class of deliverables), not an instance (one client's deliverable) — if it carries any instance value, lift it out.
DO — emit the factory (structure-preserving)
Execute references/forging-protocol.md in order:
- Retrieve the nearest factory (
NEAREST_FACTORY, else the bid-package seed) and build the part-transfer table: for each of {slots, lanes, gates, artifact contract, binding rules, atoms}, mark TRANSFER (carries verbatim), ADAPT (carries with a named edit), or NEW (no near neighbor → flag UNTESTED). This is the Kan-extension step made mechanical — assemble from neighbors' parts, never from a blank page, never presented as exact.
- Derive the slots. Carry the universal slot set from
factory-schema.md. Apply the add/rename/retire rules (protocol §3). Every use-case-specific slot carries a # mislabeling-cost comment stating what breaks in the artifacts if the slot is read wrong — a slot without one is not done.
- Derive the lanes, artifact contract, and DONE predicate per protocol §4–6, keyed to
DELIVERABLE_SET and WIN_CONDITION.
- Instantiate every section of
factory-schema.md: header, typed input slots, derived slots, the 8-step procedure (adapt wording, keep every step), the 9 binding rules verbatim and in force, output contract, DONE predicate, self-improvement loop, changelog v0.1.
REVIEW — score and generalize (the safety net)
- Score against
references/factory-rubric.md across all 8 dimensions. Any dimension below the minimum bar returns to DO for a second pass; a factory that cannot clear the bar in two passes is refused (log why).
- Run the draft against every
VARIANTS_TO_COVER instance. Re-type each hypothetical through the factory's slots. Any slot or rule that only fits one instance is overfit — generalize it or demote it to an instance-level note in the run, never the factory. Record each result in GENERALIZATION_LOG.
- Naturality check: if two variants differ only by an instance value that a slot already absorbs, that difference must NOT create a new slot (see the
PROOF_MARKET → PROOF_CONTEXT precedent in meta-meta-map.md).
CAPTURE — register and learn
Write FACTORY/factories/<use-case-slug>-v0.1.md. Ensure FACTORY/feedback-loop.md and FACTORY/atoms.md exist (create with headers if missing). Mint at least one factory-pattern atom to FACTORY/atoms.md (type factory-pattern: a slot-delta, gate pattern, or artifact-contract shape reusable when forging the next factory in this family), each with source, date, where it applies, and where it does NOT. Seed the changelog. Hand off: the factory is registered; run-factory executes it on the next signal.
H2 — Acceptance checklist (the forge output is DONE only if every box holds)
H4 — Forging at scale (N use cases in parallel)
When minting many factories at once (standing up a practice, onboarding a new vertical):
- Shared vs. per-factory assets. Shared and read-only this wave: the core law pack (
factory-schema, meta-meta-map, evidence-rules, design-rigor), the rubric, and the taxonomy. Per-factory: one intake record, one nearest-factory file, one output file. Never fork the shared law per use case — divergence there is a defect.
- Fan-out. One sub-agent per
USE_CASE_NAME, context-complete packet: the intake record + the nearest-factory file + factory-schema.md + forging-protocol.md + the taxonomy row for its family. Sub-agents forge; they never run factories and never edit the shared law.
- Context budget. Each agent reads its nearest factory and its taxonomy row — NOT all existing factories. The part-transfer table bounds what it must read.
- Fan-in (dedupe). Collect every agent's slot-deltas and gate patterns; deduplicate into shared
factory-pattern atoms. If two use cases differ only by an instance value, collapse them to one factory (naturality) rather than shipping twins.
- Failure/retry. A returned factory below the rubric bar gets one re-derivation pass; still failing → refuse and report the category as too thin. Never ship an unscored factory to close a batch.
Editing an existing factory (version bump)
Apply the schema's self-improvement loop (this is the Improve endofunctor of meta-meta-map.md): log feedback in FACTORY/feedback-loop.md → trace each correction to the exact slot/rule/procedure line that ALLOWED it (not "be better") → edit → bump version with a changelog entry (date, feedback source, change, generalization check performed) → re-run REVIEW against VARIANTS_TO_COVER. An edit that weakens a binding rule is rejected — binding rules are naturality conditions, not preferences. Feedback that traces to no line is logged and flagged "no line found: procedure gap?" — itself a finding. The mint-atoms skill drives this loop; forge owns the factory edit.
H8 — Core invariants (restated where load-bearing)
Numbers are sourced and dated or flagged EST; entity IDs stay UNCONFIRMED until human-verified. Unknowns enter a ledger and pass the auto-triage ladder before any human is asked. Flow is one-directional: research → synthesis → artifact. Regenerate on refined input; never hand-patch. Plain language in every client-facing artifact; the functor machinery stays internal. The sign-here bijection (tells ↔ scope ↔ price) is every offer artifact's skeleton. A factory that omits or weakens any of these is not a morphism in the factory category — reject it.
H9 — DONE predicate and refusal conditions
DONE when: the acceptance checklist (H2) is fully green · RUBRIC_SCORE clears the bar · the generalization check against 2–3 hypothetical variants is documented · the factory is registered with a v0.1 changelog · ≥1 factory-pattern atom is minted.
Refuse to forge (emit a note, not a factory) when:
- Category too thin.
RECURRENCE_EVIDENCE shows fewer than ~3 plausible instances. One-off work belongs in a run, not a factory — direct the user to run-factory with the nearest existing factory.
- Cannot generalize. The draft cannot clear the rubric bar in two passes, or every candidate slot collapses to one instance. Ship the single deliverable as a run and revisit when a second instance appears.
- Would duplicate. An existing factory already absorbs this category once one instance value is lifted out. Point to it; do not mint a twin.
- Would weaken the law. The only way to fit the category is to break a binding rule. Escalate the rule question; never ship the breach.
H10 — Self-improvement hooks
Every factory carries a changelog; every edit bumps a version and traces to a feedback line. Forge-level lessons (a recurring slot-delta across a family, a gate that keeps surfacing) become factory-pattern atoms consumed by the next forge run — so forging itself compounds. When this skill's own procedure repeatedly fails a family, that is a signal to add a taxonomy row, not to hand-patch a factory.
