Why this site is strange

This site is a little strange on purpose.

It is a personal site in the ordinary sense: a public home for work, writing, contact, and current movement. But that is not the whole object. It is also an experiment in a newer pattern: making a public artifact that can be read by people and operated against by language models working on their behalf.

That does not mean treating LLMs as independent actors with their own purposes. The useful frame is more grounded than that. LLMs are increasingly delegated operators: systems people use to read, compare, summarize, route, draft, test, and move work across contexts. They do not need a mystical theory of agency to matter. They already change the shape of what a useful interface can be.

Most of the internet was designed for human attention. Pages assume eyes, scrolling, navigation, visual hierarchy, persuasion, forms, and clicks. That is still real. But models use the web differently. They work from documents, schemas, examples, logs, file structures, instructions, and routes. They can read a page, but they can also use a plain-text corpus, inspect a manifest, follow a protocol, compare claims against records, and carry structured context into the next action.

That makes a website something more interesting than a brochure.

From content to capability

The immediate purpose of this site is simple: help people and the LLMs working for them determine whether there is a reason to connect, and make useful public material easy to collect when there is not.

But the deeper experiment is about capability. Some model-facing artifacts are not merely content, prompts, or documentation. They are scaffolds: external structures that let a model exercise a capability more reliably than it could from a bare prompt.

The model supplies flexible interpretation, synthesis, and adaptation. The scaffold supplies names, boundaries, procedures, checks, memory, and records. Neither side is sufficient by itself. The capability appears in the coupling between them.

That is the pattern I am interested in:

latent model capability + external scaffold + validation loop = usable operational capability

The scaffold does not replace the model. It also does not merely tell the model what to do. It gives the model a structured world to work inside: objects it can name, paths it can follow, constraints it must respect, and records that make the work inspectable after the fact.

Better metrics, or new functions

Much of the current conversation about LLMs is about doing familiar work faster: more copy, quicker summaries, cheaper analysis, faster code, better support throughput. That category matters. Better metrics on existing functions are real.

But it is not the whole opportunity.

The more interesting category is work that could not be done, or could not be done at useful scale, without LLMs. Not because the task was impossible in principle, but because it required too much context transfer, too much translation between domains, too much conversational narrowing, or too much custom integration for each situation.

Discovery is one of the places this becomes visible.

Individuals, organizations, projects, systems, funders, customers, collaborators, and tools often fail to find each other even when there is strong latent fit. The public internet made people and organizations searchable, but search is still a thin instrument. It retrieves pages. It does not always understand situations, infer fit, compare needs to capabilities, prepare context, or lower the cost of a first useful exchange.

LLMs change that surface. A person can delegate exploration. A model can read across public artifacts, assemble context, test possible fit, prepare an introduction, and carry forward the relevant state. That does not make the model the source of judgment. It does make new interaction patterns possible.

This is the architecture I am probing:

• humans with real situations, constraints, needs, and judgment;
• LLMs acting as delegated operators across documents and systems;
• public artifacts structured for models to fetch, inspect, and use;
• durable records that make the interaction accountable after the fact.

The site is an early version of a tool for that architecture. It is trying to be legible as a human profile, a machine-readable corpus, a capability manifest, an audit trail, and a routing surface at the same time.

That combination points toward a larger unlock: enhanced search, discovery, onboarding, integration, and collaboration. Not merely “find a page,” but “find whether there is a reason to connect, what each side should know before connecting, what can be reused without connecting, and what useful action should happen next.”

If that works, the website is not just a destination. It is part of the coordination layer.

What the site already does

This site is a modest instance of that pattern.

The source of truth is a git repository. Content lives in typed collections. Pages are generated from source files. Writing, work, and daily log entries have plain-Markdown mirrors. /llms.txt indexes the site for language models. /llms-full.txt exposes the writing corpus as a single plain-text document. /capabilities.txt and /capabilities.json describe the current public capability surface. The Done log records recent movement, so the site is not only making claims about itself; it is leaving receipts.

None of that is advanced software in the usual sense. That is part of the point. The first useful version of this pattern does not need a complex runtime. It needs durable public structure.

A model can fetch the corpus, inspect the capability manifest, read the work history, check the recent log, and prepare a more specific introduction than a human would usually write from a cold browse. It can also decide there is no fit and still extract language, distinctions, or examples that are useful elsewhere.

That is already a different interface pattern from “look at my homepage.”

Operationalizing functional delegation

The phrase I keep circling is functional delegation.

Not delegation as vague automation. Not delegation as pretending the model owns the goal. Functional delegation means a person can hand a model a real task and a structured environment in which the task can be performed with less ambiguity, more continuity, and better evidence.

That environment might include:

• a knowledge substrate;
• an operational grammar;
• typed objects or states;
• routing rules;
• constraints and gates;
• examples of acceptable work;
• tests or checks;
• durable witness records;
• a lifecycle for revision.

In ordinary software, many of those things are hidden inside code. In LLM-facing work, many of them can be expressed directly as text, files, directories, schemas, and generated public artifacts. That is strange only because the web trained us to think of sites primarily as things people look at. For delegated model work, a site can also be a thing a model uses.

The important question is not whether the page looks interactive. The important question is whether the structure enables better action.

Can a model understand what the artifact is for? Can it find the current capabilities? Can it distinguish stable claims from provisional notes? Can it retrieve source-like text instead of scraping presentation? Can it route a situation toward contact, reuse, or dismissal? Can a person inspect what the model relied on afterward?

Those are interface questions. They are also governance questions.

Why public matters

There is a private version of this pattern: local folders, working notes, prompts, scripts, logs, and tools used with a model in a private environment. That is useful. But public structure changes the affordance.

When the scaffold is public, it becomes addressable. A person can send a model to it. Another model can fetch it. A future system can compare against it. The artifact can be linked, cached, tested, versioned, and criticized. It can become part of a wider network of delegated work without requiring a private handoff first.

That does not make every public artifact important. Most will not be. The point is narrower: if LLMs increasingly work through documents and structures, then public documents and structures can become operational surfaces, not just publication surfaces.

The website is the visible edge. The repository is the canonical object. The generated artifacts are the machine-facing surface. The human pages are still real, but they are no longer the only interface.

The constraint

The constraint is utility.

It would be easy to make this grander than it deserves to be. A capability surface that does not help anyone do anything is just decorative machinery. The site has to earn its strangeness by making connection, evaluation, reuse, or learning easier than it would otherwise be.

So the current version is intentionally small. It exposes a few routes. It makes the corpus fetchable. It names the capability surface. It keeps a log. It lets the structure evolve under version control.

That is enough to begin.

The direction is broader: public configurations, reusable procedures, evaluation rubrics, promptable workflows, task routers, research packets, and small web-addressable artifacts that help models do useful work without a person reconstructing the method from scratch every time.

Some of those will turn out to be valuable. Some will not. The site is a place to find out in public.

Why this site is strange

This site is strange because it is not only a representation of work. It is part of the work.

It is an output of AI-assisted building, writing, and revision. It is also an evolving instantiation of the pattern being explored: external structure that makes delegated model work more reliable, inspectable, and useful.

That may become a dead end. It may become ordinary. It may become one small instance of a much larger design pattern that eventually gets better names.

For now, the claim is simpler:

A website can be built for human readers and delegated model operators at the same time. It can publish ideas, but it can also publish structure. And when the structure is useful enough, the site stops being only a place where work is described.

It becomes one of the places where work can happen.