Claude Cowork as Personal Work OS

Claude Cowork is a desktop agent that reads and writes local files from standing markdown instructions, session after session. The files and the rules decide the quality of that system far more than the model does. Cowork is the judgment layer of a stack, not the whole OS.

What to build

Two philosophies share one architecture. The ambitious build runs overnight jobs, daily digests from mail and calendar, a dashboard, and a short spec before any significant build. Output and autonomy go up. So do setup, memory discipline, and the need for a machine that stays awake. The sustainable build treats Cowork as a reliable co-worker: a three-level hierarchy, a lean instruction file, a short memory file, and low maintenance. That shape is more accessible and less likely to bloat. The difference is how far the automation layer is pushed, not which files exist.

Local or cloud is the choice most guides skip. A local markdown OS keeps instructions and memory in .md files the agent reads at session start — portable, editable, no external dependencies. It lives on one machine and stops when that machine sleeps. Overnight work needs an awake machine or a remote box. A cloud build has a coding agent stand up a web app on a cloud database: always-on, any device, optional voice-to-text into the database. The cost is coding-agent comfort, a database, a design pass, and a security check. Named messengers, hosts, and voice products are recipes, not requirements. Hybrid is common and usually right: local Cowork for knowledge work, a cloud dashboard for data that should stay visible. The two are not mutually exclusive.

Two files run the root. CLAUDE.md is the instruction manual — tone, format, guardrails, routing, pointers — and it loads every session. MEMORY.md is the persistent notepad: active projects, scheduled tasks, stable facts. Product scaffolds may write memory.md or a memory/ folder; the house name on this page is MEMORY.md. Saying “remember this” writes there only if the root file says so.

The hierarchy is constitutional. Root files apply everywhere. A workstation’s files apply only in that area. A project’s files apply only to that initiative. Each level carries the same trio: instructions, memory, resources. The point is relevant context, not folder neatness. The agent performs better when the system surfaces the right amount of context at the right specificity — tokens in the window are a precious resource, owned in depth by Context Engineering.

Rules and memory stay apart. Mixing prescriptive language with changeable facts degrades the workspace.

Always / never / before doing X, do Y → CLAUDE.md. Currently true / happened / may change → MEMORY.md.

A three-folder shape is another legal architecture, not a second manual. ABOUT ME / OUTPUTS / TEMPLATES, with standing instructions in desktop settings that replace a root CLAUDE.md. Those standing instructions: read every ABOUT ME file before every task; never touch OUTPUTS or TEMPLATES unless pointed there; save deliverables under a named OUTPUTS subfolder. Example ABOUT ME files: a short self-portrait, a banned-word list so the agent does not write in the default model voice, a company file updated when priorities change. One practitioner’s self-portrait sat under 2,000 tokens after interview-and-extract; a 1,000-token company file is a house tightening of “keep it short.” Combined ABOUT ME files that bloat burn tokens before any real work starts — 6,000 is not a product threshold. Templates fill from successful outputs: “save this as a template” strips content and keeps the skeleton. No upfront template design is required.

How the machine is fed

Eight layers, each a different job. Folder access. Instructions. Skills. Connectors. Plugins. Scheduled tasks. Projects. Coding-agent handoff. Each exists in the 2026 product. The design question for any task is which layer is the smallest that fits.

Connectors hook mail, calendar, drive, an office suite, chat, notes — availability is plan- and region-dependent. Plugins bundle skills plus connectors for a domain; an official set shipped at launch (eleven, Productivity among them). Point at the current plugin directory rather than a snapshot of which warehouse a finance plugin talks to. The Productivity Plugin is the fastest bootstrap: /start creates a tasks file, a dashboard, memory files, a directory structure, CLAUDE.md, and MEMORY.md. Generated files get audited before they are trusted. Scheduled tasks are a first-party product feature: recurring background execution for a morning brief or a monthly cleanup. The coding agent in the same desktop app is the escalation for complex software work.

