Source: Every Claude Feature Explained for Normal People (YouTube seLX6SwP2hY), Ben (creator of Ben’s AIOS), 2026-05-21. 2026-10-28 addition: raw/CLAUDE_COWORK_FULL_COURSE_2+_Hours.md and raw/How_to_Use_Claude_Cowork_Better_Than_99%_of_People_Full_Guide.md (Ben AI, YouTube @BenAI92; see Ben’s earlier Cowork videos).
A comprehensive Cowork feature primer organized in three layers plus best practices plus team rollout. Same author as the previously articled Five-Skill AIOS Setup and is the broader feature-walkthrough version of the second-brain thesis — every feature is taught with the context-window-tax + token-economy lens. Headline framing: the limited context window is the problem every memory feature tries to solve; skills are how Claude remembers how to do work; routines are how skills run autonomously without your laptop open; Obsidian Relay is how a team shares one second brain in real time. Three layers: memory + context concepts (context window → global instructions → built-in memory → file access → claude.md → projects → second brain/AIOS); capabilities + automation (code execution → skills → evals → auto-research loop → scheduled tasks → routines → sub agents → dispatch); connectors + MCP (connectors → plugins → custom MCP → browser use → computer use → live artifacts).
Key Takeaways
Layer 1 — Memory + context concepts
- The context window is the constraint that drives every memory feature. Limited per chat; persistent across nothing. Long chats → context rot → worse performance + higher tokens. Fresh chat per task is the default discipline.
- Native built-ins are insufficient for serious work.
- Global instructions (settings → Cowork → global instructions): general preferences (“no em-dashes, respond in English”) applied across chats. Not project-specific.
- Built-in memory (capabilities tab → view and manage memory): auto-generated facts (role, preferences). Limited to ~one doc.
- The real solution: persistent context lives outside Cloud, in your own files. This is where Cowork + Claude Code split from chat-only Claude.
- File access = letting Cowork read/update/write a folder on your computer. Now every new chat can pull that context.
- The
claude.mdmap. Tells Cloud how a folder is structured, when to use which files, what rules to follow. Read at session start. Generate with “create a claude.md for this folder.” Routes the agent to the right files for the right tasks → less guessing → less context rot → fewer tokens → better outputs. - Cowork projects = pre-selected folder + specific
claude.md+ project-specific instructions/memory. Useful for area-of-work organization. - The second brain / AIOS. One centralized folder containing all your business + project + personal context — single source for any project / folder / team member. Compounds over time. Obsidian is just a visual overlay on the folder. Ben’s “Ben AIOS” is the implementation he sells (see Ben’s Five-Skill AIOS Setup).
Layer 2 — Capabilities + automation
- Code execution = Cowork running code locally to do work. Can read / process / produce any common file format (spreadsheets, PDFs, docs, decks, SVGs) + run scripts. Foundation under every other capability.
- Skills = saved how-to files (
SKILL.md+ reference files). The instruction process is laid out as steps. Examples Ben uses: newsletter writer, churn recovery, LinkedIn writer. Built by telling Cowork “build a skill” or by clicking “turn into skill” on a past conversation. Invoke with/skill-name. - Skill evals = built-in skill testing. Tell Cowork to “run a test on a skill.” Define criteria (works as intended? quality? tone? etc.). Cowork runs multiple parallel tests, scores each, gives a structured report + suggested fixes. Ben’s discipline: run at least 1-2 tests immediately every time you build a new skill.
- The auto-research loop. Non-Anthropic feature; Ben’s adaptation of a Karpathy framework specifically for skill optimization. Define criteria → baseline score → Cowork hypothesizes an improvement → runs test → keeps or discards based on score → next hypothesis. Ben’s example: LinkedIn writer skill, 10 iterations autonomous, +27% score lift without manual intervention.
- Scheduled tasks = Cowork runs a prompt or skill on a time interval (10min / day / week / month). Ben’s example: daily AI-news rundown for YouTube ideation. Limitation 1: requires Cloud desktop open. Limitation 2: time-trigger only, not event-trigger.
- Routines (Claude Code feature, not Cowork) bridges the gap. Runs on Anthropic’s cloud → laptop can be closed. Event-triggered → “when new lead lands in CRM, run my enrichment skill”; “when meeting transcript finishes in Fireflies, run my action-item skill”; “when customer cancels in Stripe, run my churn-recovery skill.” See Routines.
- Sub agents = Cowork spinning up parallel agents for bulk tasks. Each sub-agent has its own context, tools, skills. Returns only a summary to the main agent → main context stays clean. Ben’s example: 150 marketing agencies CSV → 15 parallel sub-agents qualify each against ICP + enrich with LinkedIn + draft personalized cold emails → full spreadsheet in minutes. Caveat: each sub-agent costs tokens.
- Dispatch = trigger Cowork tasks from the Claude mobile app; runs on your computer with full skill + connector + file access. Useful when you’re traveling.
Layer 3 — Connectors + MCP
- Connectors = pre-built software integrations bundled by Anthropic (CRM, Fireflies, Slack, Drive, etc.). Connect via customize → connectors. Apify is Ben’s most-recommended add — scrapes any website / social media.
- Plugins bundle connectors + skills + sub-agents into one install. Three sources:
- External / 3rd-party (Slack, Figma, Adobe — these ship with their own skill packs for their software).
- Anthropic-built (per department — marketing / sales / legal / etc.).
- Self-built (compose your own bundle + zip + share). Ben built a sales plugin combining sales-specific skills + agents + connectors.
- MCP (Model Context Protocol) = the protocol behind connectors. If your software isn’t in the connector list, Google
<software> + MCP— chances are someone’s built one. Add via customize → add custom connector → paste MCP server URL + credentials. - MCP builder skill = built-in Anthropic skill that creates an MCP from any software with an API. Ben’s example: built MCPs for Circle.so (his community) + Reddit using this skill.
- Browser use = Cloud takes control of your Chrome browser. Useful only as a last resort for software without API/MCP. High-token cost + error-prone. “If you can build an MCP, build an MCP.”
- Computer use = even more general than browser use — Cloud takes control of your entire desktop. Even more inefficient. Reserve for local desktop apps that don’t have an MCP (accounting software, etc.).
- Live Artifacts = personalized dashboards Cowork builds from prompts that pull live data from your connected softwares. Three Ben examples: marketing dashboard (YouTube + Bitly + PostHog), business intelligence dashboard (Stripe + PostHog with strategic insights), department-specific dashboards.
Best practices
- Mindset first. “Force yourself to use Cowork on almost every task even when it feels less efficient at the start.” Each up-front investment (building a skill, configuring an MCP) is amortized over months. Skipping these = staying at chat-quality forever.
- Token cost discipline.
- Keep context window clean — only feed it relevant data for the specific task.
- Start a new chat per task switch — don’t pile up a giant conversation.
- Sub-agents + browser use + computer use are the biggest token sinks. Only use sub-agents for bulk processing; only use browser/computer use when no MCP exists.
- Optimize
claude.mdto only pull most-relevant data per task. Ben’s threshold: 200-300 wordclaude.md(notably tighter than Jeff’s 250-line guideline).
- Model selection — the biggest cost lever most people don’t pull. Default is Opus.
- Sonnet for most day-to-day tasks (good quality, no heavy reasoning needed).
- Haiku for high-volume simple work (email triage, etc.).
- Opus for actual deep thinking / complex strategy / multi-step / research-heavy tasks.
- When to switch to Claude Code.
- Building actual software (codebases, apps) — Cowork is for one-off scripts + small dashboards.
- Running autonomous workflows with laptop closed (routines work; scheduled tasks don’t).
- Agent teams that communicate with each other (Cowork sub-agents only report to the main agent — Claude Code agent teams coordinate across each other).
- Access to softwares not in Cowork’s connector/MCP set.
Team rollout
- Team / Enterprise plan recommended — provides admin + permission controls.
- Permission settings in the admin panel: usage limits per team member, plugin allow/disallow, connector allow/disallow.
- Shared skills. Three ways:
- Customize → skills → share by email/team list.
- Download + email the skill manually.
- Organization settings → skills → upload (auto-distributes to everyone).
- Shared plugins — better for departmental rollouts (e.g., a marketing plugin combining marketing skills + connectors). Build via “build a plugin” prompt → zip file → admin panel upload.
- Shared second brain. The big team unlock. Everyone’s Cowork pulls from one centralized context folder.
- Sync via: GitHub, Obsidian Sync, or the Relay Obsidian plugin (Ben’s recommendation). Avoid Google Drive — adds an MCP-mediated inefficiency layer.
- Permissions limitation. Relay doesn’t have built-in read/write permission gating yet. Ben built a custom permissions layer on top — only available in his AI Accelerator community.
Ben’s earlier Cowork videos (January-April 2026, added 2026-10-28)
Creator: Ben AI · Platform: YouTube · Sources: raw/CLAUDE_COWORK_FULL_COURSE_2+_Hours.md (https://www.youtube.com/watch?v=2HyBA-wkWsA, 2:28:52, uploaded 2026-04-04) and raw/How_to_Use_Claude_Cowork_Better_Than_99%_of_People_Full_Guide.md (https://www.youtube.com/watch?v=HTu1OGWAn5w, 21:07, uploaded 2026-01-31).
The 2.5-hour course is mostly a compilation: its plugins, agents, scheduled-tasks, marketing and sales chapters repeat Ben’s February-March videos close to word for word, and its closing chapter covers his Obsidian second-brain setup. The wiki covers each piece where it fits:
| Ben video (upload date) | Covered in |
|---|---|
| How to Use Claude Cowork Better Than 99% of People (2026-01-31) | this section |
| Claude Cowork Plugins Explained (2026-02-14) | Cowork Plugins |
| Build Agent Teams within Claude Cowork (2026-03-04) | Cowork Sales Skills and Bulk Sub-Agents |
| Claude Cowork Just Became 10x Better: Scheduled Tasks (2026-03-11) | Scheduled Tasks |
| Claude Cowork Just Changed How You Do Marketing (2026-03-14) | Cowork Marketing Skills Playbook |
| Claude Cowork Just Changed Sales Forever (2026-03-19) | Cowork Sales Skills and Bulk Sub-Agents |
| Claude Cowork Full Course (2026-04-04) | the articles above, plus this section |
| How to Use Claude Routines (2026-04-25) | Routines |
| Live Artifacts Just 10x’d Claude Cowork (2026-04-27) | Live Artifacts |
What the course and January guide add beyond the primer above:
- Projects (course). New project → start from scratch, import a Claude chat project, or use an existing folder. Write instructions as a system prompt (his YouTube project: “you’re my YouTube assistant… any asset we create in these chats, please save them directly into the folder”). Project memory takes rules on request (“please help me memorize this”), and the project lists its chats and scheduled tasks.
- Order to try when connecting a tool (course): (1) native connector; (2) the tool’s MCP server: search ”
MCP server”, then either paste a remote URL under Connectors → + → Add custom connector, or open Settings → Developer → Edit config, paste the JSON into any AI chat with the vendor’s instructions, and paste the updated claude_desktop_config.jsonback, then restart; (3) build one with the MCP builder skill (he built a Circle.so MCP this way); (4) the browser; (5) computer use (turned on under the desktop app’s general settings), which he calls the slowest and most token-heavy option. The January guide also shows building an MCP server in n8n (his Unipile LinkedIn server) as a route for tools without one. For social sites Claude cannot read from a link, he uses Apify instead of the browser. - Always allow on connectors you trust, to stop repeated permission prompts.
- Built-in example skills (January). Settings → Capabilities → Example skills listed canvas design, MCP builder and skill creator; marketplace skills are downloaded as zips and uploaded via Add → Upload a skill. He then asked Claude to “use this skill combined with my specific knowledge sources to create a new skill” from a downloaded Meta-ads skill.
- Code execution (January). Charts from a spreadsheet and basic image edits such as aspect-ratio changes, distinct from building apps in Claude Code.
- Why skills over projects or n8n (course). Projects and custom GPTs are isolated, do not self-improve and hold limited context; n8n hard-codes deterministic flows. Skills sit between: one agent can hold thousands through progressive disclosure (name and description always loaded,
SKILL.mdon trigger, reference files only when a step calls for them), they keep a human in the loop, and they update by prompt. - Obsidian second brain (course closing chapter). Five advantages he lists: persistent context, Claude writing decisions and rules back (“remember this in my second brain”), skills that point to shared reference files so one ICP update reaches every skill, the same folder working in Claude Code and Codex, and team-wide sharing. Starting structure for a business:
context/,daily/,departments/,intelligence/,onboarding/,projects/,resources/,skills/,tasks/,team/, withCLAUDE.mdat the root; the solo version drops departments, team and onboarding. He says he started with about five files. Four habits: point every task at the same folder; say “remember this in my second brain”, naming the file if you can; tell Claude to updateCLAUDE.mdwhen it navigates badly; and store skill reference files in the second brain rather than inside each skill. See Ben’s Five-Skill AIOS Setup for his setup plugin.
Outdated in these videos. Cowork as a desktop-only second tab on paid plans, scheduled tasks that need the desktop app open, and “Opus 4 or Sonnet” in the model picker all predate the July 2026 web and mobile launch and the September 2026 chat/Cowork merge; see Claude Cowork for the current state.
The three layers, visually
┌───────────────────────────────────────┐
│ Memory + Context │
│ context window → global instructions │
│ → built-in memory → file access │
│ → claude.md → projects → second brain│
└───────────────────────────────────────┘
│
▼
┌───────────────────────────────────────┐
│ Capabilities + Automation │
│ code execution → skills → evals │
│ → auto-research loop → scheduled │
│ tasks → routines → sub agents │
│ → dispatch │
└───────────────────────────────────────┘
│
▼
┌───────────────────────────────────────┐
│ Connectors + MCP │
│ connectors → plugins (external / │
│ Anthropic / self) → MCP → browser use│
│ → computer use → live artifacts │
└───────────────────────────────────────┘
When to switch from Cowork → Claude Code
| Use case | Cowork | Claude Code |
|---|---|---|
| Office work / business automation | ✅ | (overkill) |
| One-off code scripts + small dashboards | ✅ | ✅ |
| Building actual apps / codebases | ❌ | ✅ |
| Autonomous workflows w/ laptop closed | ❌ (scheduled tasks need open laptop) | ✅ (routines run on Anthropic’s cloud) |
| Event-triggered automation | ❌ | ✅ |
| Agent teams that communicate | ❌ (sub-agents only report to main) | ✅ |
| Access to non-connector/non-MCP software | ❌ | ✅ |
Try It
- Audit your current Cowork setup against Layer 1. Do you have file access enabled for at least one folder? A
claude.mdat its root? At least one project configured? If any answer is no, fix it before exploring further capabilities — the rest compounds on top. - Build + eval your first skill in the same session. Pick a repetitive task. Build the skill. Run two evals on it immediately. Iterate on the evals’ suggestions.
- Try the auto-research loop on a working skill. Use Ben’s framework (or get the skill from his AI Accelerator). Set criteria, let it run 5-10 iterations, measure delta vs starting baseline.
- Pick one workflow to move from scheduled-tasks → routines. Either an event-triggered need (“when X happens, do Y”) or one where your laptop being open is the bottleneck.
- Switch model selection. Default Sonnet for the next day of work; reserve Opus for actual deep tasks. Measure your token bill delta over a week.
- For teams: start the shared second brain. Pick ONE centralized folder (start with brand voice + ICP + business strategy). Sync via Obsidian Relay across two team members. Measure: do their Cowork outputs converge on the same voice over a week?
Open Questions
- Auto-research loop scaling. Ben’s example: 27% lift in 10 iterations. Does the lift plateau? Diverge? Worth a longer-horizon study.
- Sub-agent token economy. Ben says they burn tokens fast; explicit numbers for the 150-agency 15-sub-agent example aren’t given.
- Cowork vs Claude Code switching cost. Ben implies switching is “easy — just hit the tab.” But context (skills, connectors, claude.md) doesn’t carry across. What’s lost on a switch?
- Anthropic-built plugins for departments. Ben calls them “generic, but useful to customize.” Worth a deeper article surveying each.
- The “context compounds” claim. Ben’s claim is strong: second brain grows from 30-40 docs to thousands; outputs get more relevant. The diminishing-returns curve / quality ceiling isn’t discussed.
Related
- Top 5 Claude Cowork Tips I Wish I Knew from Day One (Jeff) — companion video same week, narrower tactical focus
- Ben’s Five-Skill AIOS Setup — Ben’s specific AIOS implementation
- Claude Cowork (Product Overview)
- Cowork Getting Started
- Cowork Projects — AI Consultant Recipe
- Cowork Plugins
- Live Artifacts
- Routines
- CLAUDE.md File Primer
- Essential MCP Servers
- Cowork Marketing Skills Playbook (Ben AI)
- Cowork Sales Skills and Bulk Sub-Agents (Ben AI)
- Skills vs Projects (Eliot Prince)
- Ben AI’s Second Brain Playbook — the same creator’s current second-brain method.
- Ben AI’s Skill-Engineering Framework — his skill-building method.