Skip to main content
Experimenting

silan-viking — A Personal Context System

content-systemmcppersonal-knowledgerust

This is the system you are reading on right now. silan-viking is the content
engine behind this website — and writing about it inside it is the whole point.

The idea

Most personal sites separate three things that should not be separate: the
raw thought, the published artifact, and the machine that turns one into
the other. You jot ideas somewhere (notes app, scratch file), you eventually
hand-write a polished post somewhere else (a CMS, a Markdown folder), and a
static-site generator stitches it together. The thinking and the publishing
never share a substrate.

silan-viking collapses that. One content tree, six types — idea, blog,
project, episode, update, resume — all governed by a single schema
contract (SCHEMA.md). Every item is plain Markdown + TOML on disk, so it is
diffable, greppable, and version-controlled. A Rust engine parses that tree,
validates it against the schema, and projects only what is marked
visibility: public onto the live site. Nothing leaks by accident: status
is the lifecycle, visibility is the gate, and they are never merged.

Why it matters to me

I wanted a place where a half-formed spark and a finished essay are the same
kind of object at different lifecycle stages. An idea can carry a status of
hypothesis → experimenting → validating → concluded. A project evolves.
Relations (evolved_into, supersedes, documents) link them so the history
of a thought is a graph, not a folder of dead files. This idea — the one you
are reading — sits at experimenting, because the system is real and running
but the edges are still being sanded.

How it works

  • Authoring happens through an MCP server. An agent can capture a loose
    thought, propose a content change, and recall past context — but it can
    never publish or deploy. Those are owner-only CLI actions. The agent drafts;
    I decide.
  • The engine is a set of Rust crates (silan-viking-content,
    silan-viking-app, silan-viking-cli, silan-viking-mcp). Parse, validate,
    diff, project — all gated by CI.
  • Projection ships the public subset to a Go backend + React frontend, with
    a Docker pipeline proven end-to-end.

Open threads

  • Tag unification across all six content types — partly landed, partly pending.
  • Non-blog detail handlers on the backend.
  • Making the agent-memory namespace (silan://agent/) genuinely useful as a
    long-lived working memory, not just a scratchpad.

The meta-joke I like: this very entry was drafted by an agent through the
propose tool, into the system it describes. The system documenting itself is
the proof that it works.