Jonathon's AI Wiki

Every Claude Cowork Feature Explained for Normal People (Ben)

10 min read

Source: Every Claude Feature Explained for Normal People (YouTube seLX6SwP2hY), Ben (creator of Ben’s AIOS), 2026-05-21.

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.md map. 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:
    1. External / 3rd-party (Slack, Figma, Adobe — these ship with their own skill packs for their software).
    2. Anthropic-built (per department — marketing / sales / legal / etc.).
    3. 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.md to only pull most-relevant data per task. Ben’s threshold: 200-300 word claude.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:
    1. Customize → skills → share by email/team list.
    2. Download + email the skill manually.
    3. 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.

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 caseCoworkClaude 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

  1. Audit your current Cowork setup against Layer 1. Do you have file access enabled for at least one folder? A claude.md at its root? At least one project configured? If any answer is no, fix it before exploring further capabilities — the rest compounds on top.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

Graph View

Backlinks