How to Use Claude Cowork for Web3 Development

By the Sherlock team · March 9, 2026 · 7 min read

Claude Cowork gives Web3 developers something most AI tools do not: a sandboxed environment that can read your codebase, run scripts, query onchain data, generate formatted deliverables, and chain multi-step tasks together without you babysitting every prompt. Since Anthropic released Cowork as a research preview in January 2026 (initially for Max subscribers on January 12, then expanded to Pro on January 16), we have been testing it across our own workflows and watching how the teams we work with are integrating it into their development and pre-audit processes. This guide covers where Cowork genuinely accelerates Web3 development, where it falls short, and the specific workflows that save builders the most time without compromising on the security rigor that blockchain demands.

Executive Summary

After testing Cowork internally and watching protocol teams integrate it into their pre-launch workflows, two patterns stand out. First, it collapses multi-step dev workflows into single tasks — you describe a complete sequence ("scaffold this contract, generate the test suite, model the tokenomics, write the docs") and Cowork executes it end to end in a sandboxed VM, which is fundamentally different from a chatbot. Second, MCP connectors from third-party providers like QuickNode can give it live onchain context, letting Claude cross-reference your code against actual blockchain state mid-task. The throughline across every workflow we tested: Cowork saves the most time on the work around your contracts — tests, docs, modeling, research — not on the production logic itself.

What Cowork Actually Is (and What It Is Not)

Cowork shares its agentic architecture with Claude Code, Anthropic's developer CLI tool, but is packaged for knowledge work inside the Claude desktop app. According to Anthropic's documentation, it runs in a sandboxed VM on your machine, can execute code, read and write files in folders you grant access to, and connect to external services through Model Context Protocol (MCP) connectors. You control exactly which folders and connectors Claude can access. In our testing, this means Claude can interact with Hardhat or Foundry projects, install analysis tools, run test suites, and generate formatted output files within a single session. It is not a smart contract IDE and it is not a replacement for Remix or Foundry. Think of it as an autonomous research and operations assistant that happens to be able to run code, and the code it runs can touch your blockchain tooling. If you are working with pre-audit proprietary contracts, review Anthropic's data handling policies before processing code with novel mechanisms you have not yet disclosed publicly.

Setting Up Cowork for Blockchain Development

Step 1: Select your project folder. Open Cowork and choose your project's repo folder from the folder picker. Once mounted, Claude can read your contracts, configs, test files, and documentation directly. Mount only the specific repo directory relevant to the task. Do not mount a parent folder or your home directory, as Claude will be able to read everything inside the mounted path, including .env files and credentials if they are present. From there, you can set instructions for the session specifying your target chain (Ethereum, Solana, Base), your framework (Hardhat, Foundry, Anchor), your Solidity version, and any security standards you follow (OpenZeppelin, custom patterns).

Step 2: Install MCP connectors. Cowork supports MCP connectors through Anthropic's plugin system and its reviewed Connectors Directory. For blockchain work, QuickNode publishes an EVM MCP server that exposes tools like eth_getBalance, eth_getCode, eth_gasPrice, and transaction lookups across multiple chains. Dune Analytics also offers an MCP connector for pulling dashboard data. Note that these are third-party integrations, not built-in Cowork features — availability and setup steps may vary, so check each provider's documentation for current installation instructions.

Step 3: Set session instructions. Tell Claude your role ("I am a Solidity developer building a lending protocol"), your security priorities ("always check for reentrancy, access control, and oracle manipulation"), and your output preferences ("use Foundry test syntax, not Hardhat"). Anthropic's docs indicate Cowork supports configurable instructions, though the exact persistence behavior may evolve as the product moves beyond its research preview phase. One hard rule regardless: never paste private keys, mnemonic phrases, or deployment credentials into any AI session. If your workflow involves signing or deploying, handle key management in a separate environment that Cowork cannot reach.

‍

Where Cowork Saves Web3 Developers the Most Time

Contract scaffolding and refactoring. Describe what your contract needs to do and Cowork will generate a working Solidity or Rust scaffold with the structure, interfaces, and boilerplate handled. It follows patterns from OpenZeppelin and Anchor when prompted, handles inheritance chains, and can refactor existing contracts to reduce gas costs or improve readability. It is not writing your final production logic, but it cuts the time from idea to working draft significantly, especially for standard patterns like ERC-20 extensions, staking mechanisms, or access control layers. A caveat worth repeating: AI-generated Solidity can compile cleanly and still contain subtle vulnerabilities, from reentrancy paths that depend on callback ordering to storage collisions in upgradeable proxies. Treat every scaffold the way you would treat a junior developer's pull request: useful starting point, mandatory review before merge.

