Architecture / Operating Model

How SharePlane Works

Context as code for humans and agents.

SharePlane is built around a simple belief: the durable product is not the chat session. It is the governed context that survives the session, tells every participant what matters, and makes the result reproducible after the model, tool, or operator changes.

RAG helps an agent find documents. Context as code helps a system know what those documents mean, which authority governs, what action is permitted, how work moves, what must be validated, and where human judgment remains mandatory.

• Static-first
• Human-governed
• Agent-assisted
• Versioned authority
• Deterministic build
• Receipt-backed
• Portable pattern

Executive scan

Finds relevant material

Retrieval can surface useful documents and passages. It does not decide which source governs or what the system may do next.

Defines what controls

Versioned source, locked decisions, metadata, schemas, and public-safe boundaries establish the authority the system must follow.

Moves work deliberately

Explicit stages separate rough intent, source intake, human judgment, implementation, validation, rendered review, and publication.

Checks deterministic rules

Validators can prove structure, hashes, links, contracts, and generated consistency. They cannot prove truth, taste, or wisdom.

Remains human

Humans own thesis, disclosure, source posture, design selection, acceptance, and accountability. Agents increase leverage without inheriting those decisions.

1. A pile of documents is not an operating model

A folder full of useful material can still be a terrible system.

The documents may conflict. One may be current and another obsolete. A polished summary may outrank the decision record that actually governs. A model may retrieve the right paragraph and still have no idea whether it is permitted to act on it. A new operator may inherit the files without inheriting the reasoning that made them coherent.

This is the gap between information and operations.

Information answers questions such as: What material exists? What does this document say? Which passage looks relevant?

Operations must answer harder questions: Which authority controls? What is public? What is prohibited? What step comes next? Who may change the files? What must be validated? Who approves the result? What evidence survives after publication?

A search layer can help with the first group. It does not automatically create the second.

2. RAG is useful. It is not governance.

Retrieval-augmented generation is a useful pattern. It can search an indexed body of material, retrieve relevant passages, and give a model better evidence for a response. SharePlane does not argue against that capability.

It argues against assigning retrieval a job it does not perform.

Retrieval does not establish authority merely by returning a result. It does not transform a policy into an executable routine. It does not define access rights, approval gates, validation rules, publication state, or the difference between a canonical source and a convenience copy.

It also does not train the model merely because files were uploaded. The model is receiving selected context at inference time. That can improve an answer. It does not create a durable operating memory by itself.

RAG helps an agent find documents. Context as code helps a system know what those documents mean, which authority governs, what action is permitted, how work moves, what must be validated, and where human judgment remains mandatory.

The distinction is not RAG versus context as code. Retrieval can be one component inside a governed context system. The mistake is confusing a component with the operating model around it.

3. What context as code means here

In SharePlane, context as code means treating the material that shapes system behavior as versioned, reviewable, testable system components rather than loose chat history or undocumented convention.

That material includes:

• authority files
• approved public copy
• source pins
• canonical artifact pages
• structured metadata
• claim and caveat posture
• schemas
• implementation boundaries
• role definitions
• validation rules
• receipts
• manifests
• publication gates
• learning records
• stop conditions

The phrase does not mean that every human idea must become software code. It means the operating context is represented explicitly enough that people and tools can inspect it, review it, change it deliberately, and detect when outputs drift from it.

A conversation can start the work. It should not be the only place the work knows what it is.

4. The authority stack

SharePlane separates authority from projection.

At the top is human judgment: intent, thesis, disclosure, source posture, design choice, and approval.

Below that sits versioned authority: canonical page source, structured artifact metadata, public-safe boundaries, schemas, configuration, and locked implementation instructions.

The build system reads those authorities and produces public projections: the human page, catalog entries, topic and author views, graph data, discovery files, context projections, receipts, manifests, and agent packages.

Those projections are useful. They are not equal authorities.

