How This Site Works

A working demonstration of semantic memory architecture.

You're Inside the Proof

This isn't just a website about semantic memory. It's a semantic memory system you can examine, trace, and verify.

Everything you're reading was generated from canonical claims stored in markdown files. The HTML you see is a derived artifact—output from a build system that transforms source truth into audience-specific presentations.

This page maps how it works.

The Three Layers

Layer 1: Canonical Claims

Eight markdown files contain the source of truth:

File Content Word Count
pages/index.md Homepage — emotional hook, problem statement ~800
pages/methodology.md How Semantic Memory Systems work ~2,200
pages/proof-points.md TerpTune + Book of Fire + This Site ~1,800
pages/how-this-site-works.md This page — meta-transparency ~1,400
pages/healthcare.md Clinical protocols, compliance, EHR ~2,400
pages/software.md API docs, knowledge bases, tribal knowledge ~2,300
pages/retail.md Pricing, product content, multi-location ~2,400
pages/education.md Curriculum, policy, assessment ~2,300

These files contain prose—verified claims about what we believe and offer. They're written for humans to read and edit.

The canonical claims that appear across all pages: - Truth fragments when stored in multiple systems - Verification at source scales; verification of copies doesn't - AI generation without verification creates confident lies - Organizational change requires architecture, not tooling

Each vertical page expresses these in industry-specific language. The healthcare page talks about protocol drift. The software page talks about doc rot. Same underlying truth, different rendering.

Layer 2: Governed Derivation

A Python build system transforms markdown into HTML:

build/
├── generate.py        # The generator (~200 lines)
├── templates/
│   └── base.html      # HTML template with placeholders
└── static/
    └── styles.css     # Design system CSS

What the generator does:

  1. Reads each markdown file
  2. Converts markdown to HTML using the markdown library
  3. Injects into the template: {{title}}, {{description}}, {{content}}
  4. Applies theme classes for vertical pages
  5. Sets navigation active states
  6. Copies static files to output

The derivation rules are explicit:

"healthcare": {
    "source": PAGES_DIR / "healthcare.md",
    "title": "Semantic Memory for Healthcare",
    "theme": "theme-healthcare",  # Applies emerald accent
    "nav_active": "industries",
}

Every page has defined metadata. The generator doesn't guess—it follows explicit configuration.

Layer 3: Derived Output

The /output/ folder contains the deployed site:

output/
├── index.html           # Homepage
├── methodology.html     # How it works
├── proof-points.html    # Evidence
├── how-this-site-works.html  # This page
├── healthcare.html      # [emerald theme]
├── software.html        # [amber theme]
├── retail.html          # [pink theme]
├── education.html       # [indigo theme]
└── styles.css           # Design system

Critical principle: These HTML files are ephemeral. They're regenerated every build. Editing them directly is pointless—the next build overwrites them.

This is the same principle we recommend for enterprise content: never edit derived artifacts; edit the source and regenerate.

The Theme System

Each vertical gets its own accent color, applied via CSS custom properties:

Vertical Body Class Accent
Healthcare theme-healthcare Emerald #10b981
Software theme-software Amber #f59e0b
Retail theme-retail Pink #ec4899
Education theme-education Indigo #6366f1

The CSS defines all theme colors:

.theme-healthcare {
    --color-accent: #10b981;
}

The template applies the body class:

<body class="">

Same content structure, different visual identity. This is audience-appropriate derivation—the architectural principle that lets one source serve multiple presentations.

Trace Any Sentence

Pick any sentence on this site. You can trace it back to source:

Example 1: "Truth fragments when stored in multiple systems"

  • Appears on: Homepage, Methodology, all vertical pages
  • Source: pages/index.md (original), referenced in each vertical
  • Why: Core canonical claim, expressed in context-appropriate ways

Example 2: "Protocol-procedure-practice gap"

  • Appears on: Healthcare page
  • Source: pages/healthcare.md, line ~45
  • Why: Industry-specific term for the fragmentation problem

Example 3: "Content is code"

  • Appears on: Methodology, Book of Fire section
  • Source: pages/methodology.md
  • Why: Technical principle for implementers

The architecture makes tracing trivial: every sentence lives in one markdown file. Find the source, see the context, understand the intent.

Why This Architecture

Problem: Content Drift

Traditional websites have separate HTML files for each page. Over time: - Homepage gets updated, vertical pages don't - Messaging inconsistencies accumulate - Nobody knows which version is correct - Updates require hunting through multiple files

Solution: Single Source

With semantic memory architecture: - Canonical claims live in markdown files - Changes propagate automatically on rebuild - Inconsistency is architecturally impossible - Updates happen in one place

The Recursive Proof

We're demonstrating the methodology by using it.

If this site drifts—if the homepage contradicts the methodology page—we've failed at our own system. The architecture prevents this. That's the proof.

Build It Yourself

The entire system is reproducible:

# Prerequisites
pip install markdown

# Build
cd build
python generate.py

# Preview
cd ../output
python -m http.server 8000
# Open: http://localhost:8000

The generator is ~200 lines of Python. The template is standard HTML with placeholders. The CSS is a straightforward design system.

No proprietary tooling. No complex dependencies. Just markdown → HTML with explicit derivation rules.

What This Proves

Semantic memory systems aren't theoretical. You're reading one.

Canonical claims work. Eight source files generate a coherent multi-page site.

Derivation scales. Adding a new vertical means creating one markdown file and one line of configuration.

Transparency is architectural. The build system is readable. The source files are accessible. Nothing is hidden.

We practice what we preach. The methodology we consult on is the methodology we use.

Apply This To Your Organization

This site is a simple example. The same architecture scales:

  • Healthcare: Clinical protocols in canonical storage, derived to order sets, EHR templates, training materials
  • Software: API specs as source, docs/SDKs/guides as derivations
  • Retail: Product truth in canonical system, derived to channels, locations, contexts
  • Education: Curriculum standards as source, assessments/materials/rubrics as derivations

The pattern is the same: verify upstream, derive downstream, prevent drift architecturally.

Interested in implementing semantic memory for your organization? Let's Talk →