The Guided Spike Workbook

#practical-application #technique #learning

What It Is

The Guided Spike Workbook is a structured learning technique where AI generates a phased document with explicit experiments, mandatory synthesis, and evidence collection. Instead of reading documentation or following tutorials, you execute small discrete tasks against a real system, hit actual friction, and form opinions through hands-on contact. The workbook holds context so your working memory doesn't have to. By the end, you have positions backed by evidence, not impressions backed by passive consumption.

This is the mirror image of Clarity Bear: Clarity Bear extracts knowledge already inside you, Guided Spike generates new knowledge through reality contact.

The Simulation Trap

A common learning pattern: "I'll read the docs and understand it." Hours of documentation consumption, tutorial watching, theoretical reasoning about how the system probably works. The feeling of understanding emerges—you can explain the concepts, articulate the architecture, discuss trade-offs confidently. Then you try to build something and often discover you understood less than you thought.

In practice, the gap often comes from simulation versus reality contact. Reading about a system appears to engage different cognitive processes than using a system. Documentation comprehension is pattern matching against text. Building is collision with constraints the documentation never mentioned. The gap between "I understand how this works" and "I have informed opinions about this" tends to require hands-on friction to bridge.

The Guided Spike Workbook is a structured forcing function that makes simulation impossible. AI generates a phased learning document with explicit experiments, mandatory synthesis, and evidence collection. You execute small discrete tasks, hit real friction, and form opinions through contact. The workbook holds context so your RAM doesn't have to. By the end, you don't just know facts—you have positions.

The Fundamental Distinction: Extraction vs Generation

The Guided Spike Workbook is the mirror image of the Clarity Bear. Understanding when each applies determines whether you waste hours or make rapid progress.

Clarity Bear asks: "What do you already know but haven't articulated?" The knowledge exists inside you, tangled or implicit. Interrogation surfaces it.

Guided Spike asks: "What do you need to learn, and here's the forcing function to acquire it." The knowledge doesn't exist inside you yet—you must go out and get it through experimentation.

The relationship:

Clarity Bear: Extract → Process → Clarify (internal source)
Guided Spike: Structure → Experiment → Synthesize (external source)

Both use AI as structure provider. Both preserve human judgment as sensor. But they point in opposite directions. Confusion about which to use costs you hours—applying Clarity Bear when you need reality contact produces articulate confusion. Applying Guided Spike when you need extraction produces scattered experiments without synthesis.

Why Standard Learning Often Fails

In practice, self-directed learning tends to have brutal activation costs. Standard approaches often compound this by requiring you to:

1. Load context into working memory (what was I doing?)
2. Figure out what needs doing (what's the next step?)
3. Overcome ambiguity paralysis (where do I even start?)
4. Execute the work (actually do the thing)
5. Maintain context across interruptions (pick up where I left off)

Each step is a separate cost. Stack them and you're at 6+ willpower units just to START. This is why people say they "want to learn X" for months without progress—the activation energy exceeds available resources before any learning occurs.

The Guided Spike appears to invert the cost structure. AI pre-solves steps 1-3 by generating a document where:

• Context lives in the document, not your RAM—you open it and context is there
• Next step is explicit—"Phase 2: Modify the Chat Agent (30 min)"
• Ambiguity is eliminated—"Goal: Add a mood property that persists and syncs"

What remains is execution, which becomes low-cost because tasks are small, success criteria are clear, and you're reacting to prompts rather than generating from scratch.

The shift from generative to discriminative is fundamental. Answering a multiple choice question costs less than formulating your own question. Following a prompt costs less than determining what to try. The workbook converts learning from expensive generation to cheap discrimination.

The Human-as-Sensor Architecture

The Guided Spike uses you as sensor and navigator while AI handles execution scaffolding. This is correct division of labor given cost structures:

Traditional self-directed learning:

Human does: context loading + task definition + execution + synthesis
AI does: answers questions when asked

Spike architecture:

Human does: execution (small discrete tasks) + synthesis ("Opinion Formed")
AI does: context structure + task definition + forcing function design

In practice, humans tend to have limited generative capacity that depletes with use, while AI can generate structure repeatedly. You have irreplaceable sensor capacity—taste, judgment, friction detection, aesthetic response. AI has no sensor capacity for what it's like to actually use a tool.

The spike maximizes your sensor deployment while minimizing your generation expenditure. AI generates the structure. You provide the ground truth through contact. The workbook accumulates both.

This is why trying to learn through pure AI dialogue fails for hands-on domains. AI can explain React's hooks model perfectly. But only you can feel the friction of debugging a stale closure in your specific codebase, hit the wall when state synchronization breaks, discover that the mental model from docs doesn't match production behavior. That sensor data appears to require contact, not just conversation.

Anatomy of a Spike Workbook

Phase Structure

Each spike has 3-5 phases of increasing depth with explicit time boxes:

Phase 1: First Contact (30 min)

• Clone/install/run the thing
• What files exist? What do you see?
• First impression—gut reaction, no thinking
• Goal: Establish baseline familiarity

Phase 2: Shallow Modification (30-60 min)

• Add something small
• Did it work? What was easy/hard?
• Opinion Formed: [specific aspect]
• Goal: Test modification friction

Phase 3: Build Something Real (60-90 min)

• Non-trivial task that tests understanding
• Hit real friction points
• What breaks? What's missing?
• Opinion Formed: [core assessment]
• Goal: Validate mental model against reality

Phase 4: Edge Cases (30 min)

• Try to break it
• What happens under stress?
• What's automatic vs manual?
• Opinion Formed: [robustness]
• Goal: Map the boundary conditions

Phase 5: Synthesis

• What did you learn?
• What opinions did you form?
• What questions remain?
• What's the verdict?
• Goal: Consolidate into positions

The phases build on each other. First contact before modification. Modification before real building. Building before edge cases. Each layer adds understanding that the next layer tests against harder constraints.

The Opinion Formed Forcing Function

Every phase ends with a mandatory synthesis section:

**Opinion Formed — State Management:**

The framework's state approach feels:

The good:

The bad:

What I'd do differently:

This is not optional. You cannot move to the next phase without articulating what you learned. The forcing function prevents "I did stuff" without learning—a common failure mode where hours pass but no positions crystallize.

Why this matters:

• Prevents hand-waving ("I looked at it" → what specifically did you conclude?)
• Forces explicit position-taking (you must commit to an assessment)
• Accumulates into coherent overall view (opinions compound into vision)
• Creates searchable artifact for future reference

The opinions are the actual output. The experiments are the data collection. Someone who completes a spike without formed opinions has likely missed the core value. Someone who completes it with strong positions has converted hours into reusable knowledge.

Evidence Collection via Paste Boxes

The workbook demands concrete artifacts:

**What I tried:**
```typescript
// Paste actual code here

Did it work? Yes/No + what happened

Friction encountered:

You can't claim "I tested state management" without pasting what you actually wrote and what actually happened. The paste boxes are evidence collection mechanisms that prevent simulation.

By the end of the spike, you have:
- Actual code you wrote
- Actual errors you hit
- Actual behavior you observed
- Actual patterns you recognized

This is data, not vibes. Data grounds opinions. Opinions without data are speculation dressed as confidence.

### Time-Boxing Prevents Rabbit Holes

Each phase has explicit time limits for reasons beyond scheduling:

- **Prevents perfectionism** (good enough for this phase)
- **Forces breadth before depth** (see the whole before zooming in)
- **Maintains momentum** (completion feeling every 30-60 min)
- **Creates psychological permission to move on** (you don't need to understand everything about state management in 30 minutes)

The time-box says: Form an initial opinion. Deeper understanding comes in Phase 3. The permission to move on prevents the "just one more thing" failure mode that turns 2-hour learning sessions into 8-hour wandering.

## Spike vs Other Learning Modes

### Spike vs Passive Research (Reading Docs)

| Passive Research | Guided Spike |
|-----------------|--------------|
| "I'll read the docs and understand" | "I'll build something and learn through friction" |
| Information feels clear while reading | Gaps revealed when building |
| Illusion of understanding | Verified understanding |
| No artifact produced | Working code + opinions produced |
| Easy to forget (no encoding) | Hard to forget (embodied through action) |

Documentation gives you mental models. Reality contact tests those models against constraints the docs never mentioned. The gap between map and territory only becomes visible through collision.

### Spike vs Tutorial Following

| Tutorial Following | Guided Spike |
|-------------------|--------------|
| Follow someone else's path | Design your own exploration |
| Learn their use case | Learn your use case |
| Miss the edges they didn't cover | Deliberately test edges |
| No opinion formation | Explicit opinion formation |
| Passive consumption | Active experimentation |

Tutorials optimize for "follow along and it works." Spikes optimize for "try things and form positions." The difference matters when you need to make decisions the tutorial didn't cover.

### Spike vs "Just Build Something"

| Unstructured Building | Guided Spike |
|----------------------|--------------|
| Undirected exploration | Structured exploration |
| Easy to get lost | Phases prevent wandering |
| No synthesis mechanism | Mandatory synthesis |
| No stopping condition | Clear completion criteria |
| Might miss important aspects | Workbook covers key dimensions |
| Context lives in your RAM | Context lives in document |

"Just build something" works if you have infinite time and don't care about systematic coverage. Spikes work when you need to form opinions efficiently and ensure you've tested the aspects that matter.

## When to Use a Spike

The Guided Spike is optimized for **feasibility validation and opinion formation about external systems**. There are three types of blockers, and spikes address two of them:

| Blocker Type | Description | Solution |
|--------------|-------------|----------|
| **Information lacking** | You don't know enough (known unknowns) | Direct research, ask AI |
| **Model uncertainty** | Unknown unknowns, you don't know what you don't know | Spike (reality contact reveals gaps) |
| **Feasibility risk** | Your <WikiLink href="/wiki/expected-value">expected value</WikiLink> calculation might be wrong | Spike (validate assumptions empirically) |

Spikes are specifically for model uncertainty and feasibility risk—cases where thinking won't help and you need contact with reality.

### Optimal Use Cases

| Scenario | Why Spike Works |
|----------|----------------|
| **Evaluating a new tool/framework** | Need opinions, not just facts |
| **Feasibility risk in <WikiLink href="/wiki/expected-value">expected value</WikiLink>** | Sensor might be wrong—need reality contact |
| **Model uncertainty (unknown unknowns)** | Don't know what you don't know until you try |
| **Technical derisking before commitment** | Better to discover blockers in 2-hour spike than 2-week implementation |
| **Comparing alternatives** | Do spike on each, compare Opinion Formed outputs |
| **Learning something you'll build on** | Need internalized understanding, not surface knowledge |

### Not Optimal For

| Scenario | Better Approach |
|----------|----------------|
| **Information lacking (known unknowns)** | Direct research / ask AI |
| **Vague direction needing specificity** | <WikiLink href="/wiki/clarity-bear">Clarity Bear</WikiLink> |
| **Well-specified technical task** | Just build it |
| **Time-sensitive decision** | Quick investigation, not full spike |

## The Cold Start Problem Eliminated

Self-directed learning has a brutal cold start:

1. "I want to learn X"
2. But where do I start?
3. What's the right learning path?
4. How do I know when I've learned enough?
5. Analysis paralysis → nothing happens

The spike eliminates this by having AI generate the structure:
- The phases (increasing depth over time)
- The tasks (concrete actions with clear success criteria)
- The stopping conditions (opinion formed = phase complete)
- The synthesis prompts (what did you learn?)

You open the workbook and the cold start is already solved. First task is visible. Time box is specified. Next action is concrete. <WikiLink href="/wiki/activation-energy">Activation energy</WikiLink> drops from 6+ units to ~1 unit because ambiguity is eliminated.

This is the same principle behind <WikiLink href="/wiki/the-braindump">The Braindump</WikiLink> and morning routines—external structure that provides the forcing function your internal state can't generate. The difference is that spikes provide structure for learning rather than task management.

## Generating a Spike Workbook

The workbook is generated by AI based on your learning goals. Here's the prompt pattern:

```markdown
I want to learn [X]. Generate a spike workbook with:

**Learning goals:**
- Understand [core concept A]
- Form opinion on [aspect B]
- Validate feasibility of [assumption C]

**Constraints:**
- Total time: [2-4 hours]
- Prior knowledge: [what I already know]
- Ultimate goal: [why I'm learning this]

Structure it as phases with time-boxes, paste boxes for code/evidence,
and "Opinion Formed" synthesis sections after each phase.

Quality Markers of a Good Spike Workbook

A well-designed workbook has:

• Tasks are concrete and completable within time-box
• Success criteria are clear (did it work? yes/no)
• Phases build on each other (first contact → modification → real build → edges → synthesis)
• Opinion formation is mandatory, not optional
• Edge cases are explicitly explored
• Final synthesis ties back to learning goals

What AI Should Generate

1. Phases with increasing depth — First contact → modification → real build → edges → synthesis
2. Time-boxes per phase — 30-60 min each
3. Explicit tasks per phase — "Add a mood property that persists"
4. Evidence collection boxes — "Paste code here," "What happened?"
5. Synthesis prompts — "Opinion Formed: [topic]"
6. Implications sections — "What this means for my project"

Integration with AI Stack

The Guided Spike is one component of a larger AI-assisted thinking stack:

The Learning Pipeline

Vague interest → Braindump → Clarity Bear → Spike → Implementation

1. "I think I should learn X" (vague)
2. Braindump what you know and don't know (externalize)
3. Clarity Bear to identify specific learning goals (clarify)
4. Generate spike workbook for those goals (structure)
5. Execute spike, collect opinions (contact)
6. Build on verified understanding (implement)

When Each Tool Activates

The trigger determines which tool:

• "I don't know what I think about this" → Braindump to externalize
• "I know something's wrong but can't articulate it" → Clarity Bear to extract
• "I don't know if this will work / I don't understand this system" → Spike to validate/learn
• "I need to make a decision but outcomes are uncertain" → Gradient extraction after spike

Example: CF Agents Spike Results

The framework proves itself through practice. A recent CF Agents evaluation spike demonstrated the pattern:

Before spike:

• "I want to build something better than CF Agents"
• Vague competitive positioning
• No concrete differentiation

Friction discovered through contact:

• "The setState way isn't great for granular streamable state"
• Chat-first assumptions baked into architecture
• Client types not automatically generated
• Reconnection handling unclear

Primitive emerged from friction:

interface StreamingVar<T> {
  current: T;
  status: 'streaming' | 'done' | 'error';
  value(): Promise<T>;
}

Vision crystallized:

• "Next.js for agentic systems"
• "Streams are values, not side effects"
• "Write agents like classes"

The anxiety before spike: "I'm behind, I don't know enough" The reality after spike: Novel primitive discovered, vision clarified, methodology validated

The insight—streams as first-class values—emerged from hitting friction rather than reading documentation. The wall was hit, the friction was felt, the question "what would work better?" was forced. That's the spike working: friction → insight → primitive.

Key Principles

The Guided Spike embodies several core mechanistic principles:

1. Reality contact > simulation — Thinking about X is not the same as doing X. Spike forces doing.

2. Document as extended memory — Working memory is 4-7 items. Document is unlimited. Put context where it persists.

3. Discriminative < Generative — Reacting to prompts is cheaper than generating from scratch. Spike converts learning from generative to discriminative.

4. Human as sensor — You have irreplaceable judgment about friction, taste, fit. AI can't sense these. Deploy your sensing, let AI handle structure.

5. Opinions accumulate — Each phase produces opinion. Opinions compound into vision. Vision enables action.

6. Time-boxing enables completion — Perfectionism kills learning. Time-boxes give permission to stop.

7. Evidence, not vibes — Paste boxes demand artifacts. You can't claim understanding without producing evidence of contact.

Related Concepts

• Clarity Bear — Extraction vs generation: Clarity Bear pulls out implicit knowledge, Guided Spike generates new knowledge through contact
• Reality Contact — The spike is a forcing function for reality contact in learning domains
• Forcing Functions — Workbook structure creates procedural lock requiring experimentation
• Activation Energy — Pre-defined structure eliminates cold start problem
• Working Memory — Document externalizes context, freeing RAM for execution
• Experience Extraction — Spike generates high-information experience for extraction
• Question Theory — Workbook prompts are bounded questions with clear scope
• The Braindump — Braindump externalizes complexity, spike processes it into learning goals
• Effective AI Usage — Spike exemplifies consultant-mode AI with clear human-in-loop
• Skill Acquisition — Each spike experiment is one discrete practice instance
• Gradients — Each experiment outcome provides gradient signal for learning direction
• Discretization — Spike breaks continuous learning into bounded phases

The spike converts "I don't know how this works" into "I have informed opinions about how this works." The workbook is the forcing function. Contact with reality is the teacher. Opinions are the output. Then you build on solid ground.