A generated context file helps an agent ingest the artifact. A ZIP package makes the public material portable. A catalog helps discovery. None of them replaces the versioned source from which they were generated.

This distinction prevents convenience copies from quietly becoming competing truths.

5. Who owns what

SharePlane works because responsibility is divided on purpose.

Tony owns the public decision. That includes intent, thesis, source authority, claim posture, personal disclosure, public-safe boundaries, design acceptance, rendered UAT, and merge authorization.

ChatGPT acts as interpreter and architect. It helps turn fragments into a coherent thesis, performs research and source comparison, writes and locks public copy, defines design intent, formulates bounded implementation tickets, and translates review findings into precise corrections.

Codex acts as mechanical implementer. It reads the repository authority, edits only scoped files, regenerates projections, runs validators, records receipts, and opens draft pull requests. It does not own the thesis, rewrite locked copy, decide what should be disclosed, or promote implementation convenience into public doctrine.

Validators act as deterministic referees. They can reject missing files, malformed metadata, changed hashes, broken links, unknown copy, invalid relationships, package drift, and other explicit failures.

The pull request and exact-head preview act as the review surface. They expose the proposed state before it becomes the accepted state.

The names of the tools can change. The role boundaries are the portable pattern.

Current implementation and portable roles

Render a two-column comparison.

Current SharePlane implementation

• Tony Malott
• ChatGPT
• Codex
• GitHub
• Python standard-library compiler
• generic validators
• Cloudflare exact-head previews
• static public site

Portable operating roles

• Owner / Judge
• Interpreter / Architect
• Executor / Implementer
• Validator / Verifier
• Versioned authority
• Review surface
• Publication gate
• Durable public projection

Add this caption:

The products will change. The control boundaries should not have to be rediscovered every time.

6. How work moves through the system

SharePlane does not move directly from interesting thought to public page.

The normal lifecycle is:

intent → source or candidate → Creative Lock → implementation ticket → branch → draft PR → deterministic validation → rendered UAT → exact-head merge → receipt and learning

Intent starts the work. It can be a rough idea, source, critique, diagram, operating observation, or transcript. Intent is not implementation authority.

Source and candidate work makes the material inspectable. It identifies what informed the work, what remains uncertain, what is public-safe, and whether the idea is ready to advance.

Creative Lock is where human judgment freezes the public thesis, copy, claim posture, source boundary, design direction, and acceptance criteria.

The implementation ticket converts that locked package into bounded repository work. It tells the executor what may change, what must remain untouched, what validators must pass, and when to stop rather than improvise.

The branch and draft pull request isolate the proposed change. Validators test deterministic rules. The rendered exact-head preview shows the page that would actually be merged.

Human UAT can reject work that passed every validator. That is not a contradiction. It is the point of preserving a human judgment gate.

Only the reviewed exact head is eligible to merge.

7. One change, many synchronized surfaces

The system earns its keep when one authoritative change can update many dependent surfaces without requiring a human to edit each one manually.

An artifact record can drive its catalog card, topic pages, author page, graph relationships, structured metadata, context projection, public receipt, manifest, and agent package.

A footer change can be made once in the shared generator and rebuilt across every public route.

A canonical-base change can flow into canonical links, discovery files, context files, manifests, receipts, and other generated references.

The compiler performs the repetition. Validators check that the repetition remained coherent. The operator reviews the resulting change as one governed unit.

This is not magical synchronization. It is explicit dependency represented in code.

8. Deterministic where trust matters. Probabilistic where beauty belongs.

SharePlane deliberately uses different kinds of computation for different jobs.

Facts, IDs, dates, routes, schemas, relationships, hashes, package membership, receipts, and publication state should not drift because a model found a more lyrical arrangement. Those belong to explicit authority, deterministic generation, and mechanical validation.

Thesis development, research assistance, writing exploration, design exploration, metaphor, composition, and alternative explanations benefit from probability. A generative system can search a much wider field of possible forms than a rigid template.

