Generative Memories: killed ideas that keep teaching

The count from my own bench on the day this shipped: three full designs for one system, all three killed by my own AI judge panel. Unanimous verdicts.

That should have been the end of it. It became the most useful thing I built this month.

I call them Generative Memories. On a schedule, no human in the loop, the system takes one killed approach from a past brainstorm, expands the old sketch into a mini-spec, builds it as a throwaway ghost, and distils what the build taught into my knowledge system. Tagged, always, as counterfactual. This build never shipped.

The build is the instrument. The memory is the product.

Without the build, the memory is hallucination wearing a dead idea's name. Without a typed distil schema, the build is noise. Both ends of that sentence are load-bearing.

---

The goal, before the mechanism

The goal is not "more memory." The goal is progressive creative force.

Verbatim, the brief that locked the design:

Essentially the goal of this is to make something where we're progressively thinking creatively and taking creative approaches to solving problems.

Every brainstorm I run kills two ideas for every one that ships. The winner is usually the safe pick. The kills are where the creativity was hiding. If those kills only live as discarded prose in a digest, the knowledge system never gets the experience of the road not taken. Future brainstorms only recall what won. That is how a system gets more efficient and less creative at the same time.

Generative Memories reverse that asymmetry. The safe pick still ships. The kill still dies as product. The kill's build experience survives as a marked memory. Next time a related problem lands, recall can surface not only what worked, but what building the discarded path would have taught.

---

Methodology: swarm, kill, salvage, hybrid, gate

This system was designed by the same discipline it feeds.

Six discovery legs mapped the real landscape. Three draft approaches proposed shapes. Three judge legs attacked those shapes. All three approaches were killed with salvage. The shipped design is the hybrid the judges left standing:

• Spine from the risk-first draft: provenance proof before any timer, executor probe before any real ghost, one end-to-end run before unattended cadence.
• Body from the mvp-first draft: single-file pipeline, one ghost per run, typed memory schema, cheapest expand before paid build.
• Armor from the portability-first draft: substrate names only in config, sink that refuses to write where real memories live, no auto-cleanup of ghosts (disk stays hands-off).
• Heart from the goal reframe above: creativity compounds; the product is insight, not code.

That is not committee design. It is kill-with-salvage. The judges were not a rubber stamp. They destroyed three coherent proposals and left a pile of reusable parts. The synthesis step is where the creative mass from the kills becomes the winner's skeleton.

Risk-ordered milestones, each gating the next:

1. Recon: verify what the knowledge system actually does today, not what the docs claim. (The old distiller path was a dead stub. Live ingest is a file scan over a path-to-layer map. Recall has no layer filter. Killed digests already enter as raw fact. These four facts shaped every later decision.)
2. Provenance proof: hand-write one mock counterfactual memory, prove it ingests under a dedicated synthetic layer, prove the banner is visible in recalled chunks. No timer before this passes.
3. Executor probe: one trivial headless build under the real unattended runner, no terminal attached. Exit code and logs to a file, always. Invisible process death is how autonomous work rots.
4. Single ghost end to end: one real kill, human-scored memory quality against the schema.
5. Timer on: unattended cadence. Success stays silent. Failures surface in status. Budget cap blocks further runs rather than bleeding.

The order is the design. A prettier pipeline that writes unmarked fiction into a trusted memory store is worse than no pipeline.

---

The design problem was provenance, not scheduling

A fake experience in a trusted memory store is worse than no memory.

Recall has no filters today. Synthetic notes will sit next to real ones. Marking only in metadata is not enough: if a chunk is retrieved, the reader (human or model) must see the mark in the chunk. Defence in depth:

1. Dedicated layer for synthetic memories in the ingest map, so the index records the class even when query APIs do not filter by it.
2. Sink pre-flight that refuses any emit path an existing ingest glob would claim under a non-synthetic layer.
3. Frontmatter with an explicit counterfactual provenance field and a filename prefix that never collides with human notes.
4. Body banner as line one, verbatim, so every retrieved fragment carries the warning even when frontmatter is stripped.

[ fig ]

MEMORY.md

SYNTHETIC COUNTERFACTUAL // this build never shipped

1. 01What surprised
2. 02Technique emerged
3. 03Transfers to
4. 04Kill verdict
5. 05Build shape
6. 06Open questions

provenance: synthetic_counterfactual