Root CLAUDE.md has a practical ceiling of 200–250 lines and a hard maximum of 300. That is this system’s operating rule, not a vendor spec. One practitioner cut 600+ to about 250 and reported a roughly 25% token drop. A strong root holds memory-system rules, communication prefs, guardrails, a routing map, one-line pointers, and a workstation-creation protocol as a pointer, not an embedded section. The governing question: does the agent need this every session, or only when a specific task comes up?

MEMORY.md is a whiteboard. archive.md is a filing cabinet. Memory ceiling: 150 lines. When breached, compress and archive — never raise the ceiling. One practitioner’s root stayed under 100 lines after months; that is a data point, not a limit. archive.md is not read at session start if no root instruction includes it, and loads only when asked about history. Each workstation and project has its own MEMORY.md; root only needs to know a project exists and where. Cascade: root confirms → routing map → workstation memory → project memory.

Token cost is a quality concern, not just a billing one. Extra tokens distract. Every message causes the agent to re-read the entire conversation history — standard chat-API behavior. Prompt-caching changes the price of that reread, not the fact of it. If each exchange is the same size, turn n sends about n times the first turn’s new tokens — 30× at turn 30, not 31×. At about 500 new tokens per exchange, twenty messages burn 105K tokens and thirty burn 232K, as the triangular sum 500 × n(n+1)/2 and assuming no cache. Real sessions also carry system, CLAUDE.md, and memory on every turn, so the share of history is lower and the absolute burn is higher. Cache can make the marginal reread cheap. One anonymous developer tracked 98.5% of tokens on re-reading history and 1.5% on output; that is one no-cache measurement, not a Cowork average.

The instruction still holds for quality: restart, don’t pile. Cut the conversation prefix. Desktop UI may move; the move is cutting the prefix, not a button name. A previous message may not be editable — a product-UI claim, not a law. A fresh session around every twenty messages, with a handoff note pasted as the first message of the new session, is a round number, not a measured cliff. Batch tasks into one message: three prompts are three full reloads; one prompt with three tasks is one.

Match the model to the task. The cheaper, faster model handles grammar, formatting, short answers, and brainstorming — default about 80% of the time. The stronger model is for multi-step interdependent builds and complex judgment, typically when three or more steps depend on each other. Using the strongest model for everything spends 30–70% of the budget on work the cheaper model usually handles well enough. “Equally well” overclaims.

What this is for

Cowork is infrastructure you build, not a tool you use. Because the system is files, every rule, preference, and workstation that survives a session makes the next session better. The mechanism is durable written context, not magic compounding.

The smallest layer that fits is the design rule. A full project for a small skill, a skill when a connector is needed, Cowork when the coding agent is better — those are the same mistake at different scales.

Autonomous building is a queue of approved units, not “let it do everything.” A brief dropped before bed becomes a completed artifact only if a machine stays up and the unit was approved.

Cowork is the judgment layer. Execution sits with a local coding agent. Standing watch sits with a cloud bot. The live split is on Current Agentic LLM Stack. Hybrid — local Cowork for knowledge work, a cloud dashboard for always-visible personal data — is the same split seen from the folder side. Agentic Engineering owns the doctrine this is one implementation of: specs, verification, a human bar.

How a week actually runs

CLAUDE.md is a behavioral contract, not only a routing file. A personal AI OS needs both context architecture (what to know) and conduct architecture (how to act). Without conduct, autonomous Cowork becomes over-eager: extra features, adjacent files, hidden uncertainty, vague requests treated as permission. Four standing principles: Think before acting. Simplicity first. Surgical changes. Goal-driven execution. A public ~60-line conduct file is a cousin of the same list; the number is not frozen. Those four, plus four operating principles pasted before folders or PRDs exist — PRD-first, push back and clarify, aggressive note-taking, reversibility — change the character of the system. Without them the agent builds fast and confidently in the wrong direction.

