06-reference

navtoor cowork best practices

Sat Feb 28 2026 19:00:00 GMT-0500 (Eastern Standard Time) ·article ·source: x.com/@heynavtoor ·by Nav Toor
claude-coworkbest-practicescontext-architecturetask-designautomationpluginsskillssystem-engineeringconsulting-reference

17 Best Practices That Make Claude Cowork 100x More Powerful

Nav Toor (@heynavtoor), second article from this author, published March 1, 2026. After 400+ Cowork sessions across 7 weeks, Navtoor documented the 17 practices that separate power users from everyone else. The gap isn’t prompting skill — it’s setup, structure, and system design.

The central shift: ChatGPT rewarded prompt engineering. Cowork rewards system engineering. The prompt is the least important part of a Cowork session.

The Pattern Behind All 17

Every practice follows the same principle: invest in setup, reduce prompting. Struggling Cowork users write long detailed prompts for every task. Thriving users spent an afternoon building their context architecture and now write ten-word prompts that produce client-ready deliverables.

Part 1: Context Architecture (Practices 1–5)

These five practices alone will transform the Cowork experience. Everything else builds on this foundation.

1. Build a _MANIFEST.md for every working folder The single highest-impact practice. When Cowork points at a folder, Claude reads everything — including outdated drafts and superseded versions. The _MANIFEST.md tells Claude which documents are the source of truth, which subfolders map to which domains, and what to skip.

Three tiers:

Underscore prefix keeps it sorted to the top. Five minutes to fill out, hours saved in confused output. Non-negotiable for folders over 10 files.

2. Use Global Instructions as your permanent operating system Most people leave this blank. Global Instructions load before everything — before files, before prompts, before Claude looks at your folder. They’re the baseline behavior for every session. Even a lazy, rushed prompt still produces calibrated output when Global Instructions are well-written. Example: “Before starting any task, look for _MANIFEST.md and read Tier 1 files first. Always ask clarifying questions before executing. Show a brief plan before taking action. Default output format: .docx. Never use filler language. Quality bar: client-ready without editing.”

3. Create three persistent context files about-me.md, brand-voice.md, working-style.md in a folder named Claude Context or 00_Context (so it sorts first). These eliminate the “generic AI output” problem overnight. Without them, every session starts cold. With them, Claude starts every session already knowing your voice, standards, and preferences.

Key insight: these files compound. Refine weekly. Every time Claude produces something you don’t like, ask if it’s a prompt problem or a context problem. Nine times out of ten, it’s context. Add one line to one file — permanent fix.

4. Use Folder Instructions for project-specific context Three layers: Global Instructions (universal) → Folder Instructions (project-specific) → Prompt (task-specific). This layering produces output that sounds like it came from someone who’s been on the team for six months. Folder Instructions activate when you select that folder; Claude can update them automatically during a session.

5. Never let Claude read everything — scope your context deliberately Claude’s context window is over 1M tokens on Opus 4.6, but bigger context doesn’t mean better output. More irrelevant files = more noise = worse output. Tell Claude exactly what to read. In Global Instructions: “When starting any task, look for _MANIFEST.md first. Load Tier 1 files. Only load Tier 2 files when the task explicitly touches that domain. Never load Tier 3 unless I specifically ask.” For subagents: give each only the minimum context needed for its subtask.

Part 2: Task Design (Practices 6–10)

6. Define the end state, not the process Cowork is not a chatbot — it’s a coworker. You don’t tell a coworker how to do their job step by step. You tell them what “done” looks like. Every task prompt should answer: What does “done” look like? What are the constraints? What should Claude do when uncertain?

Bad: “Help me with my files.” Good: “Organize all files in this folder into subfolders by client name. Use format YYYY-MM-DD-descriptive-name. Create a summary log documenting every change. Don’t delete anything. If a file could belong to multiple clients, put it in /needs-review.”

7. Always request a plan before execution Add to Global Instructions: “Show a brief plan before taking action on any task. Wait for my approval before executing.” This one line prevents 90% of Cowork disasters. Cost: 30 extra seconds per task. Benefit: you never have to undo a 20-minute autonomous mistake.

8. Tell Claude what to do with uncertainty Build uncertainty handling into every task: “If a date isn’t clear, mark it as VERIFY. If a file could go in multiple folders, put it in /needs-review. If you’re less than 80% confident in a classification, flag it instead of guessing.” Transforms Cowork from a tool that sometimes produces errors into a tool that tells you exactly where it needs your judgment.

9. Batch related work into single sessions Every session has startup cost (file reading, context loading). Don’t run five sessions for five related tasks. Run one: “Process this month’s expense receipts, update the budget spreadsheet, generate a summary report, draft an email to finance, save everything to /monthly-reports/february.” Context from each task informs the next. Faster, cheaper, higher quality. If hitting usage limits, this is usually the fix.

