Memory Palace Architect

# Domain Analysis for Memory Palaces

Thorough domain analysis validates your memory palace accurately reflects the knowledge structure you're organizing.

## Analysis Process

### Step 1: Identify Core Concepts
- List all primary concepts in the domain
- Note the relative importance of each concept
- Identify foundational vs. advanced concepts

### Step 2: Map Relationships
- Document parent-child relationships (hierarchy)
- Identify sibling concepts (same level)
- Note cross-cutting concerns that span categories

### Step 3: Assess Complexity
- Rate each concept's complexity (1-5)
- Identify concepts requiring prerequisite knowledge
- Note areas with high information density

### Step 4: Define Access Patterns
- How often will each concept be accessed?
- What are typical entry points?
- Which concepts are frequently accessed together?

## Analysis Template

```yaml
domain:
  name: "Domain Name"
  scope: "What this domain covers"

concepts:
  - name: "Concept A"
    importance: high | medium | low
    complexity: 1-5
    prerequisites: []
    related_to: []
    access_frequency: frequent | occasional | rare

relationships:
  hierarchical:
    - parent: "Category"
      children: ["Concept A", "Concept B"]
  associative:
    - from: "Concept A"
      to: "Concept B"
      type: "complementary | sequential | contrasting"

boundaries:
  included: ["topics in scope"]
  excluded: ["topics out of scope"]
  adjacent: ["related domains"]
```

## Best Practices

1. **Start broad, then narrow** - Begin with major categories before details
2. **Use domain expert input** - Validate your analysis with subject matter experts
3. **Consider evolution** - Design for how the domain might grow
4. **Document uncertainties** - Note areas where relationships are unclear


---
name: franklin-protocol
description: Apply Benjamin Franklin's learning algorithm to memory palace construction and skill acquisition
category: techniques
tags: [learning, iteration, deliberate-practice, improvement]
dependencies: [memory-palace-architect]
complexity: intermediate
estimated_tokens: 400
source: https://spf13.com/p/how-benjamin-franklin-invented-machine-learning-in-1720/
---

# The Franklin Protocol for Memory Palace Design

Benjamin Franklin's 1720 writing improvement method provides a systematic approach for building effective memory palaces and acquiring any skill.

## The Core Algorithm

Franklin treated skill deficiency as an engineering problem. His method:

1. **Feature Extraction** - Compress exemplar to essential structure
2. **Deliberate Delay** - Wait to prevent rote memorization
3. **Reconstruction** - Rebuild from compressed understanding
4. **Error Calculation** - Compare against original, find gaps
5. **Parameter Update** - Lean into errors, adjust, iterate

## Applying to Memory Palace Construction

### Step 1: Find Your Spectator
Identify an exemplary knowledge structure:
- Well-organized documentation
- Expert's mental model of the domain
- Existing high-quality memory palace

### Step 2: Extract Features
Create "short hints" of the structure:
```yaml
hints:
  - "Three main districts: Core, Extensions, Ecosystem"
  - "Each building maps to major category"
  - "Connections follow dependency relationships"
```

### Step 3: Reconstruct from Hints
After a deliberate pause, rebuild the palace:
- Design your own layout from the hints
- Don't look at the original
- Trust your compressed understanding

### Step 4: Compare and Calculate Error
Side-by-side comparison:
- What did you miss?
- Where is navigation awkward?
- Which associations are weak?

### Step 5: Update and Iterate
Lean into discrepancies:
- Strengthen weak associations
- Add missing connections
- Refine sensory encoding