Before any workflow, dashboard, or automation, write a PRD first. Without one, Cowork can build something plausible but wrong, discovered an hour later. Minimal PRD: the problem, what done looks like, out of scope, the simplest acceptable solution, what cannot be touched, checks that prove complete. Wait for explicit sign-off. Fill the lake before building on it: data layer first, then dashboards, skills, automations. One documented ambitious build took about five hours and produced a live connected system; that clock is a demo, not a constant. The mission-control PRD is written by interviewing on goals, tools, and priorities, then reviewed and approved before anything is built. Scaffold: a folder, a project on that folder, the PRD dropped in, then /start from the Productivity Plugin. Sequence, not a clock: confirm live data from every planned connector before a dashboard; then a dashboard over existing data, a morning brief with explicit urgency tiers (needs a response before a morning cutoff / can wait / informational), and a small set of skills as examples, not a required trio. Notifications and end-to-end testing come last. Following a PRD gets most of the way there; leftover work is permissions and tweaks.

A workstation is a place you work. A skill is a thing you do. A workstation is a durable area of work with its own context, rules, examples, and memory — a place the agent goes to do a kind of work repeatedly, not a folder for one-offs. Universal workstations (email, writing, research) when the workflow cuts across life. Dedicated workstations (personal finance, travel, a newsletter, investing) when the workflow belongs to one domain. Email HQ knows greeting and sign-off, search-before-draft, and that email tone is not the general voice. Newsletter HQ knows audience, voice examples, a drafting workflow, a publishing checklist. Personal Finance knows a category taxonomy, vendor corrections, tax deadlines. The strongest workstations are operating environments holding reusable context the agent would otherwise be retold.

Situation	Home
Ongoing area with its own context	Workstation
Human judgment inside the workflow	Workstation
Same checklist every time	Skill
Creates or updates durable files and memory	Workstation or project

“Work on my next newsletter” is a workstation (decisions). “Generate five scored subject lines from the final draft” is a skill (fixed checklist). Do not create a skill before the workflow has proven itself — one or two real uses, then package. Progression: one-off → refined workflow → skill → scheduled task.

A plugin is a packaged role for a domain — industry knowledge, a process, autonomous runs. The metaphor is not legal personhood and not unsupervised production. The important file is SKILL.md: a description block with trigger phrases and explicit negative boundaries, numbered testable steps, output format, rules, edge cases, a quality checklist before every delivery. Too vague a trigger and the skill never activates; too broad and it hijacks unrelated conversations. Build sequence: research the role, interview, write SKILL.md, supporting files, test on real data with different inputs, update after every miss. The tool does not get better — the instructions do. Without connectors, Cowork operates only on local files. Skills can be invoked explicitly or triggered when the agent recognizes the context. Plugins are a high-leverage entry for domain-specific workflows; that ranking is not measured.

There is a natural ceiling where Cowork’s general capability is not enough. Use Cowork to define the project, architecture, memory, and workflows; switch to the coding agent for programming, complex file manipulation, multi-file code. Both share the same workspace folder, so handoff is pointing the coding agent at the same directory. Cowork for orchestration; the coding agent for execution.

Before asking Cowork to organize a world, teach it what that world is. Point it at a high-signal subset of notes; ask for an About Me digest (values, interests, goals, frameworks, themes, ranked projects, recurring questions); paste into standing personal preferences. Voice principles tell the agent how the user sounds. A dossier tells it what they care about and which distinctions matter. Without the dossier, Cowork acts locally but thinks generically — categories that are technically correct but not this life.

The distinct thinking-partner use case already lives on Knowledge Base as Thinking Partner; this page adds only the Cowork-specific file-write-back. Structured notes are the best context an AI can be given. A well-linked markdown vault — metadata, ranked importance, maps of content, cross-references — gives a navigable model rather than a flat pile, which is why a compiled markdown wiki is the context layer LLM Knowledge Systems argues for. Context architecture beats prompting: well-organized notes outperform any single clever prompt. Applications: a weekly review grounded in actual notes; synthesis that writes a markdown file back into the vault; maps of content that surface unlinked notes. The AI surfaces tensions; resolving them remains human. The markdown KB remains the source of truth; Cowork traverses, synthesizes, writes back.

The most concrete always-on shape is three sessions. Morning briefing, automated: inbox by urgency, routine replies drafted, two or three flagged for judgment, calendar pulled, a prep brief per meeting, one desktop file. One file is read and the day is visible — that is the test, not a guarantee. Midday production, manual trigger: Cowork works on actual files. Task templates specify input source, processing steps, output format, save location. For large jobs the product can spin up sub-agents; reliability is jagged, and parallelism is not a promise. End-of-day wrap-up, automated: sent and received, meetings, files touched, tasks done, still pending. The load-bearing invention is a carry-forward section that appears in tomorrow’s morning brief as priorities.

