How to run entire projects with Claude Code and Cowork

I run entire consulting engagements through Claude. Not coding tasks - full projects with 20+ stakeholders, meeting pipelines, deliverable tracking, CRM integration, and billing automation. Most people ask Claude to write emails. I ask it to run my business.

The gap between “using Claude” and “running projects with Claude” is enormous. It’s the difference between having a calculator and having a finance team. And with Cowork launching in January 2026, the non-developer side of this equation finally has proper tooling.

Claude Cowork is the part most people miss

Everyone fixates on Claude Code. It’s a terminal-based agentic coding environment that runs for hours on complex tasks. Spotify uses it to merge 650+ agent-generated pull requests into production every month. Their top engineers reportedly haven’t written a single line of code since December and still shipped 50+ features.

But here’s the thing. Code is maybe 20% of any real project.

The other 80% - stakeholder communication, research synthesis, document creation, data analysis, meeting prep, CRM updates - that’s what Cowork handles. Anthropic describes it as “Claude Code for the rest of your work.” It runs inside the Claude desktop app with direct access to your local folders on macOS, and connects to over 50 external services through MCP connectors: Google Drive, Gmail, Slack, Notion, Figma, DocuSign, Asana, and more.

The mental shift matters. Stop thinking “AI chat tool.” Start thinking “AI project team member.” Cowork is available on Max plans, which means the barrier to entry isn’t a six-figure enterprise contract - it’s a monthly subscription that any consultant or small team can justify.

What does “running a project” actually look like? In my consulting practice, Claude handles: building stakeholder profiles from LinkedIn and CRM data, prepping meeting agendas from past notes and recent emails, tracking deliverables across multiple workstreams, calculating billing with tiered rate logic, updating project dashboards after every interaction, and flagging when deadlines approach. The Claude for developers angle gets all the attention, but the non-code project work is where most hours actually go.

Here’s a concrete example. A PE-backed manufacturing company with 1,300+ employees across 21 sites needed an AI governance framework. The non-code work dwarfed the technical work. Stakeholder interviews across site leaders. Communication plans tailored to four different audience levels. Research into compliance frameworks across multiple jurisdictions. Deliverable tracking for 14 documents with staggered deadlines. Weekly status dashboards for the steering committee.

Cowork handled all of it. Connected to Google Drive for document management, Gmail for stakeholder communication tracking, and the CRM for contact data and meeting history. Claude Code handled the automation layer underneath - the scripts, the data transformations, the structured templates. Neither tool alone would have covered the engagement. Together, they replaced what would have been a project coordinator role.

Claude Code is the developer CLI. Cowork is its counterpart for everyone else. Together they cover the full spectrum of project work. I use both, constantly, and the handoff between them feels natural.

Plan mode stops you from winging it

The single most underrated feature in Claude Code is plan mode. Hit Shift+Tab twice. That’s it. Claude switches to read-only exploration - it can analyze everything, reason about anything, but it can’t change a single file.

Why does this matter? Because the 4-phase workflow it enables - Explore, Plan, Implement, Commit - fundamentally changes how you approach complex work.

Most people jump straight to asking Claude to do things. Write this. Build that. Fix this bug. Plan mode forces a different discipline. You explore first. You map the territory. You identify dependencies and risks. Then - and only then - you act. Community benchmarks suggest that tasks taking 35+ minutes with trial-and-error can drop to about 12 minutes when properly planned.

I used this pattern on an AI governance rollout across 21 manufacturing sites. Plan mode explored the existing technology stack across all sites, mapped stakeholder communication preferences for every site leader, identified 8 project dependencies that would have derailed the timeline, and produced a phased roadmap before any deliverable was drafted. Three agents ran simultaneously - one researching compliance frameworks, one mapping the organizational structure, one analyzing existing automation. All read-only. No risk.

Ben Newton’s ROADMAP.md pattern gets at a similar idea - persist your plans as markdown so every session starts with full project awareness. But for complex consulting work, the ROADMAP.md is just one file in a much larger system.

The key insight: plan mode isn’t about being cautious. It’s about being efficient. When you explore a codebase or a project structure in plan mode, you’re building a mental model that prevents the three most common failure modes: working on the wrong thing, duplicating existing work, and breaking dependencies you didn’t know existed.

In my consulting work, I enter plan mode before every new workstream kickoff. Even for non-code projects. Before drafting a change management communication plan, plan mode explores the existing stakeholder profiles, reviews past meeting notes for context, checks the deliverable tracker for dependencies, and identifies which audiences need which messages. Only after that exploration do I switch to implementation.

Plan mode isn’t just for code. Research plans, meeting strategies, deliverable sequencing, stakeholder mapping - any complex thinking benefits from the discipline of exploring before acting. The read-only constraint isn’t a limitation. It’s the feature.

