Claude Cowork Preview: A Real User’s Experience With Three Critical Flaws
Summary: Claude Cowork is Anthropic’s experimental AI collaboration feature built into the macOS client. Its architecture centers on “local files as the core, supported by multi-platform Connectors and MCP-based plugins.” Hands-on testing reveals three significant limitations in this preview version: failure to enable TUN mode on proxy tools results in 403 errors; Project modifications are written only to a local session without real-time cloud sync; and the system cannot invoke already-installed Claude Skills, only a handful of built-in plugins. These shortcomings create a sharp contrast with the high-quality output Claude’s models are known for.
Introduction: The “AI Coworker” We’ve Been Waiting For
Late 2024. Anthropic quietly slips a new feature into the Claude macOS app. No press release. No launch event. Just a tab labeled “Cowork” — experimental, unpolished, but undeniably ambitious.
A user who goes by “Rainman on X” recently shared his hands-on experience with this preview. His post isn’t a review; it’s a field report. It documents what Claude Cowork tries to do, what it actually does, and where it stumbles.
This article is built exclusively on that user’s findings. No outside sources. No speculation. Just a methodical breakdown of one question: How far can a “local-first” AI collaboration tool go in 2024 — and what’s stopping it from going further?
Part I: The Blueprint – What Claude Cowork Wants to Be
1.1 Local Files as the Center of Gravity
Most AI collaboration tools — Notion AI, Google’s Duet AI — assume your data lives in the cloud. They pull from cloud storage, process in the cloud, return results to the cloud.
Claude Cowork does the opposite.
It puts your local files at the center. The app reads documents directly from your hard drive. Only the necessary context is sent to Anthropic’s API. The raw data, if you choose, never leaves your machine.
This isn’t a minor design decision. It’s a philosophy. For users handling drafts, non-disclosure agreements, or simply preferring to keep unfinished work off third-party servers, this architecture offers a level of privacy that cloud-native tools cannot match.
1.2 Connectors: Bridging the Walled Gardens
Local files alone aren’t enough. We live in a multi-platform world — Notion for notes, Google Drive for collaboration, Google Calendar for scheduling.
Cowork’s answer is Connectors. Each Connector is an authorized bridge. Grant permission once, and Claude can read metadata or content snippets from these services, then merge them with your local files.
Screenshots from Rainman’s post show a Connector configuration interface that’s already reasonably mature. OAuth flows. Granular permission toggles. It’s clear this part received attention.
What’s less clear is whether these Connectors perform reliably under real-world conditions. The user didn’t comment on speed or stability — perhaps because the three major issues overshadowed everything else.
1.3 MCP Plugins: Extensibility Through Protocol
MCP — likely Model Context Protocol — is Cowork’s answer to “what if Claude could do things, not just say things?”
Think of MCP as a contract. Third-party developers can build plugins that follow this contract, giving Claude the ability to query databases, call internal APIs, or trigger workflows. It’s an “API gateway for AI agents” concept.
The potential is clear. The implementation, as we’ll see, is still in early stages.
1.4 Projects: Tying It All Together
A Project in Cowork is a bundle. One Project contains:
-
A set of local files -
Several authorized Connectors -
Configured MCP plugins
Open a Project, and Claude automatically loads everything it needs to understand your context. No repeated explanations. No re-uploading.
Project = Context Definition + Toolbox.
On paper, elegant. In practice, this is where the user encountered his most frustrating friction point.
Part II: Three Hard Problems in the Preview Version
Experimental software gets a pass on polish. It does not get a pass on transparency. Users need to know what’s broken, why it broke, and whether there’s a temporary fix.
Here are the three issues Rainman documented, examined from a technical perspective.
2.1 The Proxy Handoff Problem: Why 403 Errors Aren’t Your Fault
What the user saw:
“If my local proxy tool isn’t in TUN mode, Cowork can’t intercept its own requests. The feature just fails — straight 403 error.”
What’s happening under the hood:
Claude macOS App, like many modern desktop apps, is built on a web-based framework (Electron or similar). Its network requests normally follow your operating system’s proxy settings.
But “normally” is the keyword here.
-
HTTP/HTTPS proxy: Works if the app explicitly supports it. Some network libraries, especially those used for real-time communication, don’t automatically inherit system proxy configurations. -
TUN mode: A feature in advanced proxy tools (Clash, Surge, Quantumult X) that creates a virtual network interface. It captures all IP traffic, regardless of whether the source app “knows” about the proxy.
Cowork appears to use a different network stack from the main Claude chat interface. Possibly WebSocket. Possibly a custom transport layer. Whatever it is, it doesn’t play well with standard HTTP proxies.
Quantifiable impact:
| Scenario | Cowork Functionality | Error |
|---|---|---|
| No proxy | Blocked by firewall | Connection timeout |
| HTTP proxy only | 100% non-functional | HTTP 403 Forbidden |
| TUN mode enabled | Fully functional | None |
Why 403 specifically?
A 403 Forbidden typically means: “You reached the server, but you’re not allowed in.” When a request bypasses the proxy and goes direct from certain regions, the server doesn’t see the expected authorization headers or IP whitelist. It refuses the connection. The error code is correct but completely unhelpful for diagnosing the root cause.
User takeaway:
This isn’t a bug in Cowork. It’s a network engineering oversight in a preview build. The fix — enable TUN mode — works but imposes a 5–10% system resource overhead and requires users to understand what TUN mode even is.
A mature product would either:
-
Implement explicit HTTP proxy support for all network calls -
Or display a clear diagnostic: “We detected your network configuration may block Cowork’s connections. Here’s what to do.”
Currently, it does neither.
2.2 Project Sync: The Session That Stayed Local
What the user saw:
“When I modify a Project, Cowork only writes to a local session. The changes don’t sync to the cloud version of the Project files. It feels broken.”
What’s happening under the hood:
Cowork treats Project configurations as local-first objects. When you add a file or change a Connector setting, the app writes this change to a session — a temporary state stored in memory or IndexedDB.
This session is fast. It’s responsive. It gives you the illusion that everything is saved.
But the cloud Project storage — the copy that would allow syncing across devices or with the web version — does not receive this update unless something triggers it. And in the preview version, nothing does.
Quantifiable observations from the user:
-
Force-quit the app, relaunch on the same machine: sometimes the session recovers, sometimes it doesn’t. -
Open Claude on another Mac: 0% chance the updated Project appears. -
Wait 5 minutes. Wait 10 minutes. No sync. -
There is no manual “Sync Now” button.
Why this feels worse than it sounds:
Modern users are trained by Google Docs, Notion, and Figma. The mental model is: change → instant cloud save → everywhere updated.
Local-first is a valid architecture. But it requires state visibility. Dropbox shows a “Syncing” icon. Figma shows “Saving…” Google Docs doesn’t even bother showing it anymore because it’s so fast.
Cowork shows nothing. The change appears saved. It is not.
2.3 Skills Integration: The Siloed Ecosystem
What the user saw:
“Cowork can’t properly call the Claude Skills I already have installed locally. It basically only uses a few built-in plugins. The experience is fragmented.”
What’s happening under the hood:
Claude Skills are custom extensions — users or organizations write them to give Claude specific abilities. A “Code Interpreter Skill” runs Python locally. A “SQL Query Skill” talks to a private database.
These Skills typically run as separate services or plugins, registered with the main Claude client.
Cowork, despite living in the same macOS app, does not share this registry.
The fragmentation manifests in three ways:
-
Discovery failure: Skills already installed and working in Claude chat are invisible to Cowork. -
Redundant installation: The user has to “reinstall” the same Skill inside Cowork’s MCP plugin interface. -
Limited selection: The user’s screenshot shows only a handful of official example plugins available. No community plugins. No private Skills.
Why this matters:
Cowork is supposed to be about doing work. Skills are how Claude does things. By failing to integrate with the existing Skills ecosystem, Cowork becomes a read-only, suggestion-only tool — exactly the opposite of its intended purpose.
Part III: The Claude Ecosystem Disconnect
“Even though this feature is built inside the Claude macOS app, its connection to the rest of the Claude ecosystem is surprisingly weak.”
This sentence from Rainman’s post deserves expansion.
| Dimension | Main Claude (Chat) | Claude Cowork (Preview) | Gap |
|---|---|---|---|
| Network resilience | Works with standard proxies | Requires TUN mode, else 403 | Different network stacks |
| Context persistence | Chat history saved in cloud | Project sync incomplete | Local-first design not yet production-ready |
| Extensibility | Supports custom Skills | Built-in plugins only | Modules not integrated |
The irony is sharp:
The same user who documented these flaws also wrote: “When it comes to genuinely helpful output, Claude is far ahead of ChatGPT. I’m seriously considering canceling my ChatGPT subscription.”
Cowork isn’t suffering because Claude’s models are weak. It’s suffering because the tooling around the models is incomplete.
This is common in experimental features. Teams prioritize validating the core interaction flow (local files + Connectors) and defer edge cases, ecosystem compatibility, and enterprise-grade reliability to later milestones.
For early adopters, these deferred items sometimes become dealbreakers.
Part IV: What This Tells Us About the Future of AI Collaboration
4.1 What a “Mature” AI Coworker Needs
Reverse-engineering from Cowork’s ambitions and current gaps, we can outline the requirements for a production-grade AI collaboration tool:
-
Network agnosticism: Function correctly (or fail clearly) under any reasonable network configuration. No “TUN mode required” without explanation. -
Synchronous transparency: Local edits and cloud state should be synchronized either instantly or with explicit user control. State must be visible. -
Ecosystem inheritance: Any plugin, Skill, or extension configured for the main AI client should be available in the collaborative environment without reconfiguration. -
Contextual memory: A Project is more than a file list. It should include conversation history, decision logs, and version-aware metadata.
4.2 The Preview’s True Value
Rainman’s experience suggests Cowork is not ready for daily production use. But that doesn’t mean it lacks value.
The value is in the concept validation.
-
Can a “local-first” AI collaboration tool work? Yes, the basic flow is intact. -
Do users want this? The frustration with missing features implies strong interest. -
Are the problems fixable? Proxy support, sync buttons, and Skills integration are all within standard engineering scope.
Anthropic isn’t selling a finished product here. They’re testing a direction. For users willing to tolerate friction, this is an opportunity to shape that direction.
For everyone else: wait for the next few updates.
FAQ: Questions You Probably Have
Q1: Is Claude Cowork free?
A: Cowork is included in the Claude macOS app. You need a Claude account (free or Pro). Some Connectors may require paid subscriptions to the respective third-party services (Notion, Google Workspace, etc.).
Q2: Is there a workaround for the proxy 403 error right now?
A: Yes. Enable TUN mode in your proxy tool, or use a VPN that supports global tunneling. Be aware that TUN mode may conflict with other network-dependent applications; consider enabling it only when using Cowork.
Q3: Does the Project sync problem cause permanent data loss?
A: No permanent loss has been reported. The issue is that new changes are not uploaded to the cloud, but the local session usually persists in the app’s storage. Force-quitting the app may clear this session. Workaround: keep the app running after making Project changes.
Q4: Will Cowork come to Windows or Linux?
A: The user report only mentions the macOS app. Anthropic has not announced cross-platform plans. Given the “local file” centric design, a port would require significant engineering effort.
Q5: Can I use my existing Claude Skills in Cowork?
A: Not at this time. This is the most frequently cited integration gap. It is reasonable to expect this will be addressed in future updates, though no timeline is available.
Conclusion: Patience, Not Complacency
Claude Cowork is a brave but unfinished step toward a different kind of AI collaboration.
Its “local-first, cloud-supplemental” architecture offers a privacy-conscious alternative to the cloud-native tools that dominate the market. The Connectors framework is thoughtfully designed. The Project concept, when fully realized, could genuinely simplify complex workflows.
But bravery doesn’t excuse broken basics.
A preview version can be forgiven for missing features. It is harder to forgive network incompatibility that fails silently, state synchronization that doesn’t synchronize, and ecosystem isolation that forces users to reconfigure what they’ve already configured.
For the technically curious: install it, test it, report the bugs. Anthropic has shown responsiveness to user feedback.
For everyone who just needs a tool that works: mark this as “check back in six months.”
The Claude model family remains excellent. The Cowork client, at this moment, is not yet excellent alongside it.