Test generation. Cowork can read your contract code and generate comprehensive test suites in Foundry or Hardhat syntax, including edge cases, boundary conditions, and fuzzing targets. In our experience, it meaningfully expands test coverage for the structural and mathematical paths that are easy to overlook under deadline pressure. Ask it to "write tests that try to break this contract" and the output quality improves significantly. We have seen teams go from 40% to 85%+ line coverage in a single session. One thing to watch for: AI-generated tests can create false confidence. A test suite that passes 100% does not mean your contract is secure, because Cowork generates tests based on the patterns it sees in your code, which means it can reproduce your own blind spots. Always supplement with manual edge case analysis and invariant testing.

Onchain research and debugging. With the QuickNode MCP connector, you can ask Claude to check contract deployments, verify balances, inspect bytecode, monitor gas prices, and pull transaction histories across Ethereum, Arbitrum, Base, and BSC. Combined with the Dune connector, you can have it analyze protocol metrics, TVL trends, and user activity data, then compile findings into formatted reports. This turns what used to be a multi-tab browser session into a single conversational workflow. For debugging, you can point it at a failed transaction hash and ask it to trace what went wrong.

Tokenomics modeling. This is an underrated use case. Cowork can take your token design parameters (supply, allocation, vesting schedules, emission curves) and generate a working Excel spreadsheet with formulas, conditional formatting, and scenario tabs showing how your token economics behave under different adoption curves. It models cliff unlocks, daily linear vesting, and treasury burn rates with actual Excel functions, not just static numbers. For teams preparing investor decks, this saves days of spreadsheet work.

Documentation and technical writing. Point it at your codebase and ask for technical documentation in Word format. It generates function descriptions, architecture overviews, deployment guides, and integration notes directly from the source code. It catches discrepancies between inline comments and actual implementation, which is exactly the kind of issue that slows down the audit scoping process and confuses integrators.

Security self-review before your audit. You can point Cowork at a contract directory and ask it to generate an architecture map showing inheritance chains and external calls, a function-by-function access control inventory, and pattern checks for common vulnerabilities like reentrancy, unchecked return values, and integer overflow. This is the same preparation work we recommend teams integrate into their development workflow. It catches the low-hanging issues early so you spend your audit budget on the complex business logic that actually needs human eyes. To be clear: this is pre-audit preparation, not a replacement for one. Cowork cannot evaluate novel business logic, cross-contract economic attacks, or governance manipulation vectors. For contracts handling real capital, a formal audit from a team that has not seen your AI-assisted development process remains non-negotiable.

5 Workflows to Try This Week

The best way to evaluate Cowork is to run it on a real task. Here are five workflows you can copy into a session today, each designed to produce a concrete deliverable in under 30 minutes.

1. Generate a full test suite from an existing contract. Open Cowork, grant access to your project folder, and type: "Read the contracts in /contracts and generate a Foundry test suite for each one. Include edge cases for reentrancy, integer overflow, and access control. Flag any functions that lack test coverage." Claude will read your Solidity files, scaffold the test directory structure, and write tests that target the actual logic in your contracts. Review the output, run forge test, and iterate on any failures.

2. Build a tokenomics model from your parameters. Type: "Create an Excel spreadsheet modeling a token with 1B supply, 20% team allocation with 12-month cliff and 36-month linear vest, 30% ecosystem fund, 15% investors with 6-month cliff and 24-month vest, 10% liquidity, and 25% community rewards emitted over 4 years. Include monthly unlock schedules, circulating supply charts, and a scenario tab where I can adjust the emission rate." You will get a working .xlsx file with formulas, not static numbers.

3. Run a pre-audit security self-review. Type: "Analyze all contracts in /contracts. Generate an architecture map showing inheritance chains and external calls, list every state-changing function with its access control modifier, check for reentrancy patterns, unchecked return values, and missing input validation. Output a markdown report I can send to my auditor." This produces the exact preparation package that speeds up the audit scoping process and reduces back-and-forth with your security team.

4. Query onchain data to debug a failed transaction. With the QuickNode MCP connector active, type: "Look up transaction [paste tx hash] on Ethereum mainnet. Trace the execution, identify where it reverted, check the contract's current state, and tell me what went wrong. Cross-reference with the source code in /contracts if the target contract is one of ours." Claude will pull the transaction data, decode the revert reason, and map it back to your codebase.

5. Generate deployment documentation and a security checklist. Type: "Read my codebase in /contracts and /scripts. Generate a Word document with: a contract architecture overview, a deployment sequence diagram, environment variable requirements, a pre-deployment security checklist covering access control, upgradeability, oracle dependencies, and emergency pause functionality, and a post-deployment monitoring plan." This workflow is especially valuable for teams preparing for mainnet launches where the steps to secure a contract for launch need to be documented and shared across the team.

Where Cowork Falls Short for Web3

