Claude Cowork like a deliverables factory

Article published in June 2026, updated on September 27, 2026: Cowork It now runs in the cloud and has merged with the chat. Memory usage, scheduled tasks, permission modes, plugins, and the compliance API have been updated.

In our first article, we showed how to configure Claude Cowork so that he would stop producing generic content and start working as if he knew you. That was the foundation, of which our Cowork It revisits the principles. This article is for those who have already asked the question and want to take the next step: no longer utiliser Cowork task by task, but transform it into production system.

The shift is subtle but decisive. An intermediate user opens Cowork and requests a deliverable. An advanced user designs a production chain that manufactures this deliverable repeatably, with consistent quality, minimal human intervention—and improves with each iteration. The difference between the two is not the skill of promptingThat's architecture.

Let's see how to build it.

Changing mental models: from the prompt to the system

As long as we reason in promptsWe've reached a plateau. A good prompt produces a good deliverable once. A system, on the other hand, produces the good deliverable. Everytime, even when you're not there to pilot it.

A deliverables factory relies on five components, which must be clearly distinguished because they are often confused:

• Skills — the basic building block. A Markdown file that teaches Claude how to do a specific thingIt activates automatically when the context warrants it.
• Slash Commands — shortcuts that you trigger manually, during the task, to launch a defined workflow.
• Sub-agents — specialized agents that Claude mobilizes, often in parallel, to deal with isolated sub-tasks.
• Plugins — complete packages that group skills, connectors, commands and sub-agents for a given business function.
• The Projects — the persistent workshop: a space that stores files, instructions and memory from one session to the next.

Remember this image: the base of Cowork is a competent general practitioner. These components make him a specialist who already knows your field — your tools, your vocabulary, your processes.

Let's examine each brick, from the finest grain to the overall orchestration.

Skills: Encoding your know-how in files

The Skill is the unit of production. In practical terms, it's a simple Markdown file that encodes expertise: a best practice, a format, a sequence of steps. It triggers automatically as soon as the current task makes it relevant—you don't have to remind it.

The distinction that changes everything, highlighted by the power users : In the chat, skills were useful; in CoworkThey become operational. Because Cowork It actually acts on your files; a Skill no longer just advises — it executes according to your method.

What a good skill should encode

For a deliverable factory, your most profitable Skills are those that capture your output standards :

• Your templates. The exact structure of a summary note, a report, a client preparation file. Sections, order, target length.
• Your brand voice. The tone, the level of formality, the formulations to favor and to avoid.
• Your quality criteria. A checklist that Claude applies before delivering: "the summary does not exceed one page", "each recommendation is supported", "no undefined jargon".
• Your business rules. The constraints specific to your sector, particularly in a regulated environment.

How to write them (without coding)

You don't need to be a developer. Two paths:

1. The interview. Ask Claude to quiz you on how you produce a particular type of deliverable, then write the Skill file based on your answers. This is more accurate than writing from memory—where you're always describing an idealized version of yourself.
2. The Skill Creator. Anthropic provides a dedicated tool and a proven framework for creating Skills step by step, testing, refining and debugging them.

The context budget trap

One point that only advanced users are aware of: Your Skills share a context budget, on the order of 2% of the context window. In practice, this is rarely reached. But if Claude starts behaving as if he had forget it The fact that a Skill exists is probably the cause. The solution: segment ("chunk") your Skills into targeted modules rather than piling everything into a monolithic file, and only load what is actually needed.

Slash Commands: your production buttons

Where Skills operate in the background, Slash Commands are... quick actions that you trigger on demandThink of them like the buttons on your production line: you type /You start the flow, you stay in the movement — without changing tools or losing context.

Their interest in the factory: standardizing the triggers. Rather than having to explain each time, "Prepare a file for me for this appointment," you type /prep-rdv and the entire workflow kicks in. The official plugins already expose these types of commands (for example, a sales call preparation command, or a data query writing command), and you can use them. rename according to your internal terminology — transform a generic command into /note-client so that it speaks the language of your teams.

Sub-agents: parallelization, or how to divide time

This is where the factory truly shines. Rather than processing your requests one by one, Cowork peut distribute the work among several sub-agents operating in parallel, each in its own isolated context.

The benefit is tangible. A frequently cited test result: processing ten files in parallel rather than one by one reduces the wait time from approximately thirty minutes to four minutes. For recurring, high-volume production, the effect is significant.

Two orchestration schemes to be aware of:

• The parallel. Several sub-agents simultaneously process independent elements — ten reports, twenty index cards, a series of documents to analyze. Each returns with their result.
• The sequential. For a multi-stage workflow, sub-agents are chained together: one gathers the context, the second writes, and the third checks the quality. Each sub-agent completes its task and passes the essential information on to the next.

