My AI Operating System
A shared workspace for AI-assisted work. Context lives in files, agents work across tools, and I keep direction and final approval.
- Year
- 2026
- Role
- Designer · orchestrator · system owner
- Status
- Ongoing
The consolidated workflow vault. Colour groups distinguish workspace context, tasks, durable knowledge and projects. See the earlier graph
Context that survives the conversation
Every new conversation needed the same explanation. I wanted the next session to start with the context already in place.
I built a shared workspace around ordinary files: instructions set the boundaries, a registry routes work to each project, and a sourced wiki holds durable facts and decisions. Tasks preserve the next step; reusable skills capture recurring procedures.
Agents inspect the project, plan, implement and verify the result in its actual interface. I set the direction and accept the final work. The system is ongoing: each project reveals another gap to address.
How the pieces connect
- 01 · DirectionBill sets the goal and boundaries
Taste, constraints, approval boundaries, and the final word stay human.
- 02 · CoordinatePortable context routes the work
Shared instructions, confirmed user context, the project registry, and the sourced wiki.
- 03 · GroundAgents work from real evidence
Project files, Git state, durable memory, tasks, and reusable skills each keep one clear job.
- 04 · Close the loopInspect → plan → build → verify
Verified outputs ship; durable decisions return to memory so the next session starts further ahead.
The decisions
Files over chat memory
Chat context is temporary. Portable Markdown gives every file-aware agent the same confirmed context without depending on one model or one conversation.
Separate current truth from durable synthesis
Repositories own current implementation state. The wiki stores sourced facts, decisions, relationships, and uncertainty instead of becoming a stale copy of the codebase.
Human direction at consequential boundaries
Agents can inspect, plan, build, and verify autonomously, but Bill retains the final call on intent, external communication, destructive actions, and meaningful scope changes.
Verification is part of generation
A plausible diff is not a finished result. The workflow requires builds, diagnostics, responsive checks, and real-interface QA in proportion to the risk.
Tool-agnostic coordination
The core contract says “the agent” and stores context in ordinary files, so the system can move between Codex, Claude Code, and future file-aware tools.
Making the workspace readable
The earlier graph mixed workflow notes with repository and dependency files. Filtering those files and grouping the core notes made the workspace easier to navigate.
The hard part
Every new session started from zero
SymptomThe same project history, preferences, and decisions had to be explained repeatedly.
CauseImportant context lived in chat history rather than a portable, discoverable layer.
FixCreated shared entry instructions, a project registry, confirmed user context, and a sourced workspace wiki.
LessonMemory is infrastructure only when it is portable, scoped, and backed by evidence.
Memory risked becoming a second source of truth
SymptomSummaries could lag behind fast-moving code and uncommitted work.
CauseVolatile implementation detail and durable knowledge were being treated as the same kind of information.
FixMade project files authoritative for current behavior and limited durable memory to synthesis, provenance, relationships, and visible uncertainty.
LessonGood memory preserves meaning without pretending to replace the system it describes.
Fast output could look finished before it worked
SymptomA generated change could read well in a diff while failing in the actual interface or at a responsive breakpoint.
CauseThe loop ended at implementation instead of evidence.
FixAdded proportional build checks, browser-based UI inspection, screenshots, and concrete before-and-after measurements.
LessonThe last mile of AI-assisted work is not generation. It is verification.
More autonomy increased the cost of unclear boundaries
SymptomA helpful agent could drift into unrelated cleanup or consequential external actions.
CauseInitiative was defined without equally explicit scope and approval rules.
FixSeparated safe inspection and normal implementation from actions that require Bill's confirmation.
LessonUseful autonomy comes from clear boundaries, not constant supervision.
Build fragments
Workspace routing contract
# Start here
1. Read the shared operating rules.
2. Load confirmed user context only when relevant.
3. Route through the project registry before touching a repo.
4. Treat project files and Git state as current truth.
5. Use the sourced wiki for durable facts and decisions.A small entry contract keeps different agents and tools grounded in the same workspace model.
Definition of done
INSPECT the real system
→ PLAN against explicit constraints
→ IMPLEMENT the smallest complete change
→ VERIFY builds, behavior, and the real UI
→ CAPTURE only durable, sourced knowledge
→ HAND OFF with evidence and a clear next actionGeneration is only the middle of the loop; verification and continuation state make the work dependable.
Results and limits
Outcomes
- One portable coordination layer routes work across the connected projects
- Reusable workspace skills turn recurring procedures into consistent, reviewable workflows
- Durable memory carries sourced facts and decisions across tools without replacing project truth
- Task state, project context, and handoffs survive beyond a single chat session
- Implementation work closes with evidence from builds, diagnostics, and real-interface testing
- The system remains intentionally open-ended: each project can improve the workflow for the next one
Guardrails
- Secrets, credentials, and sensitive account data are explicitly excluded from durable memory
- External communication and consequential side effects require human approval
- Project files and Git state remain authoritative over generated summaries
- Uncertainty is labeled instead of silently converted into fact
- Reads follow the narrowest relevant links rather than loading the entire workspace
- Existing user changes are preserved and unrelated dirty work stays out of scope