Weekly refinement is a short Friday pass — fifteen minutes is a ritual, not a measured optimum. Three questions: what did the brief miss; what needed redoing; what recurring task should be automated next.

Autonomous-build folders are a pattern, not a product: pending/ · in_progress/ · done/ · failed/ · logs/. A scheduled task picks up approved PRDs, builds, and moves them. Cadence is one person’s. Guardrails: only approved PRDs enter; ask before destructive actions; failed builds are logged, not silently retried; a verification check before done/. failed/ plus logs mean the queue does not have to be babysat. Local Cowork still stops when the laptop sleeps. A remote box runs 24/7 with API keys and data on that infrastructure, and builds can be triggered from a phone — only what would already be left in a cloud agent belongs there, or it does not move.

Markdown is the source of truth. HTML is the temporary review artifact. Markdown is excellent for durable notes; complex agent work often needs richer review surfaces. HTML artifacts earn their keep for PRDs with diagrams and tradeoffs, dashboards, visual research reports, and custom editors that export JSON, markdown, or prompts. The useful pattern is HTML with an export path — copy as markdown, copy as a diff.

Cowork compounds only if useful discoveries survive the session. End-of-session audit: new preferences; rules for CLAUDE.md; facts for MEMORY.md; old facts to archive; follow-up tasks. Compress; do not dump the conversation. After something goes especially well, ask whether the process should become a skill, a scheduled task, or a project rule. The loop: do work → audit → save reusable lessons → compress old context → next session better.

Claude Projects, as of a mid-2026 desktop, could not have instructions edited programmatically, and AI-generated project memory could not be structured or edited directly — a product-UI limit, re-check before treating as current. Migration map: project instructions → workstation or project CLAUDE.md; project memory → editable MEMORY.md; knowledge files → resources/; a repeated workflow → workstation rules or skills. After migration, tell Cowork the change; it writes the correct file. The routing map gets a new entry. Project transplanting is how old chatbot workflows become compounding local systems.

How it fails, how to start

The same system fails in a short list of ways, each with a fix already on this page.

Failure	What it looks like	Fix
Root bloat	Every new lesson lands in root, even when task-specific	Root is routing and governance, not a warehouse
Memory bloat	An unstructured transcript of old facts	Ceilings, 1–2 sentence entries, per-workstation memory, archive.md
Rule-memory confusion	Prescriptive language in memory, changeable facts in rules	Regular audit against the always/never vs currently-true test
Workstation sprawl	A folder for every passing interest	Start with two or three; add only on recurring need
Capability confusion	A full project for a small skill, a skill when a connector is needed, Cowork when the coding agent is better	Smallest layer that fits
Skill misuse	Judgment-heavy workflows packaged as skills, or small checklists turned into workstations	Place-I-work vs thing-I-do
Autonomous drift	Builds without alignment, review, or logging	PRD-first, sign-off, queue states, dashboard
Agentic overreach	A local request treated as permission to improve the surrounding system	Every changed line traces to the request or an approved PRD; adjacent cleanup is a recommendation, never silent
Hidden ambiguity	The agent silently picks an interpretation	Name the ambiguity, state the assumption, ask when the wrong choice is costly
Generic personalization	Categories that are technically correct but not this life	Dossier and high-signal resource files
Unreadable plans	Dense specs that cannot be reviewed	HTML artifacts for dense specs

Start with the root, one universal workstation, and one dedicated workstation. Grow from repeated friction. An example tree — not the required tree — is root CLAUDE.md / MEMORY.md / archive.md / 00_resources/ (voice principles, about-me dossier, memory-system rules, workstation-creation protocol as a pointer); one Email HQ; one Writing HQ; a Mission Control dashboard over queues, briefs, and builds; a small skills folder once a workflow has proven itself. The order that matters: autonomy last. Conduct rules and a PRD sit before folders; a proven skill sits before a scheduled task; an approved queue sits after both.

