--- # System prepended metadata title: cowork-plus-obsidian --- # Using Obsidian as a Local Knowledge Base for Claude Cowork > Working draft. This guide restructures the pasted source material into a clearer, more durable how-to document. It assumes the user wants a practical setup guide rather than a marketing-style newsletter. ## Purpose This guide explains how to use **Obsidian** as a readable, editable front end for a folder-based Claude Cowork workflow. The core idea is simple: * Claude Cowork works from a local folder. * That folder can contain persistent instructions, style guides, templates, and prior outputs. * Obsidian can open the same folder as a vault. * Obsidian makes the folder easier to browse, search, read, and edit. * Claude Cowork uses the folder as durable working context. In this model, **the files become the prompt**. Instead of repeatedly typing long instructions into each new chat, you maintain a structured set of markdown files that Claude can read across sessions. ## Audience This guide is for people who use Claude regularly and want more consistent, context-aware outputs without rewriting the same instructions each time. It is especially useful for people who repeatedly create: * newsletters * LinkedIn posts * reports * briefs * meeting notes * presentations * client deliverables * templates * recurring writing or analysis tasks It is also intended for people who are not developers and do not want to manage markdown files through a code editor. ## Core Concept Most disappointing AI outputs are not caused by a single bad prompt. They usually come from missing context. A weak prompt often leaves out: * who the writer is * who the audience is * what tone is appropriate * what examples to imitate * what mistakes to avoid * what constraints matter * what the final output should look like Typing all of that into every prompt is inefficient. Projects improve the situation by letting you reuse context, but they can still become fragmented if each topic or deliverable gets its own isolated project. A folder-based workflow solves a different problem: it lets you maintain a durable, editable, reusable working context. ## The Basic Architecture ```text Claude Cowork folder ├── about-me/ │ ├── about-me.md │ ├── anti-ai-writing-style.md │ └── my-company.md ├── claude-output/ ├── templates/ └── skills/ ``` ### What Each Folder Does | Folder | Purpose | Edited by | | ---------------- | --------------------------------------------------------------------------------------- | --------------------------- | | `about-me/` | Persistent context about the user, their style, preferences, goals, audience, and rules | You | | `claude-output/` | Work generated by Claude | Claude, then optionally you | | `templates/` | Reusable examples, formats, and preferred structures | You | | `skills/` | Repeatable workflows for specific tasks | You and Claude | ## Why Obsidian Helps Claude Cowork can read and write local files, but managing those files directly can be frustrating for non-developers. Markdown files may look strange when opened in basic text editors. They include syntax such as: ```md # Headings **bold text** - bullets [links](https://example.com) ``` For people unfamiliar with markdown, that can feel like coding. Obsidian solves this by opening the folder as a readable, searchable knowledge base. It lets you: * browse files in a sidebar * read markdown with proper formatting * edit the underlying `.md` files directly * search across the whole folder * organize Claude outputs and persistent instructions * keep everything local, without importing files into a separate cloud database ## Recommended Setup ### Step 1: Install Claude Desktop Claude Cowork is used through the Claude desktop app. Install the desktop app and make sure your account supports the Cowork feature. > Verification needed: confirm the current account requirements, subscription tier, and platform availability before publishing this guide. ### Step 2: Create a Local Cowork Folder Create a folder on your computer called something like: ```text Claude Cowork ``` Inside it, create these subfolders: ```text about-me claude-output templates skills ``` This folder will function as the shared workspace between Claude Cowork and Obsidian. ### Step 3: Add Core Context Files Inside `about-me/`, create three starter markdown files. ```text about-me/ ├── about-me.md ├── anti-ai-writing-style.md └── my-company.md ``` #### `about-me.md` Use this file for durable personal and professional context. Example structure: ```md # About Me ## Role I am [role/title]. I work on [main responsibilities]. ## Audience I usually write for [audiences]. ## Goals My work should help [audience] do [goal]. ## Preferences - Prefer clear, direct prose. - Avoid generic AI phrasing. - Use concrete examples. - Ask clarifying questions when the task is ambiguous. ## Current Priorities - [Priority 1] - [Priority 2] - [Priority 3] ``` #### `anti-ai-writing-style.md` Use this file to describe what you do **not** want. Example structure: ```md # Anti-AI Writing Style Guide Avoid: - generic enthusiasm - overused transitions - filler phrases - vague claims - exaggerated certainty - corporate-sounding language - repetitive sentence structures - bland summaries that could apply to anything Prefer: - precise language - specific examples - clear stakes - concrete nouns and verbs - varied sentence rhythm - honest uncertainty when needed ``` #### `my-company.md` Use this file for organizational context. Example structure: ```md # Organization Context ## What We Do [Short description] ## Audience [Who the organization serves] ## Voice [How the organization should sound] ## Current Offers / Programs / Products - [Item 1] - [Item 2] - [Item 3] ## Important Constraints - [Constraint 1] - [Constraint 2] ``` ### Step 4: Configure Claude Cowork Instructions In Claude Cowork settings, add global instructions that tell Claude how to use the folder. Example instruction: ```md Before beginning work, read the relevant files in `about-me/`, especially `about-me.md`, `anti-ai-writing-style.md`, and `my-company.md`. Use those files as persistent context for style, tone, audience, constraints, and recurring preferences. Do not modify files unless I explicitly ask you to. Save generated work in `claude-output/` unless I specify another location. ``` ### Step 5: Install Obsidian Install Obsidian from the official site. After installing: 1. Open Obsidian. 2. Choose **Open folder as vault**. 3. Select your `Claude Cowork` folder. 4. Obsidian will display your Cowork folder as a navigable knowledge base. No import or conversion should be necessary. Obsidian reads the files in place. ## Daily Workflow The workflow is based on two applications looking at the same folder. ### Obsidian Is Where You Maintain Context Use Obsidian to: * browse your context files * edit your standing instructions * search through past outputs * revise templates * update skill files * add examples of preferred work * remove stale or misleading guidance ### Claude Cowork Is Where You Generate Work Use Claude Cowork to: * draft documents * generate presentations * analyze files * build deliverables * create or revise outputs * apply your standing context to new tasks ### The Basic Loop 1. Open Obsidian. 2. Update or review the relevant context files. 3. Open Claude Cowork. 4. Start a new session using the same Cowork folder. 5. Give Claude a short task-specific prompt. 6. Claude reads the folder context and creates the output. 7. Review the output. 8. Save or revise durable lessons back into Obsidian. ## Example: Updating Claude’s Persistent Context Suppose Claude repeatedly uses a phrase you dislike. Instead of correcting it in every chat, open `anti-ai-writing-style.md` in Obsidian and add: ```md Never use the phrase "unlock the power of". It sounds generic and promotional. ``` The next time Claude Cowork reads that file, the instruction becomes part of the working context. The principle is: > Do not keep re-prompting the same correction. Save the correction in the relevant context file. ## Example: Changing Your Professional Context If your role, audience, or project changes, edit `about-me.md`. Example: ```md ## Current Role I am now focused on helping faculty build AI-aware assignments and research workflows. ``` Once this is saved, future Cowork sessions can draw on the updated context. ## Example: Using a Deliberately Obvious Test To verify that Cowork is reading the folder, add a temporary, unmistakable instruction to `about-me.md`. For example: ```md For testing only: if asked what snack I want, answer "coconut". ``` Then start a new Cowork session using the same folder and ask a simple question related to snacks. If Claude responds with the test detail, the folder context is being read. After testing, remove the temporary instruction. ## Working With Outputs Claude Cowork can create outputs in the local folder. Keep those outputs organized. Recommended structure: ```text claude-output/ ├── drafts/ ├── reports/ ├── presentations/ ├── newsletters/ ├── meeting-notes/ └── archive/ ``` The exact structure depends on your work, but the important principle is to keep generated outputs separate from durable instructions. ### Durable Context vs. Temporary Output | Type | Example | Where it belongs | | -------------------- | ------------------------------ | ----------------------------------------- | | Durable instruction | “Avoid generic AI phrases.” | `about-me/` or `anti-ai-writing-style.md` | | Reusable format | Newsletter template | `templates/` | | One-time deliverable | Draft newsletter for this week | `claude-output/` | | Repeatable workflow | `/newsletter` skill | `skills/` | ## Searching Across Your Claude Work One major advantage of Obsidian is search. Use Obsidian search to find: * past drafts * previous phrasing * reusable examples * instructions you forgot you wrote * recurring project notes * outputs Claude created weeks ago This can be more useful than relying on chat history because the work is stored as normal local files. ## Templates Use `templates/` for reusable structures Claude should imitate. Examples: ```text templates/ ├── newsletter-template.md ├── linkedin-post-template.md ├── client-brief-template.md ├── research-report-template.md ├── slide-deck-outline-template.md └── meeting-notes-template.md ``` A good template should include: * purpose * audience * structure * length expectations * required sections * optional sections * examples of strong outputs * common mistakes to avoid ### Example Template File ```md # Newsletter Template ## Purpose Create a clear, useful, non-generic newsletter for readers who want practical AI workflows. ## Structure 1. Specific problem 2. Why the usual solution fails 3. Better workflow 4. Step-by-step implementation 5. Example 6. Closing takeaway ## Style Rules - Use direct language. - Avoid hype. - Include concrete steps. - Keep paragraphs short. - Do not sound like a generic productivity influencer. ## Common Mistakes to Avoid - Opening with a vague motivational sentence - Overpromising results - Using too many rhetorical questions - Making claims without examples ``` ## Skills Skills are repeatable workflows for tasks you perform often. A skill is more specific than a general style file. It tells Claude how to perform a recurring task. Examples: ```text skills/ ├── newsletter.md ├── linkedin-post.md ├── client-brief.md ├── weekly-report.md ├── negotiation.md ├── meeting-notes.md └── slide-deck.md ``` ### When to Create a Skill Create a skill when: * you repeat the same task often * the task has a predictable structure * you keep giving the same instructions * there are consistent constraints * there are examples or benchmarks Claude should follow Do not create a skill for every one-off task. ### Example Skill: Newsletter ```md # Skill: Newsletter ## Use This Skill When The user asks for a newsletter draft, newsletter outline, or revision of an existing newsletter. ## Goal Create a useful, specific, non-generic newsletter that teaches a practical idea clearly. ## Inputs to Request Ask for any missing information that is necessary: - topic - audience - desired length - key examples - claim or argument - call to action ## Process 1. Restate the core argument. 2. Identify the intended reader. 3. Propose a structure before drafting. 4. Draft in the user’s preferred style. 5. Run the draft against the anti-AI writing style guide. 6. Provide a revision checklist. ## Output Format Return: 1. Title options 2. Draft newsletter 3. Suggested edits 4. Optional shorter version ## Constraints - Avoid generic AI phrasing. - Do not overstate claims. - Use examples. - Keep paragraphs readable. ``` ## Creating a Skill With Claude Cowork One way to create a new skill is to ask Claude to interview you first. Example prompt: ```md Create a skill called "negotiation". Interview me about the kinds of negotiations I handle, the constraints I care about, the experts or frameworks I want to draw from, and the outputs I need. After the interview, draft a reusable skill file that I can save in my `skills/` folder. The skill should include: - when to use it - what inputs to request - the step-by-step process - output formats - quality checks - examples ``` After Claude creates the skill: 1. Review it. 2. Save it in `skills/`. 3. Edit it in Obsidian as your workflow improves. 4. Reuse it when needed. ## Suggested Folder Structure for a Mature Setup ```text Claude Cowork/ ├── about-me/ │ ├── about-me.md │ ├── anti-ai-writing-style.md │ ├── my-company.md │ ├── audience-notes.md │ └── recurring-preferences.md ├── examples/ │ ├── strong-writing-examples.md │ ├── bad-writing-examples.md │ └── favorite-structures.md ├── templates/ │ ├── newsletter-template.md │ ├── linkedin-template.md │ ├── report-template.md │ └── presentation-template.md ├── skills/ │ ├── newsletter.md │ ├── linkedin-post.md │ ├── meeting-notes.md │ ├── research-report.md │ └── client-brief.md ├── claude-output/ │ ├── drafts/ │ ├── reports/ │ ├── decks/ │ ├── spreadsheets/ │ └── archive/ └── README.md ``` ## Recommended `README.md` At the root of the folder, create a `README.md` that explains how the workspace should be used. ```md # Claude Cowork Workspace This folder contains persistent context, templates, skills, and outputs for Claude Cowork. ## Instructions for Claude Before starting work: 1. Read relevant files in `about-me/`. 2. Use `anti-ai-writing-style.md` to avoid generic writing. 3. Check `templates/` when the user requests a recurring format. 4. Check `skills/` when the user invokes or implies a repeatable workflow. 5. Save generated outputs in `claude-output/` unless instructed otherwise. ## Do Not - Modify durable context files unless explicitly asked. - Overwrite templates without permission. - Mix one-time outputs into the instruction folders. - Treat old outputs as current facts without checking with the user. ``` ## Choosing Obsidian Over Other Tools The source material argues for Obsidian because it satisfies three practical requirements: 1. It works with local files. 2. It reads markdown directly. 3. It does not require import/export workflows. ### Comparison | Tool | Why it may not fit this workflow | | ---------------- | --------------------------------------------------------------------------------------------------------- | | Notion | Stores content in its own database; not ideal for directly editing local markdown files that Cowork reads | | Google Docs | Uses Google Docs format rather than plain markdown; requires conversion | | Apple Notes | Does not open a local folder of markdown files as a vault | | VS Code / Cursor | Powerful but developer-oriented; may be intimidating for non-technical users | | GitHub | Good for versioning and rendering markdown, but requires git workflow knowledge | | Typora | Strong single-file markdown editor, but not a full folder-based knowledge base | | MarkEdit | Minimal markdown editor, but less useful for searching and navigating a whole knowledge base | | Obsidian | Opens the local folder directly, renders markdown cleanly, and supports search and navigation | ## Cautions and Claims to Verify Before sharing this guide externally, verify the following details: * Whether Claude Cowork is currently available on the relevant plans. * Whether Cowork requires a paid Claude subscription. * Whether Cowork supports the exact file creation behaviors described. * Whether Skills are created, stored, imported, and invoked in the way described here. * Whether the `/skill-name` command syntax is current. * Whether Obsidian’s free tier terms remain the same. * Whether any claims about market valuation or product growth are accurate enough to include. The practical workflow does not depend on the more dramatic claims. Those should be removed unless independently verified. ## Practical Version of the Argument A more restrained version of the source argument would be: > Repeated prompting is inefficient when the same context, style preferences, and workflow rules are needed again and again. A local folder of markdown files can serve as persistent working context for Claude Cowork. Obsidian makes that folder easier to read, edit, search, and maintain. Together, they create a simple system for reusable AI context: Obsidian is where you maintain the knowledge base; Claude Cowork is where you apply it to generate work. ## Best Practices ### Keep Durable Instructions Separate From Outputs Do not let generated drafts clutter the files Claude uses as standing instructions. ### Update Context After Mistakes When Claude produces something you dislike, ask whether the correction belongs in a durable file. Examples: * Add style corrections to `anti-ai-writing-style.md`. * Add personal context to `about-me.md`. * Add organizational context to `my-company.md`. * Add reusable format guidance to `templates/`. * Add repeatable task logic to `skills/`. ### Use Examples Claude usually performs better when given examples of good work and bad work. Create files such as: ```text examples/strong-writing-examples.md examples/bad-writing-examples.md examples/preferred-hooks.md examples/preferred-report-structures.md ``` ### Review Old Context Periodically Persistent context can become stale. Schedule occasional cleanup: * remove outdated goals * update job titles or organizational details * archive old project instructions * revise templates after workflows change * delete test instructions ### Avoid Overloading the System More context is not always better. Prefer concise, well-organized files over a giant pile of miscellaneous notes. Good context files are: * current * specific * organized * easy to scan * explicit about priorities * clear about what should and should not be used ## Minimal Setup Checklist Use this checklist for a first version. * [ ] Install Claude desktop app. * [ ] Confirm access to Cowork. * [ ] Create a local `Claude Cowork` folder. * [ ] Add `about-me/`, `claude-output/`, `templates/`, and `skills/` folders. * [ ] Create `about-me.md`. * [ ] Create `anti-ai-writing-style.md`. * [ ] Create `my-company.md` or equivalent organization/project context file. * [ ] Add global Cowork instructions telling Claude to read the relevant context files. * [ ] Install Obsidian. * [ ] Open the Cowork folder as an Obsidian vault. * [ ] Test that Claude reads the folder context. * [ ] Save future corrections into the appropriate markdown files. ## Advanced Setup Checklist After the basic workflow is stable: * [ ] Add an `examples/` folder. * [ ] Add reusable templates. * [ ] Create skills for recurring tasks. * [ ] Build a clear output archive. * [ ] Add a root `README.md` with instructions for Claude. * [ ] Create periodic maintenance reminders. * [ ] Review stale context monthly or quarterly. * [ ] Add benchmark examples for high-value outputs. ## One-Sentence Summary Use Obsidian to maintain a local markdown knowledge base, and use Claude Cowork to apply that knowledge base when creating documents, drafts, presentations, and recurring deliverables.