The schema is the other half of the heart. Required sections, fixed order, each validated for substance (not empty, not generic filler):

1. What surprised: unexpected findings from actually building it.
2. Technique emerged: novel methods or tricks the build surfaced.
3. Transfers to: the problem class future brainstorms should recall this against.
4. Kill verdict: confirmed or refuted: did the ghost validate the original kill reasoning?
5. Build shape: what got built, rough size, how far it got.
6. Open questions: what a real attempt would still need to answer.

A rehash of the original kill digest fails What surprised. Digests already reach the knowledge system as semantic fact. The whole point of the ghost is new signal that only appears when you force the idea into code.

---

The pipeline

One run, one killed idea, oldest unledgered first.

[ fig ]

GENERATIVE MEMORIES

01INTAKEkilled sketches

→

02EXPANDmini-spec

→

03BUILDthrowaway ghost

→

04DISTILtyped memory

→

05EMITcounterfactual

GATEschema non-empty · provenance marked · cost capped

one killed idea per run

Intake. Scan past brainstorm digests for kill verdicts only. Multiple corpus shapes exist (schema-declared digests, prose synthesis tables, older flat files). Parse all of them or starve silently. Dedup by a stable key over slug, approach id, and normalised sketch text. Salvage verdicts stay out of v1 intake on purpose.

Expand. One local pass turns the ~250-word kill sketch plus its refutations into a buildable mini-spec, with the kill reasoning attached. Local first so the paid budget buys build, not planning.

Build. One headless coding seat against the mini-spec, working directory = the ghost. Cost checked before the call. Cap per run. Timeout backstop. Spend recorded in an append-only ledger.

Distil. Structured pass over mini-spec + build transcript + kill refutation → memory markdown matching the typed schema. Optimise for transferable creative insight, not a build summary.

Validate. Every required field non-empty with substance. Empty means the run fails validation. Failed keys retry once on a later run, then park and surface. No silent burns. No infinite retries.

Emit. Sink pre-flight, then write only into the synthetic memories directory. Ledger the result.

Cadence is every three days, one ghost per run. Rough ceiling is on the order of ten runs a month under the per-run cap. The timer is the driver. Manual seats exist for status and dry-run; they are not required for operation. Automation stays event-triggered.

What v1 deliberately does not build: multi-executor support beyond a config seam, salvage intake, auto-cleanup of ghosts, brain-side recall filters, remote push of anything. The open threads are distil quality dial, a stronger stamp lane if the layer mark proves insufficient, a morning-panel line for failures, and salvage-verdict intake later.

---

Benefits: why the kill is the creative mass

Creativity compounds. Each ghost adds experience the winner path never generated. The knowledge system gains roads not taken, not only roads shipped.

Killed ideas stop being waste. A kill used to mean: write the refutation, move on, lose the build experience forever. Now the kill is a scheduled job. The sketch becomes a teacher on a delay.

The safe pick bias gets countered. Brainstorm winners skew conservative because judges optimise for ship risk. The creative mass often lives in the options that failed a constraint. Generative Memories harvest that mass without putting the failed option into production.

Gates earn trust. Autonomous write into a long-lived memory store is a red-zone operation if provenance is soft. Risk-ordered gates + typed schema + human score on the first real memory make the timer a promotion, not a leap of faith.

Transfer is first-class. The Transfers to field is the retrieval key future work needs. Without it, you get build diaries. With it, you get a technique library indexed by problem class.

---

The four-bug saga (why the gates exist)

M3, the single-ghost end-to-end gate, did not pass on the first try. It took four runs. Each run failed for a different reason. Each gate caught exactly one bug.

[ fig ]

R1 · FAIL → FIX

CAUGHTbuilder narrated instead of writing files

SILENT NON-BUILD

R2 · FAIL → FIX

CAUGHTterminal junk polluted the distill input

ESCAPE NOISE

R3 · FAIL → FIX

CAUGHTgate stricter than the model could pass cleanly

VALIDATOR HARDER

R4 · FAIL → FIX

CAUGHTchain-of-thought preamble rode into the memory

PREAMBLE LEAK

Run 1: silent non-build. The coding seat described the project in prose and never wrote files. The distil stage had nothing real to chew on. Fix: force file-writing acceptance checks into the mini-spec and treat "no artifacts" as build failure, not as a soft miss.