When should you use a sub-agent instead of a skill? The rule of thumb: use a sub-agent when the task produces a lot of intermediate output that you don't need In the main thread, use a Skill when it's standalone and can return a simple summary, or when you want to impose restrictions on specific tools. Prefer a Skill when you want a reusable flow that runs within the main context of the conversation.

Things to keep in mind: A sub-agent starts "cold" and sometimes needs time to gather its context. Parallelization pays off on volume, not on micro-tasks.

Plugins: assembling a business function into a package

If Skills are the building blocks, the Plugins These are the prefabricated walls. A plugin groups together in a single package all the skills, connectors, slash commands, and sub-agents necessary for a job function precise. You install it once, and Claude immediately knows the best practices, tools, and commands for this role — without having to re-explain your workflow at each session.

It is the most structuring component for an organization, because it transforms an individual configuration into team standard.

Starting from what already exists

Anthropic has open-sourced eleven plugins, developed from its own use cases, into a public repository dedicated to knowledge sharing. These plugins cover functions such as productivity (task management, calendars, personal context), company search (finding information across your tools and documents), plugin creation and customization, sales (lead generation, deal preparation), and finance (analysis, modeling, and KPI tracking). You can install them directly from [website/platform name]. Cowork, from the website, or from GitHub. Once installed, they activate automatically: the skills are triggered when relevant, the commands become available in the session.

The plugins are available in Cowork for all paid subscriptions (Pro, Max, Team and Enterprise). On Team and Enterprise, administrators can also distribute them to their teams from an internal catalog, making them available, installed by default or mandatory.

The real value: personalization

The official plugins are written for generic use. Most teams need to adapt them—and that's where the value lies. Since each component is a simple file (Markdown for skills and commands, JSON for connectors), common customizations are within your reach:

• Rename the commands to fit with your internal vocabulary.
• Inject your company context in a Skill file: your brand voice, your validation workflow, your document templates.
• Point the connectors to your instances : the default connector assumes a generic configuration, yours may have its own custom objects or test environment.
• Remove unwanted capabilities : if a team does not need to have the sub-agent who writes external communications, we simply delete the corresponding file.

Build your own

Beyond adaptation, you can create your own plugins. Two approaches: use the plugin dedicated to creating/managing plugins, or simply to have a detailed conversation with ClaudeLet him interview you about your use cases and generate the plugin. Since plugins are simply Markdown files, you version, share, and develop them like any other document asset.

Safety — an essential reflex: favor plugins bearing the badge "Anthropic Verified"which have undergone quality and safety review. For any community plugin, examine the source code and permissions before installation. Trust is verified, not assumed.

The Projects: the workshop's memory

All of the above remains fragile without persistence: a factory that rediscovers its context at each session is not a factory. Cowork It now has two levels of memory. The account's memory, shared between the cat and Cowork Since August 25, 2026, it remembers who you are and how you work from one conversation to the next. The Project's Memory retains what is specific to a given construction site, and that is what counts for a production line.

A Project is therefore the foundation of your workspace. It retains its files, instructions, and memory across sessions. It's what allows your system to accumulate context instead of losing it. Before any serious recurring production, create a Project—and observe the difference: Claude no longer has to rediscover your context each time.

An additional advantage for industrialization: in a project, Claude can write directly into its instruction filesTell it "codify this principle" and it will write it down, without any manipulation. Your system documents itself as it is used.

Scheduled tasks: running the factory at night

A factory that only produces when a human presses a button isn't really a factory. scheduled tasks They are the night shift team for your channel.

You describe a recurring task once, and Cowork It executes automatically at the chosen frequency, leveraging all the context you've built — instructions, connectors, files. A competitive intelligence summary every morning, an activity recap every Friday, weekly meeting preparation: all these deliverables are generated without you.

To create one, type /schedule in any task, or open "Scheduled" in the sidebar.

The methodological advice of experienced practitioners runs counter to the enthusiasm: Don't automate everything at once. Start by only one Flow — meeting preparation, product monitoring, competitive analysis. Observe how it flows, adjust the tone to your preferences, then expand. Process Cowork less like a robot than like an assistant to whom tasks are gradually delegated.

What has changed for your design: since the passage of Cowork In the cloud, as of July 2026, scheduled tasks run on Anthropic's infrastructure, even when your computer is turned off or the application is closed. The only exception is a task that requires files or connectors located only on your machine, which necessitates that the desktop application be open on a powered-on computer. For these types of workflows, keep your source code in a project or behind a cloud connector, or allocate a dedicated, active workstation.

The continuous improvement loop: a factory that learns

This is the ultimate level of maturity, and what distinguishes a true factory from a simple set of automated systems: the system that improves with each pass.

The principle, observed in the most advanced systems, is this: each completed task reintroduces patterns, templates, and preferences into the system. The next time, on a similar task, the result is faster and more accurate because it has learned from the previous one. As you ask Cowork to remember things, it writes your preferences itself into its memory files — the more it writes, the better it works in your way.