Unsupervised autonomy becomes another context switch; Attention Management is the cost the daily rhythm has to pay. Running Cowork well is knowing when to stay in the loop and when to let it run — Metacognition. The Right vs Wrong Way to Work With AI is the sibling on not outsourcing the thinking the files are supposed to hold.

The case against. Local Cowork dies when the machine sleeps. Autonomy without a PRD queue is drift. A remote box with mail and keys is a real security move, not a convenience toggle. The page mixes product (scheduled tasks, plugins, skills, connectors) with recipes (pending/ queues, Friday rituals, voice-into-a-database). Treating recipes as product waits for a /start that builds someone else’s life.

The price. Setup hours, then a short weekly refinement. Token quality cost remains even when cache kills the bill panic. A bloated root past 300 lines stops routing and starts warehousing.

Quit signal. Two weeks of unsupervised autonomy that produce plausible-wrong artifacts, or a root file past 300 lines that no longer routes. Next move: cut autonomy back to an approved queue, compress root to routing, and stay in the loop until the morning file can be acted on without reopening mail.

Checkable. A morning file that can be acted on without reopening mail. A session-audit that changed a file.

The next session is better because the files got better. Overnight work still needs a machine that stays up. Cowork remains one layer.

Related

• Attention Management — unsupervised autonomy becomes another context switch; the daily rhythm has to pay that cost
• Knowledge Base as Thinking Partner — the thinking-companion use case already lives there; this page adds only the Cowork file-write-back
• Metacognition — the in-the-loop versus let-it-run judgment
• Agentic Engineering — doctrine: specs, verification, a human bar. Cowork is one implementation
• Current Agentic LLM Stack — live split: Cowork = judgment, coding agent = execution, cloud bot = standing
• LLM Knowledge Systems — why a compiled markdown wiki is the context layer agents should read
• Context Engineering — owns right context at the right specificity at greater depth
• Essential AI Skills 2026 — local-agent rung on the ladder; Cowork is the worked example
• The Right vs Wrong Way to Work With AI — conduct / don’t-outsource-the-thinking sibling
• Vibe Coding — Cowork-as-OS is not vibe-coding a life

Open Questions

• The right balance of autonomy versus oversight, and how that balance shifts as the system matures.
• Memory architecture as projects accumulate — structural limits of the cascade. One root staying under 100 lines is a data point, not a limit.
• Whether heavy Cowork use reinforces or erodes independent judgment and taste. The live stack page is where this is being lived.
• When a Cowork-style system starts competing with a traditional second brain, and whether that is a problem.
• Whether conduct architecture should become a standalone concept page across agentic systems. The four principles already live in this vault’s Cowork contract and on Agentic Engineering.
• Whether the personal context dossier should become standard onboarding for any agentic system.

Sources

• My Full Claude Cowork Setup. Tina Huang. Ambitious overnight build, daily digest, dashboard, PRD-first.
• My Simple Claude Cowork System (for normal people). Jeff Su. Three-level hierarchy, lean files, sustainable co-worker.
• Top 5 Claude Cowork Tips I Wish I Knew from Day One. Jeff Su. 300-line root, 150-line memory, whiteboard / filing cabinet, workstation vs skill.
• Give Me 20 Minutes. I’ll Teach You 80% of Claude Cowork. Nick Milo. Dossier from a high-signal note subset; thinking companion against a linked vault.
• Claude Cowork Fundamentals In 22 Minutes. Tina Huang. Product surface: folders, skills, connectors, plugins.
• A public ~60-line conduct file. Third-party mirror of lean guardrails (think before acting; simplicity; surgical changes; goal-driven execution). Not a first-party canonical file.
• Local vs cloud personal OS. Miles Deutscher. Cloud dashboard pattern; recipes, not a required stack.
• April 2026 Cowork update. Ruben Hassid. History reread, triangular token burn, restart / batch / match-the-model, three-folder ABOUT ME shape.
• Automating the workflow. Plugin and automation pattern.
• Building a Cowork plugin. Packaged role, SKILL.md as the load-bearing file.
• The unreasonable effectiveness of HTML. HTML as a review surface with an export path back to markdown.