Honest assessment: Cowork should not be writing your production smart contracts. AI-generated smart contract code still requires heavy human review, and the security risks of agentic AI in Web3 extend beyond code quality to include prompt injection, credential exposure, and unintended autonomous actions. The 2025 Trail of Bits evaluation found that even the best AI models overlook critical vulnerabilities unless explicitly prompted with detailed security context. Solidity and Rust have significantly smaller training datasets than Python or JavaScript, which means AI models produce more errors and miss more edge cases in blockchain-specific code. In a benchmark published by Anthropic's red team, Claude-class agents solved 55.8% of post-cutoff smart-contract exploit problems in simulation. That is a measure of frontier model capability in a controlled setting, not a direct indicator of how reliably Cowork catches vulnerabilities during day-to-day development — but it demonstrates both the power and the limits of current AI on security-critical code. The developer trust data reflects this: 84% of developers now use AI tools, but only 3% report high trust in AI output. For Web3, where a single logic error can drain a liquidity pool in seconds, that caution is warranted. Use Cowork to write faster. Do not use it to skip your security process.

‍

Recommended Skills and Plugins for Web3 Teams

Built-in skills that matter most. The xlsx skill generates tokenomics spreadsheets with working formulas, vesting schedules, and scenario tabs. The docx skill produces formatted audit reports, investor documentation, and technical specs directly from your codebase. The pdf skill handles compliance documents, whitepaper drafts, and form generation. These three cover the majority of deliverables Web3 teams need to produce outside of code itself.

Security-specific skills. Trail of Bits has published Claude skills for smart contract security scanning using their Behavioral State Analysis methodology. These add structured vulnerability detection patterns to your Cowork sessions, checking for reentrancy, access control gaps, and state manipulation vectors using the same frameworks their auditors use manually. If your team runs pre-audit self-reviews, installing these skills turns a general-purpose AI session into something closer to a lightweight security scanner.

Where to discover new skills and plugins. The Anthropic plugin directory is the primary hub for browsing and installing vetted plugins with a single click. Inside Cowork, type /plugin and open the Discover tab to browse what is available without leaving your session. Community marketplaces like Anthropic's open-source knowledge-work-plugins repo publish plugins you can install directly, and third-party directories like SkillsMP and Claude Code Skills Hub index hundreds of community-contributed skills across categories including blockchain development, DeFi protocol patterns, and multi-chain deployment workflows. For Web3 specifically, look for skills covering Solidity security patterns, Foundry/Hardhat test scaffolding, ERC standard implementations, and Arbitrum Stylus development. The ecosystem is growing fast, and checking these sources monthly surfaces new workflows that can save your team real time.

Build your own. If your team has repeatable workflows that no existing skill covers, you can create custom skills for pre-deployment checklists, governance proposal templates, incident response runbooks, or weekly onchain analytics reports. Anthropic's documentation confirms Cowork supports scheduled tasks for recurring work — potential use cases include a daily gas price summary, a weekly TVL comparison across your deployed chains, or a periodic digest of protocol activity. The exact scheduling interface and enterprise plugin distribution features may continue to evolve during the research preview.

The Bottom Line

The teams getting the most value from Cowork are the ones using it to move faster on tests, docs, modeling, and research while keeping human expertise and formal audits at the center of their security process. If you want help structuring that balance, talk to our team.

Frequently Asked Questions

Can Claude Cowork write smart contracts?

It can generate and refactor Solidity and Rust code, but treat the output like a junior developer's pull request — useful starting point, mandatory review before merge. Claude is strongest for scaffolding, test generation, and documentation rather than production logic.

What MCP connectors work for blockchain development?

Third-party providers like QuickNode and Dune Analytics publish MCP servers that give Claude onchain data access. These require separate installation and configuration — check each provider's docs for current setup steps and supported chains.

How can Web3 teams use Cowork for audit preparation?

Point it at a contract directory and ask for architecture maps, access control inventories, and vulnerability pattern checks. This pre-audit preparation reduces the surface-level findings that reach human auditors. See the "5 Workflows" section above for an exact prompt you can copy.

Is Cowork safe to use with private smart contract code?

Cowork runs in a sandboxed VM on your local machine, and you control which folders Claude can access. Never paste private keys or deployment credentials into any AI tool, and review Anthropic's data handling policies before processing proprietary contracts.

What are the best Cowork skills for Web3 developers?

The xlsx skill for tokenomics modeling, docx for audit reports, pdf for compliance docs, QuickNode EVM for onchain queries, and Trail of Bits security scanning skills. Browse the Anthropic plugin directory at claude.com/plugins or type /plugin in Cowork to discover community skills for Solidity patterns, Foundry scaffolding, and multi-chain deployments. Teams can also build custom skills for their own recurring workflows.

How does Cowork compare to other AI tools for blockchain development?

In Anthropic's red-team testing, Claude-class agents solved 55.8% of post-cutoff exploit problems in simulation — impressive but a benchmark measure, not a guarantee of day-to-day reliability. Cowork's key differentiator is agentic multi-step execution: you describe a full workflow and it runs the entire sequence autonomously in a sandboxed environment.

‍