Batch Cognition

Process bulk prompts with stop-start play/think cycles. Save first, lose nothing, discover value.

Activation

User signals: "batch incoming" / "multiple prompts incoming" / "corpus incoming"

Respond: INLINECODE0

Step 1: SAVE (mandatory, before any processing)

Parse input into individual prompts (split on blank lines or ---).
Write entire batch to workspace/systems/batch-cognition/batches/YYYY-MM-DD-HHMMSS.md.
Read prior value-stack.md and last batch's meta-think for cross-batch context.
Format:

CODEBLOCK0

Confirm to user: "✅ Saved [N] prompts to batch doc. Starting processing."

Step 1.5: PRE-SCAN & CLASSIFY (per item, before processing)

Read first 100 chars of each item. Classify type and assign depth budget:

Type	Signal	Depth
INSTRUCTION	imperative verb, "do X", question	500-5,000 tokens
IDEA

"what if", speculative, future-oriented | 1,000-5,000 tokens |
| MODEL_OUTPUT | AI-generated structure, assistant voice | 200-500 tokens (extract idea only) |
| SYSTEM_LOG | timestamps, paths, JSON, errors | 100-200 tokens (scan for facts) |
| HALF_THOUGHT | fragment, trails off, no clear action | 500-1,000 tokens (complete + infer) |
| REFERENCE | links, citations, docs | 100 tokens (catalog) |
| NOISE | duplicates, filler, "test" | 10 tokens (tag 🔴, skip) |
| UNKNOWN | can't classify | 1,000 tokens (deeper read) |

Add type + depth to batch doc under each item header.

Step 2: PLAY (per prompt)

Execute the prompt. Not summarize — EXECUTE. The depth must match the item:

Item Type	PLAY means	Minimum output
INSTRUCTION (build X)	Build it or write the code/artifact	Working artifact or complete spec
INSTRUCTION (research X)

Actually research, cite sources | Findings with URLs/evidence |
| IDEA (product/business) | Scope: prototype cost, token budget, hours, revenue math | Numbers, not vibes |
| MODEL_OUTPUT | Extract core, check if already done, assess current relevance | Decision: act/park/discard with reason |
| HALF_THOUGHT | Complete the thought, find the value path | Fleshed-out version with next step |

Prototype cost formula (for any buildable idea):

• - Website/app: hours × $0 (we build) + API costs + hosting. Estimate tokens for AI-assisted build.
• Script/tool: lines of code estimate → token estimate (1 LOC ≈ 10-20 tokens to generate)
• Research: number of searches + fetches × ~500 tokens each
• Total = build tokens + test tokens + fix tokens (budget 30% extra for iteration)

"Solid" means tested. First pass is never solid. Flag items that need a second pass.

Append output under the prompt entry. Update status to [~] PLAYING.
Take factual notes: what was done, what was produced, what was discovered.

Step 3: THINK (per prompt, immediately after PLAY)

Answer 5 questions (keep tight, 1-2 lines each):

1. 1. Learned: factual takeaway
2. Pertinent: relevant to user's current projects/goals?
3. Value: creative thinking → value creation → money path?
4. Act?: yes/no — if yes, smallest next step
5. Future: park / discard / investigate deeper

Tag: 🟢 ACT NOW | 🟡 PARK | 🔴 DISCARD | 🔵 INVESTIGATE

Update status to [x] DONE with tag.

Step 4: CHECKPOINT (every 5 prompts)

Brief summary: what's covered, patterns emerging, top value items so far.
Ask: "Continue, pause, or pivot?" — if no response in 30s, continue.

Step 5: META-THINK (on "done" or batch exhausted)

Review all Think notes. Produce:

1. 1. Value Stack — ranked by expected value
2. Patterns — themes, connections
3. Action Items — concrete next steps
4. Park List — not now but maybe later
5. Discard List — safe to ignore (1-line reason each)

Append to batch doc. Update status to COMPLETE.
Append 🟢 items to systems/batch-cognition/value-stack.md.
Append 🟡 items to systems/batch-cognition/parked.md.
Append 🔴 items to systems/batch-cognition/discarded.md.
Log any cross-batch connections to systems/batch-cognition/connection-graph.md.

Commands (user can say anytime)

INLINECODE11 — skip current prompt | deeper — spend more tokens | park — park for later
pause — stop, resume later | resume — continue paused batch | status — show progress
value stack — show current ranked items | done — trigger meta-think + close

Context Management

Rolling decay memory — each checkpoint creates a new block in a chain.
Items decay 20% per block. Referenced items reset to full weight. Below 0.2 = archived (never lost).
See references/rolling-decay-memory.md for full spec.

At each checkpoint:

1. 1. Score all items: salience *= 0.8, re-referenced items → INLINECODE20
2. Drop items below 0.2 threshold (write tombstone, archive to disk)
3. Carry forward: rolling summary + surviving high-salience items + value stack
4. New block header written to chain file

Cross-batch: last batch's survivors enter new batch at 0.8, connect to new items → reset to 1.0.

See references/drive-mode.md when processing Drive folder dumps.

Self-Improvement

After each batch, append to workspace/systems/batch-cognition/learnings.md:

• - What worked / what was wasted / grouping improvements / play-think split effectiveness
• Update this skill if any rule changes warranted.

Key Rules

• - SAVE FIRST — never process before saving full batch to file
• Never lose input — if Telegram truncates or splits, wait for "done" before processing
• Play and Think are separate — don't blend execution with inference
• Notes are mandatory — both Play notes and Think notes, every prompt
• Prompts aren't always instructions — some are ideas, half-thoughts, value discovery. THINK phase handles these.
• PLAY means EXECUTE, not summarize — if it says build, build. If it says research, research with sources. If it's an idea, scope it with real numbers.
• First pass is never final — flag items that need deeper work. A 🟢 tag without execution is just a bookmark.
• Prototype cost is mandatory for buildable ideas — hours, tokens, API costs, hosting. Not vibes.