In practical terms, to initiate this loop:

• After each deliverable, ask Claude what could be codified — a recurring format, a correction that you systematically make.
• When a pattern repeats itself, turn it into a rule in a Skill or instruction file. Do not create a file "just in case": create it when repetition justifies it.
• Keep a record ofsuccess stories (your best past deliverables) which the system takes as a quality reference.

An organization that adopts this approach sees its factory gradually become a cross-functional expert: the context defined once is reflected in every relevant interaction. Managers spend less time enforcing processes and more time improving them.

Powering the factory: connectors and live data

A production line needs raw materials. connectors give to Cowork Governed, real-time access to the data your deliverables need: discussion threads, documents, CRM records, tickets. Beyond that, the MCP applications go further by integrating a supplier's tools directly into Claude.

The most striking illustration comes from the financial sector, where Anthropic offers agent models that package skills, connectors, and sub-agents for standardized productions such as the construction of pitchbooksCompliance file filtering or monthly account closing — adaptable to each firm's specific agreements, risk policies, and validation processes. This is exactly the factory logic applied to deliverables with high regulatory stakes: the framework is packaged, the human element validates.

For teams working in the Microsoft suite, note that context is automatically passed between Excel, PowerPoint and Word once the modules are installed: work started in a template can be completed in a presentation without having to explain everything again between the two.

Quality control: the human remains in charge of the workshop

Industrializing does not mean dehumanizing. In any serious factory, there is a quality control position — and in a factory focused on deliverables, that position is you.

Cowork facilitates this supervision. When Claude writes a Markdown document, you can Highlight the passage you wish to modify, click on "Edit with Claude", and formulate your request. The correction is made at the exact spot, without having to describe the section in the thread. It's the equivalent of a touch-up at the end of the chain.

Some principles of quality governance for large-scale production:

• Permission mode adapted to the risk. Cowork We offer three options. Manual approval, where Claude asks for your agreement before each action, for new or sensitive flows; automatic approval, where Claude proceeds but each action is checked and those deemed dangerous are blocked, for proven chains; and the no-approval mode, where nothing checks the actions, to be reserved for situations without stakes that you actively supervise.
• Validation gates. Insert breakpoints into your workflows where a human validates the content before external distribution.
• QA checklists integrated into Skills, so that the control is applied by the system, not just on the system.
• Traceability. For Team and Enterprise teams, monitoring activity via OpenTelemetry provides an overview. On Enterprise, sessions Cowork sessions executed in the cloud (launched from the web, desktop application or mobile) are now captured by the compliance API; only the history of strictly local sessions remains stored on the machine.

The factory produces; humans decide what comes out.

Industrialization as an operational model

Building a deliverables factory isn't just about individual productivity. It's a change of operating model for the organization.

When an expert's know-how resides in a prompt, it dies with the session. When it resides in a Skill, a plugin, a shared Project, it becomes a company asset—reproducible, transferable, and improvable. That's the difference between a team that uses AI and a team that capitalizes with AI. The second transforms the tacit expertise of its best elements into a standard accessible to all.

This is why, in our work with large organizations, we treat the construction of these systems as a project in its own right, distinct from simple acculturation: identifying recurring, high-volume deliverables, mapping the know-how to be encoded, building the initial business plugins, establishing validation points, and implementing the continuous improvement loop. The technology is transmitted; what creates lasting value is the systematization of each business's production methods.

Finally, one recommendation that applies to all levels of maturity: start with a single chain. Choose the recurring deliverable that takes you the most time, build the factory around it from start to finish, measure the gain, and then replicate. A factory that operates on a continuous flow is more convincing than a large architecture that produces nothing.

Your roadmap to the factory

1. Define a Project dedicated to the type of deliverable you want to industrialize (it retains the memory specific to this project).
2. Encode your standards into skills. : templates, brand voice, quality criteria, business rules — by interview or via the Skill Creator.
3. Expose Slash Commands with descriptive names for your recurring triggers.
4. Mobilize the sub-agents to parallelize the volume and link writing and then checking.
5. Start with an official plugin, customize it to your vocabulary and circuits, then build your own.
6. Connect your connectors to feed the factory with live data.
7. Schedule the first recurring task — just one, to start with.
8. Install the improvement loop : after each deliverable, code what is repeated.
9. Install your QA doors and choose the permission method according to the risk.
10. Measure, then replicate on the following channel.

Sources. Claude Help Center (accessed September 27, 2026): Use Claude Cowork on web, desktop, and mobile, Claude Cowork and chat are one Claude, Use Claude's chat search and memory, Organize your tasks with projects, Schedule recurring tasks in Claude Cowork, Use Claude Cowork safely, Use Claude Cowork on Team and Enterprise plans.

To go further: the steps to configure Claude Cowork for the first time, ten use cases of Claude Cowork by job and to choose between Claude, ChatGPT or Copilot.