# I got a private lesson on Claude Cowork & Claude Code

Tom Brewer
#claude-code #guide #ai-development
Table of Contents
I got a private lesson on Claude Cowork & Claude Code
Watch on YouTube

I got a private lesson on Claude Cowork & Claude Code

These notes are based on the YouTube video by Greg Isenberg

Key Takeaways

  • Claude Cowork (Co‑work) = UI‑friendly front‑end for Claude Code – Turns a terminal‑only tool into a point‑and‑click experience that anyone (even non‑technical users) can operate, though power‑users still get finer‑grained control in the CLI. For a step‑by‑step setup, see the Claude Code tutorial.
  • Agentic AI = models that act on your computer, not just generate text – Can rename files, create spreadsheets, drive a browser, send emails, interact with Slack, etc.
  • Safety is built‑in, but not fool‑proof – Folder‑level permission gating, UI confirmation dialogs for destructive actions, and basic prompt‑injection sanitisation are provided. Users should still verify actions, especially deletions, because the UI does not run inside a sandboxed VM and there have been reports of accidental mass deletions.
  • Workflow paradigm shift – Users run many “clods” (agents) in parallel, treating them like digital teammates that you tend to rather than code line‑by‑line.
  • Extensibility via Skills & SDK – Claude Code and Co‑work share the same underlying Claude Agent engine (often referred to as the Claude SDK). Custom “skills” let the agent handle niche file formats or apps. Learn advanced skill creation in I Went Deep on Claude Code—These Are My Top 13 Tricks.
  • Practical use‑cases demonstrated – Batch‑rename receipt files, generate a local CSV → Google Sheet, email the sheet, auto‑message teammates on Slack, parallel research tasks.
  • Performance tips – Use the latest Opus 4.5 model with “thinking” mode, keep a simple cloud.md knowledge file up‑to‑date, and let the model verify its own output (e.g., run tests, preview a sheet). For server‑side performance considerations, check out 5 Claude Code MCP Servers You Need To Be Using.
  • Future outlook – Expect broader vertical‑specific skills (AutoCAD, finance, design), tighter integration with mobile/desktop, and a shift where most routine “toil” is off‑loaded to agents. Timelines are still speculative.

Important Concepts

1. Claude Code vs. Claude Cowork

AspectClaude CodeClaude Cowork
Primary interfaceTerminal / CLIGraphical UI (macOS now, Windows announced)
Target audienceDevelopers, power usersBeginners and casual users (though power users still benefit from the CLI)
Core engineClaude Agent (Claude SDK)Same engine, wrapped in UI & permission layer
ExtensibilitySDK, custom agents, hooksSDK behind the scenes; UI hides complexity

2. What “Agentic” Really Means

  • Actionable: The model can invoke tools (file system, browsers, APIs).
  • Observational: It can read screen content, parse DOM, inspect file metadata.
  • Interactive: It can click, type, drag‑and‑drop, and wait for UI feedback.

Agentic AI ≠ just “smart chat”. It’s a loop of observe → decide → act → observe.

3. Permission Model & Safety Layers

  1. Folder‑level opt‑in – By default the agent sees nothing; you explicitly grant access to specific directories.
  2. UI confirmation dialogs – Destructive actions (e.g., file deletions) trigger a confirmation prompt.
  3. Basic prompt‑injection guards – The model sanitises inputs from web pages or emails to reduce malicious instruction injection.

Note: The current implementation does not run actions inside a sandboxed virtual machine, and there have been documented cases of accidental large‑scale deletions. Treat the UI as a convenience layer and verify critical operations manually.

4. “Reverse Solicitation” (Model Asking for Clarification)

  • When the agent is unsure (e.g., missing receipt date), it asks the user instead of guessing.
  • This reduces errors and builds trust: the model only proceeds once you confirm.

5. Skills & Custom Extensions

  • Skill = a packaged description of how to interact with a specific tool or file format.
  • Example: a skill for Excel knows how to create tables, format cells, and export CSV.
  • Users can author new skills (e.g., for AutoCAD, Salesforce) and the agent will automatically leverage them when relevant.