That freedom belongs before acceptance.

Human judgment chooses the argument and the form. Creative Lock freezes the choice. Deterministic implementation preserves it.

Probability explores. Judgment decides. Determinism preserves.

9. Retrieval, context engineering, and context as code

These ideas overlap, but they are not identical.

Documents

Documents preserve information. They may still conflict, become stale, omit authority, or depend on knowledge that never made it into the file.

Retrieval

Retrieval finds material likely to be relevant to the current query. It improves access to a body of information. It does not, by itself, define system authority or permission.

Context engineering

Context engineering curates the instructions, tools, external data, history, and other information supplied to a model for a specific inference or workflow. It is concerned with giving the model the smallest useful set of high-signal context for the task.

Context as code

Context as code is the durable operating discipline around that runtime context. It versions what governs, encodes role and workflow boundaries, defines publication and validation rules, preserves decisions, and generates the projections that people and agents consume.

Context engineering asks: What should the model see now?

Context as code also asks: Who decided that? Where is the authority? What may the system do? What must happen next? What proves the change was reviewed? What survives after this session ends?

In this artifact, context as code is Tony Malott's architectural framing for that broader durable operating pattern. It is not presented as a universal industry standard or the only valid architecture.

10. Experienced-operator leverage

The architecture increases leverage by reducing re-explanation, manual synchronization, accidental authorship, and coordination loss.

A skilled operator can direct more parallel work when the system already knows the role boundaries, source posture, implementation rules, validation gates, and publication process.

The operator is not doing every mechanical action personally. The operator is controlling what the actions mean, which authorities govern, and what result is acceptable.

Agents can inspect repositories, apply bounded edits, regenerate outputs, test deterministic rules, and prepare review evidence. Those capabilities compress repetitive work that would otherwise require many handoffs and a great deal of memory reconstruction.

The defensible claim is not that one person replaces an entire organization.

The defensible claim is that a disciplined operator can govern substantially more work when authority, process, and validation are explicit, versioned, and reusable.

The leverage comes from preserving judgment for the human and assigning repeatable implementation, projection, and verification work to tools.

Specialized expertise remains specialized expertise. Security, privacy, legal review, quality judgment, scientific truth, production operations, and public accountability do not disappear because the workflow became efficient.

11. What this architecture does not solve

Context as code does not make bad sources correct.

It does not prevent an owner from making a poor decision.

It does not turn a validator into a truth machine. Validators prove the rules they were written to prove.

It does not make every model reliable. Missing boundaries still invite hallucination and drift.

It does not eliminate maintenance. Stale authority becomes governed stale authority, which is more inspectable but still stale.

It does not reward stuffing every available token into context. More material can reduce focus. Good context remains curated context.

It does not justify agentic complexity for simple work. Search, a clear document, or a small deterministic script may be the better answer.

It does not replace the runtime architecture required for a production agent that handles identity, live data, memory, permissions, security, and operational state.

SharePlane is a publishing and operating-model demonstration. It is not a claim that every problem belongs in a static site or repository.

12. The reusable pattern

The pattern generalizes where work must remain coherent across time, tools, people, and generated surfaces.

Potential applications include:

• governed publishing systems
• architecture repositories
• policy and procedure systems
• regulated documentation
• AI-assisted product development
• professional evidence sites
• public research and teaching libraries
• design systems with human approval gates
• operational playbooks
• reusable agent workflows

The exact folders, models, hosts, and tools can change.

The reusable questions remain:

• What is authoritative?
• What is public?
• Who owns meaning?
• Who may change files?
• What may an agent do?
• What must be validated?
• Where does human approval occur?
• What evidence survives the change?

Use the simplest system that can answer those questions honestly.

13. Closing

The model can change. The agent can change. The host can change. The interface can change.

The durable advantage is the governed context that tells all of them what the work is, how it moves, and where human responsibility begins.

Closing line

The agent is not the system. The governed context is what makes the system coherent.