Run 2: escape noise. Terminal control codes and status chrome polluted the transcript. The distil model tried to make meaning from junk. Fix: strip and normalise build output before distil; log the raw separately.

Run 3: validator harder than the model. Schema validation rejected output the model almost got right: too strict on section shape, too loose on substance. Fix: validate required section presence and minimum substance length, not brittle formatting that fights the model.

Run 4: preamble leak. Chain-of-thought framing rode into the memory body. The banner and sections were fine; the voice was contaminated. Fix: strip known preamble patterns; re-validate.

Fourth run emitted the first real memory. I scored it myself before the timer earned trust. Real insight, not a rehash of the kill digest.

That saga is the proof the methodology works. The gates are not ceremony. They are the reason an unattended writer is allowed near a trusted store.

---

First memory: what the ghost taught

Source kill: a "define work, not agents" approach from a work-not-people doctrine brainstorm. Judges killed the template shape. The ghost built a small validator instead.

Highlights that earned the human score:

• What surprised: the "How" axis is a Trojan horse for persona language. People naturally personify the mechanism ("the researcher finds…") instead of stating the work ("extract data from…"). The concept needs linguistic policing, not only structural guidance.
• Technique emerged: Linguistic Linting. Negative constraints (banned keyword lists) as a primary architectural driver. More effective to punish persona-drift than to suggest a new style in a template.
• Transfers to: agentic orchestration frameworks. Decoupling task definition from agent identity lets you hot-swap models without rewriting the instruction set.
• Kill verdict: confirmed as template, salvaged as validator. A template alone cannot prevent human or model drift. As a linter with programmable enforcement, the pattern is resilient.

The idea died as a template. It survives as a validator. That sentence is the whole product category: counterfactual experience that refines how you kill and how you salvage next time.

---

Stage of development

v1 is live. Not a design doc. Not a dry-run theatre.

Surface	State
Pipeline CLI	single-file, tests green
Provenance path	synthetic layer verified end to end; banner visible in recalled chunks
First ghost	emitted, human-scored
Cadence	unattended timer every three days
Cost	hard per-run cap; pause on breach
Intake	kill verdicts across multiple digest shapes
Open	distil quality dial, stamp lane, morning panel, salvage intake

What "live" does and does not mean: the system will keep emitting on schedule. Quality of distil is the remaining soft risk. If local expand or distil proves weak, the paid seat moves, or distil routes to a stronger model. That dial is deliberate and not yet burned.

The first unattended fires after ship are the real soak. Status is the surface. Cap-pause is sticky on purpose; clearing it is a human act, not a silent retry.

---

Thought process: what I refused to optimise away

Several instincts fought the design. Naming them is part of the methodology.

"Just summarise the kill digests." Rejected. Digests already enter the knowledge system. A summary of a summary adds no build experience. Without the ghost, you are laundering prose into the authority of memory.

"Write synthetic notes without building." Rejected harder. That is how you poison a zero-loss store. The catastrophic failure mode is not wasted compute. It is a model that treats fiction as lived experience.

"Human approval every emit." Rejected for v1. Hands-off was a locked decision. Trust moves into gates and schema, not into a queue Ari will ignore at 4am. The human score on the first real memory is the promotion ceremony for the timer, not a permanent approval loop.

"Clean up ghosts automatically." Rejected forever under disk-is-hands-off. Status reports total ghost disk. Ari prunes. Autonomy does not get a delete path.

"Multi-executor from day one." Rejected. Config seam only. One coding seat until headless reliability is boring.

The through-line: the product is creative insight under counterfactual provenance. Everything else is instrument design.

---

What you can steal tonight

You do not need my pipeline. You need the law.

1. Keep every rejected option in one place. Kill digests, not chat scrollback.
2. Schedule a cheap job that builds one and writes what it taught. One is enough. Cadence beats backlog heroics.
3. Mark those notes as fiction that teaches, forever. Banner in the body. Dedicated class in the store. Sink that refuses to blur the line.
4. Type the memory. Surprise, technique, transfer class, kill confirmed or refuted. If those fields are empty, the run failed.
5. Gate before unattended write. Provenance proof, executor probe, one human-scored emit, then the timer.

Killed ideas aren't waste. They're unexplored territory. Explore on schedule.

The roads not taken keep teaching. The safe pick still ships. The knowledge system gets both.

//A<3