Human Scale

Fresh

A philosophy manifesto on why semantic systems drift toward complexity, and how MD-LD enables human-readable, deterministic, locally-inspectable computation. Addresses preservation, long-term comprehensibility, and operational sustainability.

The Complexity Drift Problem

Software systems have a consistent tendency: they begin simple and drift toward complexity. This drift is not accidental — it is the result of accumulated features, edge-case handling, integration requirements, and the natural expansion of scope over time.

Semantic systems in particular suffer from this drift because they are, by definition, about everything. A knowledge graph that starts as "people and their relationships" grows to include organizations, events, time periods, locations, roles, activities, documents, and eventually every concept in the domain. The schema grows. The query complexity grows. The infrastructure required to run the system grows.

The problem is not the growth itself — knowledge naturally expands. The problem is that most semantic systems require substantial infrastructure to be legible. You cannot inspect a triple store with a text editor. You cannot read a SPARQL endpoint. You cannot understand a graph database by looking at its files.

When the infrastructure is what makes the knowledge legible, the knowledge is only as accessible as the infrastructure is available.

Human Scale as a Design Constraint

"Human scale" means: a system that a competent person can understand, inspect, and maintain without specialized tools beyond a text editor and a web browser.

Human-scale software:

• Can be read by the person who wrote it six months later
• Can be inspected by a colleague without a tutorial
• Can be debugged without a dedicated observability stack
• Can be migrated without a migration framework
• Can be archived without a database engine

Most semantic web tooling fails this test. Turtle can be read, but only if you know Turtle. JSON-LD can be read, but only if you understand JSON-LD compaction and expansion. A triple store can be queried, but only if the store is running.

MD-LD is human-scale because it uses plain text as the storage format, Markdown as the authoring convention, and produces standard RDF that integrates with the existing semantic web ecosystem without requiring that ecosystem to be present for the text to be legible.

Preservation and Long-Term Comprehensibility

Knowledge has a different time horizon than software. A contact record might be read twenty years after it was written. A research dataset might be cited thirty years after publication. A policy document might be audited fifty years after it was created.

Plain text has demonstrated survival over decades. Files written in the 1970s in ASCII are still readable today. Files written in proprietary formats from the 1990s are often inaccessible without emulation.

By anchoring knowledge in plain text with Markdown formatting, MD-LD inherits the survival properties of plain text. The semantic annotations add machine-parseable structure without sacrificing the readability that enables long-term preservation.

This is not just a theoretical argument. The practical question for any knowledge base is: "If the software is unavailable in ten years, can the knowledge still be read?" For MD-LD: yes, with any text editor. For a triple store: only if someone reinstalls the database software and migrates the schema.

Locally-Inspectable Computation

"Locally-inspectable" means: you can look at what the system knows and what the system is doing without network access, without authentication, and without a special interface.

In practice, this means:

• Knowledge lives in files on disk
• Files are readable text
• The computation happens in memory as a JavaScript array
• No service needs to be running to inspect the state
• No credentials are required to read the data

This is qualitatively different from cloud-hosted knowledge bases, API-dependent systems, or encrypted databases. You can take a folder of MD-LD files to an airplane, open them in any text editor, and still read the full knowledge base. The semantic structure is embedded in the text.

Operational Sustainability

Human-scale systems are operationally sustainable because they reduce the cost of maintenance. The cost of maintaining a system has several components:

• Infrastructure cost — servers, databases, storage
• Operational complexity — configuration, monitoring, upgrades
• Knowledge transfer — onboarding new team members
• Documentation — explaining how the system works

MD-LD minimizes all four:

• Infrastructure: a folder of text files, a JavaScript runtime
• Operational complexity: no database to configure, no schema to migrate
• Knowledge transfer: the files are readable, the format is documented
• Documentation: the documents themselves are the documentation

The Spectrum of Scale

MD-LD is not a replacement for enterprise knowledge graph infrastructure. It occupies a specific position on the spectrum:

Use Case	Appropriate Tool
Personal knowledge base (under 10K quads)	MD-LD + plain files
Team knowledge base (10K to 1M quads)	MD-LD + git + n3.js
Enterprise graph database (over 1M quads)	Apache Jena, Stardog, or similar
Real-time collaborative knowledge (millisecond latency required)	Dedicated graph database

MD-LD is designed for the first two categories — the vast majority of real-world knowledge management needs. For cases that genuinely require enterprise infrastructure, MD-LD's RDF/JS output integrates directly with any standard triple store.

Determinism as a Feature

One of MD-LD's design constraints is that the same input always produces the same output. This is not just a correctness guarantee — it is a human-scale feature.

When a system is deterministic:

• You can understand its behavior by reading the specification
• You can reproduce results without access to the original environment
• You can verify your understanding by running the parse
• You can trust that the knowledge is stable across time and tooling changes

Non-determinism (implicit semantics, inference, heuristic processing) makes a system more powerful in some dimensions but less inspectable. MD-LD explicitly trades inference power for inspectability — every triple in the output can be traced to an annotation in the source text, and there are no "surprise" triples added by the parser.

This is a deliberate constraint that keeps MD-LD in the human-scale category. If you want inference, use a reasoning engine on top of the quads. The base layer stays explicit and inspectable.