Your project needs a brain file

CLAUDE.md is a markdown file that Claude reads at every session start. It’s persistent memory. And for running real projects, it’s everything.

The official documentation describes a hierarchy: managed enterprise policies at the top, then project-level CLAUDE.md files, then user settings, then local overrides. The technical details matter less than what you put in the file.

Here’s what goes into a CLAUDE.md for a real consulting engagement - drawn from anonymized multi-stakeholder projects I run right now:

Engagement overview. Scope boundaries, billing structure, key contract dates, rate tiers (hourly consulting with tiered pricing that drops above a monthly threshold). Claude needs this to calculate time tracking and flag billing period transitions.

Mandatory behaviors. This is the critical part most people miss. Not suggestions - commands. “On every operation, check CRM for new data. Display the status dashboard. Cascade updates to all affected files.” Claude follows these at every session start, automatically.

People quick reference. Twenty-plus stakeholder profiles with roles, communication preferences, last contact dates, and relationship notes. When I say “prep for the meeting with the VP of Operations,” Claude already knows their communication style, their open action items, and what happened in our last three conversations.

Decisions log. Every major decision with date, context, rationale, and who made it. Six months into an engagement, this is invaluable.

Self-updating rules. “Do not wait to be told. Discover new information and propagate it.” This is the lateral update rule - any new information cascades to ALL affected files. A meeting note updates person profiles, project status, time tracking, and the deliverable tracker simultaneously.

The folder structure that supports this:

Client-Project/
  CLAUDE.md                    (master intelligence - 500+ lines)
  00-Company-Profile/          (company research, org structure)
  01-People/                   (20+ stakeholder profiles)
  02-Projects/active/          (live workstreams with status)
  02-Projects/backlog/         (future projects scoped)
  03-Meetings/                 (chronological, dated notes)
  04-Time-Tracking/            (CSV with rate tier logic)
  05-Research/                 (deep-dive analysis docs)
  06-Deliverables/             (tracker + output files)
  07-Templates/                (reusable formats)
  _archive/                    (CRM data exports, historical)

This isn’t a suggestion. This is the structure running multiple active consulting engagements right now. The CLAUDE.md alone can exceed 500 lines - stakeholder details, billing rules, project status, mandatory behaviors, CRM integration commands all in one place.

The lateral update rule deserves emphasis because it’s the single behavior that makes this system work at scale. Without it, you update a meeting note and forget to update the person profile. You log a decision and forget to update the project status. You track time and forget to recalculate the billing period. With the lateral update rule baked into CLAUDE.md, none of that manual bookkeeping exists. Claude does it automatically, every time, without being asked.

The templates folder matters more than people think. A person profile template ensures every new stakeholder gets documented consistently - role, reporting line, communication preference, decision authority, last contact, open items. A meeting notes template ensures every session gets captured with the same structure. A deliverable template tracks status, owner, due date, audience, and dependencies. Consistency across dozens of files is what makes the system searchable and useful six months later.

Auto-memory adds another layer. Claude writes its own notes across sessions, building institutional knowledge that I never explicitly told it. Patterns it noticed. Preferences it inferred. Context it accumulated. It might note that a particular stakeholder always pushes back on timeline estimates, or that a certain deliverable format gets better reception from the board. Between the explicit CLAUDE.md and the implicit auto-memory, session 8 of an engagement is radically different from session 1.

Subagents turn one consultant into a team

Subagents are parallel Claude instances that each handle one focused task. Up to 10 running concurrently. Each gets its own context window, its own tool access, its own permissions. They can’t spawn other subagents - no infinite nesting - but they can run in isolated worktrees so there are no file conflicts.

Three built-in agent types cover most needs. Explore agents are fast and read-only, optimized for searching and understanding. Plan agents handle read-only analysis for designing approaches. General-purpose agents get full capabilities for complex multi-step work.

You can also define custom agents as markdown files in .claude/agents/ with specific system prompts and tool restrictions. A “CRM updater” agent that can only access your CRM API. A “meeting prep” agent with read-only access to your notes folder. A “billing calculator” agent that only touches the time tracking CSV. Each constrained to exactly what it needs.

Here’s how this plays out in consulting work.

Fan-out research. A client asks about AI audit costs across their industry. Three agents fire simultaneously - one researching audit frameworks, one pulling compliance requirements, one analyzing technology stack implications. Results converge in minutes instead of hours.

Meeting prep. Before a steering committee call, one agent pulls the latest CRM emails and summarizes new developments. Another reviews past meeting notes and identifies open action items. A third drafts the agenda based on project status and upcoming deadlines. All running in parallel. By the time I sit down, the meeting brief is ready.