10. Use subagents deliberately — ask for parallel processing Cowork’s most powerful and most underused feature. Include “Spin up subagents to…” in your prompt. Example: “I’m evaluating four vendors. Spin up subagents to research each one’s pricing, support reputation, and integration options. Give me a comparison table.” Sequential: 40 minutes. Parallel with subagents: 10 minutes. Use for: competitive analysis, multi-source research, batch file processing, evaluating options from different angles. Best on Opus 4.6; consumes more tokens — use for complex tasks where time savings justify cost.

Part 3: Automation and Scheduling (Practices 11–13)

11. Schedule recurring tasks with /schedule Best scheduled tasks: Monday morning briefing (review Slack + calendar, flag what needs prep), Friday status report (pull completed tasks, draft status update), daily competitor tracking (research for news or pricing changes, save summary only if something new). Critical limitation: tasks only run when computer is awake and Claude Desktop is open.

12. Build once, run weekly — externalize everything to files Cowork has no memory between sessions — by design. No context bleed, no hallucinated recollections. But you can’t rely on “Claude remembers how I like this done.” Solution: externalize everything to files. Preferences → context files. Project plans → markdown documents. SOPs → skill files. Decisions → log files. One documented workflow is portable, shareable, and version-controlled. It doesn’t live in one AI’s memory — it lives in your system.

13. Use the /schedule + connectors combo for real automation Connect Gmail, Slack, Google Drive, Notion, Asana, then schedule tasks that pull live data: “Every Monday, pull all unread Slack messages from #product-feedback, categorize by theme, create a summary in Google Drive.” “Every morning, check Gmail for invoices, extract amounts and dates, update the expenses spreadsheet.” This is where Cowork stops being a task executor and starts being an autonomous system.

Part 4: Plugins and Skills (Practices 14–16)

14. Stack plugins for compound capability Plugins are composable. Install multiple plugins and use capabilities from all of them in one task. Example: Data Analysis + Sales plugins → “Analyze our Q1 pipeline data (Data Analysis), identify the three weakest deals, draft personalized follow-up emails for each (Sales).” Suggested stack: Productivity (always on) + Data Analysis (always on) + Sales or Marketing (rotate based on focus).

15. Build custom skills for your specific workflows A skill is a markdown file that teaches Claude how to approach a specific, repeatable task. Structure:

# [Skill Name]
## Purpose: What this skill does.
## Inputs: What information Claude needs.
## Process: Step-by-step instructions.
## Output: What the finished deliverable looks like.
## Constraints: Rules and guardrails.

Save as .md files in working folder or upload via Customize menu. Encode everything you’d normally spend 20 minutes explaining in a prompt — then say “Run my [skill name] on [topic].”

16. Use the Plugin Management plugin to build plugins conversationally Install Plugin Management, then: “Help me create a plugin for [your workflow].” Claude interviews you about the workflow and builds the plugin. No code, no GitHub, no markdown syntax. For enterprise teams: build once, distribute to hundreds via private plugin marketplace (launched February 2026). Standards live in the plugin, not in individual memory.

Part 5: Safety and Efficiency (Practice 17)

17. Treat Cowork like a powerful employee, not a toy Non-negotiable safety practices:

Implementation Checklist

Today (30 minutes): Create three context files + set Global Instructions. This alone puts you ahead of 95% of Cowork users.

This week: Add _MANIFEST.md to most-used project folder. Install 2–3 plugins that match your role. Set up one scheduled task.

This month: Build first custom skill for most repeated workflow. Experiment with subagents on a complex research task. Refine context files based on output quality.

Connections

Actionable for RDCO

For consulting clients: The implementation checklist is a deployable client deliverable. Package it as a 3-session engagement: Session 1 (context architecture + global instructions), Session 2 (first workflow + plugin selection), Session 3 (scheduling + custom skill). This maps exactly to practices 1–5, 6–10, and 11–16.

The _MANIFEST.md pattern should be adopted in the RDCO vault and on client deliverable folders immediately — it’s the same principle that makes our vault work (canonical docs surfaced first, archived docs buried), formalized as a file Claude reads at the start of each session.

The “system engineering vs. prompt engineering” frame is the single best talking point for selling Cowork consulting services: clients who try to prompt their way to results will fail; clients who invest in context architecture will thrive. That’s the consulting value-add.

Custom skills map directly to our ~/.claude/skills/ structure. Every repeatable RDCO workflow (vault processing, newsletter research, client briefs) should have a corresponding skill file so new sessions start with the full playbook rather than from scratch.