6. Parallel “Clod” Workflow

  • Clod = a running instance of the agent (short for “Claude code”).
  • Typical pattern:
    1. Open several tabs (or devices) each with a distinct task.
    2. Let each clod draft a plan; approve or tweak the plan.
    3. Switch to auto‑accept edits mode so the clod executes the plan autonomously.
  • This enables multitasking at the agent level—you’re a conductor, not a single‑task worker.

7. Planning vs. Execution

  • Plan mode – The model outlines steps, asks clarification questions, and you approve.
  • Auto‑accept mode – Once the plan is solid, the model proceeds without further human confirmation.
  • A good plan dramatically improves output quality and reduces the need for post‑hoc fixes.

8. Knowledge Base – cloud.md

  • Simple plain‑text file stored in the repo.
  • Contains “do‑and‑don’t” rules, known bugs, preferred patterns.
  • Updated manually or via GitHub actions (@cloud mentions).
  • Acts as a shared memory for all clods on a team, helping to avoid repeated mistakes.

9. Model Choice: Opus 4.5 with “Thinking”

  • Why Opus 4.5? Larger, smarter, better at tool use and planning.
  • Thinking mode – The model spends extra compute on internal reasoning, yielding fewer token calls overall → cheaper despite higher per‑token price.

Practical Demo Walkthrough

StepActionOutcome
1️⃣Grant Co‑work access to Receipts folderAgent can read/rename files only in that folder.
2️⃣Prompt: “Rename files to match receipt dates?”Agent lists files, asks clarification for missing dates (reverse solicitation).
3️⃣Agent renames files → user verifiesFiles become consistently named (e.g., 2024‑01‑15‑Amazon.pdf).
4️⃣Ask agent to “create a spreadsheet from these receipts”Agent builds a local CSV, then opens Chrome and creates a Google Sheet.
5️⃣Permission prompt for browser control → “Always allow”Agent logs into Google, creates sheet, populates rows.
6️⃣Request: “Email the sheet to Amy”Agent opens Gmail, composes message, fills recipient via contacts, attaches link, and sends.
7️⃣Parallel task: “Search startup ideas, summarize notes”Agent opens new tab, performs web search, aggregates findings in a note file.
8️⃣Slack automation example (later in conversation)Agent scans a status spreadsheet, messages missing owners in Slack.

Key observation: Even though the UI shows a “slow” visual process (clicks, typing), the model’s reasoning is fast; the bottleneck is the UI rendering and network latency, not the AI itself.

Tips for Getting the Most Out of Claude Cowork

  1. Start Simple – Install the macOS app + Chrome extension, grant folder access, and experiment with file‑renaming or spreadsheet generation.
  2. Leverage the Permission UI – Only expose the minimum needed directories; this reduces risk and keeps the model focused.
  3. Use Reverse Solicitation – When the agent asks a clarification question, answer precisely; it prevents downstream errors.
  4. Adopt Planning First – Always begin a task in plan mode; iterate until the steps look solid, then switch to auto‑accept.
  5. Maintain a cloud.md – Treat it as a living style guide for the agent; update it via @cloud comments in PRs or manually.
  6. Run Multiple Clods – Open several tabs or devices (desktop, web, iOS) and juggle tasks; you can even start a clod from your phone while commuting.
  7. Pick the Right Model – Default to Opus 4.5 with “thinking”; don’t downgrade to smaller models for cost—overall token usage will be lower.
  8. Verify Output – Let the agent test its own work (run the generated sheet, preview email, execute a script) before you accept.
  9. Create Custom Skills for Niche Tools – If you need the agent to work with a proprietary file type, author a skill and register it via the SDK.