Deliverable generation. Eight branded documents created in parallel across four different audiences - board summary, leadership brief, IT implementation guide, all-employee FAQ. Same underlying content, four different framings, produced simultaneously.

Post-meeting cascade. This is the one that saves the most time. After a single coaching session, Claude triggers a 10-step update: person profile updated, project file status changed, time tracking CSV appended, CRM task created, deliverable tracker refreshed, meeting notes filed, follow-up items scheduled, stakeholder dashboard recalculated, billing period checked, and the next meeting agenda seeded. Ten operations that would take 30 minutes of administrative work, done automatically. I paste raw meeting notes and walk away. By the time I come back, every downstream system reflects what happened in that conversation.

Cross-project coordination. When working with a mid-size IT consulting firm across multiple parallel workstreams, each project lives in its own folder with its own status tracking. But a single CLAUDE.md at the root sees across all of them. When a discovery in one workstream affects another - a compliance requirement that changes the timeline for an integration project, say - the lateral update rule propagates the change across both project files, updates the affected stakeholders, and flags the dependency in the deliverable tracker. No manual coordination needed.

The experimental agent teams feature pushes this further. Multiple agents can communicate directly with each other, not just through you. They share a task list with file-locking so agents claim work without duplicating effort. It’s early, but the direction is clear - Claude is moving toward fully autonomous project execution where the human role shifts from operator to supervisor.

The Anthropic Agent SDK takes this further for teams building custom automation - same tools and agent loop that power Claude Code, available as a TypeScript or Python library for CI pipelines and production systems. Sid Bharath’s workflow guide covers the technical setup well.

The compound effect nobody talks about

Every session builds on the last. That’s the real unlock.

Session 1, Claude knows nothing. You explain the engagement, the stakeholders, the scope. You’re doing most of the work.

Session 8, Claude knows 20+ stakeholders and their communication styles. It has 13 decisions logged with full context. It tracks billing status including rate tier transitions and weekly caps. It knows which projects are active, which are paused, which are in backlog. It knows what to prep for the next meeting without being asked. It flags approaching deadlines 14 days out.

Session 20, Claude has institutional knowledge that would take a new team member weeks to accumulate. The auto-memory has captured patterns I never explicitly documented - which stakeholders need more follow-up, which projects tend to slip, which deliverable formats work best for which audiences. The CLAUDE.md has grown to reflect the full complexity of the engagement. Every interaction is faster because the context is deeper.

Specific automation patterns that compound over time:

A status dashboard renders on every operation - hours this week, billing period progress, rate tier status, upcoming deadlines, CRM alerts. Not because I ask for it. Because CLAUDE.md mandates it.

Time tracking with rate tier logic - the rate drops when monthly hours exceed a threshold. Claude calculates this automatically from the time tracking CSV, warns when approaching the tier transition, and factors it into invoice scheduling.

Meeting capture follows a structured template. After I paste raw notes, a 10-step cascade updates everything downstream. Nothing falls through the cracks because the system doesn’t rely on me remembering to update eight different files.

Deliverable deadline alerting - every deliverable has a due date. Claude checks these on every session start and flags anything due within 14 days. Not a calendar reminder I might dismiss. A proactive alert that appears in the status dashboard with context about what the deliverable is, who it’s for, and what dependencies remain.

Weekly cap monitoring - some engagements have weekly hour limits. Claude tracks cumulative hours within each billing week and warns when approaching the cap. This sounds trivial until you realize that manually tracking hours against a weekly limit while managing multiple concurrent projects burns real cognitive energy every single day. I’ve watched consultants blow past caps and have awkward conversations with clients about over-billing. Claude eliminates that entirely.

Headless mode pushes this even further. The -p flag runs Claude non-interactively for scheduled operations - daily CRM syncs, weekly status report generation, automated deadline monitoring. Claude works on your project even when you are not at the keyboard.

MCP connections tie it together. CRM, Google Drive, Slack, calendar - Claude checks and updates these automatically through Cowork’s connector directory. The boundaries between “AI tool” and “project infrastructure” dissolve completely.

The result is a consulting engagement where the AI isn’t a tool I use occasionally. It’s a team member that maintains project state, tracks every detail, and handles the administrative burden that normally consumes half the hours in a week. When I compare the enterprise capabilities of Claude Code to other AI coding tools, the project management layer is what actually differentiates it - not the code generation.

These patterns didn’t come from documentation. They came from running real multi-stakeholder consulting engagements where getting details wrong costs real money and damages real relationships. Claude Code and Cowork together aren’t chat tools. They are a project operating system.

If you want help structuring Claude Code or Cowork for your projects - whether consulting engagements, product development, or operations - I work with teams as an AI consultant to set up exactly these kinds of systems. The value isn’t in the tool setup. It’s in the project structure and AI strategy that makes the tools actually useful.