If a team asked us how to start using Claude Cowork at work, we would not start with a platform diagram. We would say this: you probably do not need a custom app yet. Buy the subscription, set up a few good skills, run them against real work, and see what sticks. That is the honest first move.
If Claude is new to you, here is the short version. Claude is Anthropic's AI assistant. The chat box is the easy part. The reason it is worth your attention is the skills you can give it, plus its ability to work directly on your computer with your real files and apps.
A paid Claude subscription, Cowork, and a solid set of skills can get most businesses surprisingly far. Cowork is the workspace: files, folders, connectors, long-running tasks, sub-agents, scheduled work, projects. Skills are the part most people skip past, and they are the part that actually does the job. They tell Claude how your business wants work done.
People see the new workspace and ask, "Should we build our own?" Sometimes the answer is yes. We build custom deployments when a team needs private infrastructure, custom auth, a branded interface, unusual data flows, or a workflow that does not fit a hosted product. But if the real question is "how do we start getting useful agent work done?", Cowork plus a few good skills is the first answer we would try.
What changed with Cowork
Cowork takes the Claude Code style of work and brings it to Claude Desktop for knowledge work. Instead of asking Claude to tell you what to do, you can ask it to do the work: organize files, draft documents, build spreadsheets, synthesize research, run a longer task in the background, or coordinate a few workstreams at once.
That is a real shift, but the part that matters is more boring than it sounds. Cowork makes the shell easy to get. Your team does not have to build a custom mini-workspace just to let an agent touch local files, run a multi-step task, and come back with a finished output. The room is already built.
The shell is just the room, though. The skills are the working habits you teach Claude inside it.
We built TaskFox before Cowork existed
TaskFox is our agent skills factory. We built it before Claude Cowork existed because we needed Claude to actually do work, not just describe it. The useful piece is not the shell. It is the skill library that has grown inside it.
To make that concrete: TaskFox runs a daily AI dev-news brief, a multi-stage articles workflow (the same one used for this article with Codex and Claude Code in the loop), a code council that polls Claude plus Codex plus Gemini for architecture decisions, a guarded autoresearch loop, a video logger that turns recordings into transcripts and shot notes, a TTS narrator, an image generator, a deep-research skill, a knowledge-base manager, and dozens of smaller daily jobs. Different jobs. Same shape: a packaged skill that knows how the work should be done.
The useful lesson was not "everyone needs a TaskFox clone." It was the opposite. Once you have a strong runtime, the layer that earns its keep is the skill library. The same newsletter, research, review, or artifact workflow can run inside a custom system, inside Claude Code, or inside Cowork if the skill is packaged well.
That is why Cowork matters. It does not retire custom deployments. It just makes them less necessary as a starting point. More teams can begin with the hosted workspace and spend their energy on the part that keeps improving: the skills.
Three systems, one pattern
The same shape shows up everywhere we look. Different runtimes, different shells, different audiences. The skill layer is always where the business logic actually lives.
TaskFox is the one we can talk about openly. It has a deep skill library plus the supporting agents, commands, hooks, and pipelines that hold it together. The point is not that every business should copy the stack. The point is the skills are what make the stack worth running. A research skill knows how to gather sources. A newsletter skill knows the voice and format. A review skill knows the quality bar to enforce. A video skill knows how to turn raw recordings into usable notes.
The private workspace example makes the same point from the other side. The custom app earns its keep because of auth, file persistence, and a focused user experience. But the business value comes from the skills inside it: use the right knowledge base, follow the right messaging, ask for missing context, produce a draft that a real team can edit.
The guided use-case generator shows it again. The product is not one giant prompt. It is a staged workflow: clarify the request, rewrite it into a usable brief, research the context, build an outline, draft the use case, write the walkthrough, polish against a standard. Each stage is a skill-shaped piece of work.
Different apps. Same lesson.
Cowork makes skills easier to use
This is the part worth underlining. Anthropic did not just ship a place for Claude to run tasks. Cowork also has plugins, and the plugin model is the practical bit: a plugin can bundle skills, connectors, and sub-agents into one installable package.
The everyday version of that is great. Nobody has to tell every person on the team, "Go set up these six things, paste this giant prompt, and remember these three review rules." You package the workflow once. People install the plugin. They use the skill from Cowork. You improve it as the work changes, and everyone gets the upgrade.
And because skills are reusable capabilities, the investment is not trapped in one surface. A good skill can guide Claude in Cowork today, in Claude Code tomorrow, and inside an API-backed workflow later if you outgrow the hosted workspace. The runtime moves. The skill stays.
What a useful skill looks like
A skill is not a fancy prompt. A useful skill is closer to a small operating manual for a job you keep doing.
| Part | Plain-English job | Why it matters |
|---|---|---|
| Trigger | Tells Claude when to use the skill. | The user should not have to remember the whole workflow every time. |
| Instructions | Explains the steps, standards, and expected output. | This is where your team's way of working becomes repeatable. |
| References | Carries examples, templates, rubrics, and background docs. | Claude should use the known pattern instead of guessing from memory. |
| Scripts | Runs deterministic steps when code is better than prose. | Good automation should not rely on the model for everything. |
| Review loop | Defines what "good" means and how to check it. | This is how the skill improves instead of becoming stale instructions. |
Take our newsletter skill as a worked example. The trigger is "build today's TaskFox brief." The instructions tell Claude how to source the day's items, what tone the brief uses, and how the visual layout works. The references include past briefs we like, a voice guide, and a small list of phrases we ban (em dashes, "delve", that kind of thing). The scripts pull metrics, render the visual HTML, and stage the artifact. The review loop checks for missing sections, banned phrases, broken links, and stale references before anything goes out. It is not magic. It is a packaged way of doing a real job.
For a marketing team, that might be a campaign brief skill, a case-study skill, a brand-review skill, and a weekly-performance summary. For operations, it might be an invoice review skill, a vendor comparison, a meeting synthesis, a spreadsheet cleanup. For a founder, it might be a research skill, an investor update, a product spec, a support triage.
The names are less important than the shape. Pick recurring work. Package the way you want it done. Give Claude the files and examples it needs. Run the workflow enough times to tighten it.
Where custom apps still make sense
We should not overcorrect. Custom deployments still earn their cost. We build them for real reasons.
If you need strict user boundaries, custom authentication, persistent project storage, a branded interface, unusual cloud infrastructure, or a workflow that has to live outside someone's desktop, a custom deployment can be the right move. The private workspace pattern is real. The guided workflow app pattern is real. TaskFox itself is real.
But those are rarely phase one. For most teams, phase one should be: buy the tool, connect the right folders and apps, build the first five skills, and see which workflows actually stick.
That approach is cheaper and faster, and it teaches you what a custom deployment would need to do if you eventually build one. You get the workflow truth before you pay for the shell.
What we would do first
If you are looking at Cowork this week, we would keep the plan very small.
- Pick three recurring jobs that are annoying but not regulated or dangerous.
- Write down what a good output looks like for each one.
- Collect two or three examples of past work Claude should imitate or improve.
- Turn each workflow into a skill with a clear trigger, instructions, references, and review checklist.
- Run the skills in Cowork with "Ask before acting" until you trust the pattern.
- After every run, update the skill with what you learned.
That is it. No grand transformation program. No six-month platform evaluation. Just three jobs, three skills, and enough repetition to see whether Claude is doing useful work or only producing impressive demos.
If you asked us
If a team came to us this week and said, "build us a custom agent app for the business," our honest answer would be: you probably do not need a custom app yet. You probably just need a paid Claude subscription, the Claude Desktop app with Cowork turned on, and a serious set of skills. Run that for a quarter. See which workflows actually stick. Then talk to us about a custom build, with real evidence in hand.
OpenAI is going down the same road. Their answer to Cowork is making the Codex desktop app good for everyday knowledge work, not just code. Worth watching, and the same lesson lands either way: the desktop runtime is the easy part to ship. The power comes, in part, from the skills running inside it.
Skills are also why this article exists. TaskFox, our agent skills factory, ran a stack of them to help Casey write it: a research skill that pulled the source material, a drafting skill that knew the voice and structure, a visuals skill that produced the diagrams you have been reading, and a review skill that pushed back on anything that drifted into pitch-deck language. We are not handing over the recipe, but the shape is the point. Many small skills, each doing a real job, composed into one workflow.
So yes, custom deployments are great when you actually need them. But for most teams, a Claude subscription, Cowork, and a skill library you keep sharpening is genuinely all you need to start.
We built most of this the hard way, so if you are starting out and want to borrow from what worked, feel free to reach out.