Future Vision (Speculative)

  • Vertical‑specific marketplaces – Communities may publish ready‑made skills (e.g., “AutoCAD‑draw‑floorplan”, “FinTech‑reconcile‑transactions”).
  • Full‑device parity – Windows, Linux, Android, and iOS versions are planned, but not yet generally available.
  • Zero‑click automation – Future shortcuts could let you say “Hey Claude, file today’s receipts” and have the workflow run without opening the app.
  • Collaborative “agent teams” – Multiple agents could hand off tasks to each other (e.g., a data‑scraping agent passes a cleaned CSV to a reporting agent).
  • Regulatory & audit layers – Built‑in logs of every action, with optional tamper‑proof audit trails for compliance‑heavy industries.

🔗 See Also: UPDATED 2026 Claude Code Tutorial #1 - Intro & Setup
💡 Related: I Went Deep on Claude Code—These Are My Top 13 Tricks

Summary

Claude Cowork transforms Claude Code from a developer‑centric CLI into an accessible, UI‑driven agent that can act across your file system, browser, and communication tools. Its core strength lies in true agentic behavior—observing, deciding, and acting—while providing safety through granular folder permissions and UI confirmations (though not a full sandbox).

The workflow emphasizes planning first, then auto‑accept execution, and encourages running many agents in parallel, turning them into digital teammates. Extensibility via the Claude SDK and custom skills means the platform can adapt to any industry‑specific need.

Practical demos (renaming receipts, generating Google Sheets, emailing, Slack nudges) showcase how everyday tedious tasks can be off‑loaded. Performance tips—using Opus 4.5, maintaining a simple cloud.md, and letting the model verify its output—ensure speed, cost‑efficiency, and reliability.

Looking ahead, Claude Cowork is poised to become a universal automation layer, with cross‑platform support, vertical skill marketplaces, and collaborative agent teams that let users focus on creative, high‑value work while the agents handle the repetitive grind.

Tom Brewer Avatar

Thanks for reading my notes! Feel free to check out my other notes or contact me via the social links in the footer.

# Frequently Asked Questions

What’s the difference between Claude Code and Claude Cowork, and when should I use each?

Claude Code is a terminal‑only tool aimed at developers and power‑users who want fine‑grained control via the CLI, while Claude Cowork wraps the same Claude Agent engine in a graphical UI that lets anyone point‑and‑click to trigger actions.

Use Claude Code when you need custom scripts, complex hooks, or want to work entirely in a shell; choose Claude Cowork for quick, everyday tasks like renaming files or generating spreadsheets without writing code.

How do I safely grant folder‑level permissions so Claude Cowork can act on my files?

When you first launch Claude Cowork, it shows a permission dialog that lets you opt‑in specific directories; only those folders become visible to the agent.

After granting access, you can later adjust or revoke permissions in the Settings → Permissions panel, ensuring the model never sees files outside the approved scope.

Why is the UI‑based Claude Cowork recommended for non‑technical users instead of the CLI?

The UI abstracts the underlying command syntax into buttons, drag‑and‑drop, and confirmation dialogs, removing the need to remember exact CLI flags or write scripts.

This lowers the learning curve, lets users focus on the desired outcome (e.g., “create a spreadsheet”) while the agent translates the request into safe actions behind the scenes.

Can you explain the step‑by‑step process Claude Cowork uses to extract receipt data and publish it to a Google Sheet?

First, the agent scans the selected receipt files, uses OCR‑based parsing to pull fields like date, vendor, and amount, and writes those rows to a local CSV.

Next, it opens a browser window, logs into Google Drive, creates a new Google Sheet, uploads the CSV, and finally shares the sheet via a generated link or email, all while prompting you for confirmation before each destructive step.

What safety mechanisms does Claude Cowork have, and how can I prevent accidental mass deletions?

Claude Cowork includes folder‑level opt‑in, UI confirmation dialogs for any destructive operation, and basic prompt‑injection sanitisation.

To avoid accidental mass deletions, always double‑check the files listed in the confirmation dialog, keep a backup of critical directories, and consider enabling the optional “dry‑run” mode that shows the intended actions without executing them.

Related Posts

Continue Reading