1. Why Claude Is More Than a Chatbot
The defining mistake businesses make with Claude is treating it like a smart chat interface. Individuals save time, but the trajectory of the team does not change.
High-performing teams approach Claude differently. They treat it as a workflow system.
They do not ask Claude to write a single email from scratch. Instead, they build a Project with brand voice guidelines, connect it to CRM context, and set up repeatable Skills that turn meetings, customer notes, and account history into useful follow-up.
The difference is compounding value. A chatbot resets to zero every time you open a new window. A workflow system accrues context, skills, and integrations over time.
This guide maps the six stages organisations go through to get there and provides the prompts and structures to move your team up the ladder.
2. The 6-Stage Maturity Model
In the deployments we work on, adoption tends to follow a six-stage progression.
Many teams plateau at Stage 2 — moving past it requires a shift from individual habits to team operations, which is a different problem from learning to prompt better.
Chatting
Turn-by-turn interactions. High individual value, zero team leverage.
Creating
Producing durable artifacts, documents, and code one-offs.
Organising
Projects and knowledge bases. Claude now has persistent context.
Repeating
Packaging workflows into Skills. Predictable inputs yield predictable outputs.
Connecting
Claude reads from and writes to your business tools directly.
Delegating
Agentic automation. Claude executes multi-step tasks with Cowork or Code.
Stage 1 — Chatting: Make Every Prompt Count
Turn-by-turn prompts. It works, but it doesn't compound.
This is where everyone starts. The user types a question, Claude returns text. The problem at Stage 1 isn't that the outputs are bad; it's that getting good outputs requires writing long, complex prompts from scratch every time.
How it works (when done well)
Even at Stage 1, the difference between a frustrating hallucination and a useful draft comes down to prompting discipline. We train teams on the ICC framework:
- Instructions: What are you actually trying to achieve?
- Context: Who are you, who is the audience, and what happened before this?
- Constraints: Length limits, format requirements, tone guidelines, and things to avoid.
Stage 1 — Copy-ready prompts
I need you to help me with [task].
Context:
- I am [role]
- The audience is [audience]
- The goal is [goal]
- The current situation is [situation]
Constraints:
- Format: [format]
- Length: [length]
- Tone: [tone]
Before you produce anything, ask me 3 clarifying questions that will make your output significantly better.I'm about to ask you to draft a [document type] about [topic].
Before you draft anything, use web search to look up the current state of [topic]. Summarise the leading frameworks, accepted terminology, and any recent changes in the last 6 months.
I will then tell you how I want to apply this context to my specific situation.Look at this draft [document].
I want you to aggressively critique it against these criteria:
1. Is the argument actually sound?
2. Is the tone appropriate for [audience]?
3. What is confusing or assumed?
Do not rewrite it for me. Instead, group your feedback into:
- What is working well
- What is risky or weak
- The top 3 things I must change before sending⚠️ Stuck at Stage 1?
If your team complains that "Claude doesn't sound like us," they are stuck at Stage 1. They are fighting the model's default tone every single chat. The fix is Stage 3.
Stage 2 — Creating: Artifacts and Outputs
Producing structured documents, code, and dashboards you can actually use.
Stage 2 is when you stop using Claude to think and start using it to make. You move from conversational text in a chat window to durable files, visual dashboards, structured code, and complex formatted documents.
How it works
This stage unlocks when users discover three specific Claude features:
- Artifacts: Claude can generate interactive content in a dedicated side-panel — code snippets, Mermaid diagrams, React components, and SVG graphics. Instead of explaining a dashboard, it builds the dashboard.
- File processing: Uploading heavy PDFs, massive spreadsheets, or messy transcripts and asking for structured outputs.
- Research / web search: Using Claude to find up-to-date context before generating documents.
- Visual analysis: Uploading screenshots, charts, or diagrams and asking Claude to extract the data or critique the design.
Stage 2 — Copy-ready prompts
I have attached a CSV of our [sales/marketing/ops] data.
Build an interactive dashboard using an Artifact to help me make sense of this.
Include:
- Top-line metrics at the top
- Trend charts over time
- Highlight any anomalies
- A summary of what has changed versus the previous periodAttached are [number] customer feedback transcripts.
Process these and output:
- The top 5 recurring themes by frequency, with an exact quote for each
- The general sentiment split
- The three things we need to fix first based on this data
- Three unexpected opportunities mentionedUse research mode to produce a briefing on [topic / competitor / market].
I need:
- The current state of the market in 2 paragraphs
- The 5 players that matter and how they differ
- Recent moves in the last 6 months
- What this likely means for a [our type of business]
- Open questions worth investigating further
Cite every claim. Flag anything you're unsure about.Produce a [PowerPoint deck / Word document / spreadsheet] for [purpose].
Inputs: [paste or attach]
Audience: [who will read it]
Length: [pages/slides]
Tone: [tone]
Structure: [outline]
Output as a downloadable file. Use clean formatting and no filler slides.⚠️ Stuck at Stage 2?
This is where teams produce strong one-offs but never reuse them. If you're rebuilding the same dashboard or briefing every quarter, you're ready for Stage 3.
Stage 3 — Organising: Projects as a Shared Brain
Claude stops starting from amnesia. It remembers who you are and how you work.
A Project in Claude is a self-contained workspace with its own custom instructions, knowledge base, and chat history. Every conversation in the project inherits that context automatically.
Anatomy of a well-built Project
A working Project has three pieces:
- Instructions: context about the work, audience, tone, formats, and rules. Treat this as a one-page brief Claude reads before every conversation.
- Knowledge base: uploaded reference material: brand guidelines, product docs, SOPs, examples of past good work, style guides, pricing, ICP definitions, customer personas, contract templates.
- Chat history: every conversation lives inside the project, so context accrues over time and the team can see prior work.
Marketing project
- Instructions: brand voice, ICP, positioning, what we never say, channel strategy.
- Knowledge: brand book, last 12 months of best-performing content, persona docs.
- Use cases: campaign briefs, ad copy variants, content calendars.
Sales project
- Instructions: sales motion, qualification model, pricing logic, objection handling.
- Knowledge: case studies, battlecards, competitive comparisons, win/loss notes.
- Use cases: pre-call prep, follow-up drafting, RFP response, deal-desk analysis.
Stage 3 — Copy-ready prompts
Help me write the instructions for a Claude Project for [function].
Ask me about:
- Who the project is for and what work happens inside it
- The voice, tone, and formats we use
- The rules, constraints, and things you should never do
- The reference material I should upload to the knowledge base
After interviewing me, output a clean, well-structured set of project instructions I can paste in.You're operating inside a Claude Project for [function]. Based on the instructions and knowledge base loaded, tell me:
- What context you have
- What's missing that would make your answers materially better
- The 5 things I should add to the knowledge base before our next sessionUse the project knowledge base. Don't make up details — if something isn't in the project files, ask.
Task: [specific task]
Before you start, summarise the relevant context you're using from the project. Then complete the task.⚠️ Stuck at Stage 3?
The most common failure isn't building Projects; it's keeping them current. Set a 30-minute monthly review or the knowledge base goes stale and trust erodes.
Stage 4 — Repeating: Skills, the Most Underused Feature
Projects are reusable knowledge. Skills are reusable processes.
Projects make Claude remember things. Skills make Claude know how to do things. A Skill is a saved, repeatable workflow — a packaged process Claude can invoke when the relevant kind of task comes up. Note: Skill availability and behaviour vary by plan, region, and product version. Confirm what's available to your account.
Why Skills matter at the business level
Most operating know-how lives in three places: people's heads, scattered SOPs, and chat history. Skills give you a fourth location: a workflow Claude can run on demand, consistently, with the same logic each time.
- Onboarding compresses: new hires inherit the team's skills the moment they join the project.
- Quality variance drops: every run follows the same logic.
- Tribal knowledge gets captured: building a Skill is, by itself, a useful documentation exercise.
Business examples worth building first
Weekly leadership update — pulls from KPIs & trackers
Sales discovery summary — turns call notes into a brief
Customer health snapshot — synthesises CRM & tickets
RFP response drafter — applies tone & boilerplate
Incident post-mortem — produces consistent write-ups
Content repurposing — turns long-form into channel variants
Stage 4 — Copy-ready prompts
Look at this conversation. We just iterated together on [workflow] and arrived at a version of the output that works.
Turn this into a reusable Skill:
- Name and description
- Trigger conditions (when Claude should invoke it)
- Required inputs
- Step-by-step process
- Output format and quality bar
- Anything I should not do inside this skill
Output the full skill definition I can save.I want to build a Skill for [workflow]. Interview me to capture:
- The trigger
- The inputs
- The steps and the order they happen in
- Decision points and how to handle each
- The output format and what "good" looks like
- Any guardrails or escalation rules
Ask focused questions one at a time, then output the Skill definition.Here's our current Skill for [workflow]:
[paste]
Audit it. Tell me:
- Where the logic is unclear or contradictory
- Where the output quality bar is too vague
- What's missing that would cause an inconsistent result
- The smallest set of changes that would make this skill noticeably more reliableRun the [skill name] skill with these inputs:
- Input 1: ...
- Input 2: ...
- Input 3: ...
Before producing the output, summarise what you understand the inputs to be. If anything is missing, ask. Then produce the output.⚠️ Stuck at Stage 4?
Most teams know they have repeatable workflows but can't articulate them well enough to package. We do this in 60-minute working sessions per workflow.
Stage 5 — Connecting: Claude as a Workflow Hub
Claude reads your data directly, eliminating the copy-paste tax.
Connectors give Claude access to your tools and data — Drive, Slack, Calendar, common project management tools, meeting tools, presentation tools, and CRMs. Once connected, Claude can read information from those tools and take action. The available connector roster, supported actions, and required permissions all depend on plan, region, and product version.
Why connectors are an inflection point
Up to Stage 4, Claude is producing useful work about your business. From Stage 5, it's producing useful work inside your business.
- Less context-switching: The team doesn't shuttle screenshots and exports into Claude; Claude already has them.
- Shorter end-to-end cycle time: "Read the meeting notes, draft the follow-up, update the CRM, schedule the next session" becomes one prompt instead of four tools.
- Claude as a workflow hub: Instead of N tools each doing one thing, Claude becomes the surface where you orchestrate across them.
Common business connector patterns
Drive +
Slack
Stage 5 — Copy-ready prompts
Pull from my calendar, email, and project management tool.
Build my morning briefing:
- Today's meetings, ranked by importance, with a one-line prep note for each
- Anything overdue or blocked that I own
- Three messages I need to respond to today and a draft response for each
- One thing I should be thinking about that nobody else is going to flag
Don't pad. Cut anything that doesn't deserve my attention.Pull the notes from the [meeting tool] meeting on [date] with [people].
Then:
1. Draft the follow-up email
2. Identify the action items, who owns each, and the due dates
3. Draft the team Slack update
4. List any items that should become tasks in [PM tool] — show me the list before creating anythingSearch Drive for all documents related to [topic / project / account] from the last [period].
Produce:
- A timeline of what's happened
- The current state of play
- Open questions I should resolve
- The 3 documents I should actually read, with a one-line "why"⚠️ Stuck at Stage 5?
Connector setup usually stalls on permissions and security review, not on the technology. We help teams scope this with their IT and security functions in a way that gets to live use without skipping due diligence.
Stage 6 — Delegating: Cowork and Code
Claude executes multi-step operational tasks autonomously.
Stage 6 is where Claude stops being a tool you ask things of and starts being something you delegate work to. Two agentic surfaces matter here. Both have plan, platform, and version dependencies.
Claude Cowork (Desktop)
An agentic experience that handles multi-step tasks: managing files, organising documents, working across applications. It is closer to an assistant you brief once and then let work.
- Folder organisation and document cleanup
- Cross-document analysis across local files
- Preparing batches of documents for recurring processes
Claude Code
An agentic development tool. The misconception is that "Code" means "for engineers." It does not. Non-technical operators routinely use it to build:
- Internal tools: small dashboards, lookup utilities
- Prototypes: interactive mockups for stakeholders
- Automations: scripts that run a repetitive task
When to use Chat, Cowork, or Code
| Surface | Best for | Avoid for |
|---|---|---|
| Claude Chat | Knowledge work, drafting, analysis, structured outputs, one-shot or iterative conversations | Multi-step tasks across local files; building software |
| Claude Cowork | Multi-step tasks across local files and apps; repeatable operational workflows | Anything requiring access to production systems or sensitive data without supervision |
| Claude Code | Internal tools, prototypes, automations, data utilities | Production code paths or sensitive systems without technical review |
Stage 6 — Copy-ready prompts
I need to prepare [type of documents] for [recurring process]. There are roughly [N] of them in [folder].
Walk through the folder. For each document:
- Verify it has [required elements]
- Flag anything that's missing, malformed, or out of date
- Output a summary table of what you found
- Suggest a corrected naming convention
Don't change any files. Show me the plan first; I'll approve before you act.Build a small internal tool for [purpose]. It should:
- Take [inputs]
- Do [logic]
- Output [format]
- Run on [my machine / a single page]
Keep it simple. No backend unless strictly needed. Show me the plan, then build it. I'll iterate with you in place.Look at this workflow: [describe].
Tell me honestly:
- Whether this is a candidate for delegation to an agent today, or whether the workflow needs more structure first
- The 3 things I'd need to do before delegating safely
- The smallest version of this workflow that would be safe to delegate as a starting point
- Where human review must stay in the loop, and why⚠️ A note on agentic readiness
The instinct after seeing Cowork or Code work is to delegate everything. Resist it. Agents extend high-quality systems; they do not compensate for missing ones. Most "agentic AI" failures are governance failures, not capability failures.
Ready to build a workflow system?
Book a Workflow Assessment. We'll map your business to the 6 stages and identify the highest-ROI workflows to build first.
9. Choosing the Right Claude Model or Plan
Anthropic offers multiple Claude models with different speed, capability, and cost trade-offs, and several plan tiers including consumer, team, enterprise, and developer/API options.
Specifics change frequently — model names, pricing, rate limits, and feature availability all evolve. Treat any specific number written in a guide as a snapshot in time. What is stable enough to plan around:
- Larger, slower models: for hard reasoning, long-context analysis, agentic work, or building things that have to be right.
- Smaller, faster models: for high-volume, lower-stakes tasks where speed matters more than absolute capability.
- Plan tiers: generally trade off included usage, available features (such as Cowork, Code, or larger context windows), and admin/governance capabilities suitable for teams.
- API access: available for developers looking to build custom integrations or applications powered by Claude.
Treat Anthropic's current pricing and model documentation as the source of truth. Run a short pilot before committing organisation-wide.
10. Governance, Privacy, and Risk
The faster Claude becomes useful inside the business, the more governance matters. Enterprise trust and privacy are critical considerations. Three principles cover most practical decisions:
- Treat AI outputs as drafts until proven otherwise. Anything that goes to a customer, a regulator, a board, or a payroll system gets human review until you have a documented workflow that has earned the trust to skip it.
- Be deliberate about what data Claude sees. The default should be: nothing regulated, nothing confidential to a third party, nothing that would be problematic if it appeared in a screenshot.
- Maintain an explicit policy. Even a one-page policy is materially better than nothing.
Governance Checklist
- We have a written, one-page Claude usage policy
- Data classifications are explicit (public / internal / confidential / regulated)
- Connector approvals go through IT or security review
- High-stakes outputs (contracts, financials, regulatory) require human review by name
- Cowork and Code use cases are scoped before authorisation
- New starters complete a 30-minute Claude onboarding before using it for work
- We review the policy quarterly
11. Business Rollout Playbook
Phase 1 — Pilot (Weeks 1–4)
Pick one workflow with clear pain, a willing operator, and a measurable output. Build the project, the prompts, and (if appropriate) the first skill. Document what works.
Deliverables: 1 Project, 3-5 prompts, baseline metrics.
Phase 2 — Team rollout (Weeks 5–10)
Take what worked in the pilot and roll it across the team. Pick three workflows at most, build the supporting projects and skills, and run practical training sessions.
Deliverables: 3 productionised workflows, team prompt library, usage policy.
Phase 3 — Organisation-wide (Weeks 11–24)
Now scale. Identify high-value workflows in adjacent functions, replicate the playbook, install governance, and integrate connectors that have passed review.
Deliverables: Connector inventory, ROI dashboard, cross-functional skills.
12. Measuring ROI
ROI on Claude is rarely one large saving — it's many medium savings in the same direction. Five categories cover most of the value teams realise:
ROI Formula Per Workflow
ROI ($) =(hours saved per cycle × cycles per year × loaded hourly cost)
+ (rework hours avoided × loaded hourly cost)
- (Claude licence cost + workflow setup time cost)
Note: Don't count time saved if it just becomes idle time. True ROI requires that time to be redirected to higher-leverage work.
13. Claude vs ChatGPT vs Copilot
| Tool | Core Strength | Where it falls short |
|---|---|---|
| Claude | Writing quality, long-document reasoning, and durable workflow systems (Projects/Skills). The most "thoughtful" reasoning engine. | Native image generation (at time of writing). Broad ecosystem integrations lag Microsoft slightly. |
| ChatGPT | Broadest native multimodal capabilities. Image generation, voice, and data analysis. Great for rapid brainstorming. | Writing can feel overly styled ("AI-sounding"). Projects/system features not as cleanly structured for teams. |
| Microsoft Copilot | Already embedded in the Office apps your team uses. Excellent for M365 specific tasks (summarising a Teams meeting, formatting Excel). | Underlying reasoning often feels less sophisticated than Claude or ChatGPT. UI can be disjointed across apps. |
14. Prompt Library
Thirty copy-ready prompts, organised by stage. The inline prompts above are part of this library; the additional ones below extend it.
Stage 1 — Chatting (5)
Help me with [task]. Context: [role, audience, goal, situation]. Constraints: [format, length, tone]. Before answering, ask any clarifying questions.Research [topic] using current sources. Summarise the leading frameworks, terminology, and recent changes. I'll apply this to my situation next.Critique this [draft]. Search the web for current best practice on [topic]. Be specific. Group as: working / risky / change first.Take the strongest argument against [position] and steelman it. Use named frameworks or sources. Then tell me which parts I should take seriously.Answer only based on the attached files and what we have discussed. If you have to guess or infer, say so explicitly and label the section 'inferred'.Stage 2 — Creating (5)
Build an interactive dashboard from this data. Top-line metrics, trend charts, anomalies, what's changed vs last period.Analyse this feedback. Top 5 themes by frequency with a quote each, sentiment, three things to fix first, three opportunities.Use research mode for a briefing on [topic]. Market state, players that matter, recent moves, implications, open questions. Cite every claim.Produce a [PowerPoint / Word / spreadsheet] for [purpose]. Inputs attached. Audience: [who]. Length: [N]. Tone: [tone]. Output as a downloadable file.Compare these two contracts. Highlight clause-level differences, risk asymmetries, and the three negotiation points that matter most for our side.Stage 3 — Organising (5)
Help me write the instructions for a Claude Project for [function]. Interview me about purpose, voice, formats, rules, and reference material. Output a clean instruction set.Inside this Project, what context do you have? What's missing that would materially improve your answers? List the 5 things I should add first.Use the project knowledge base. Don't make up details — if it isn't there, ask. Task: [task]. Summarise the relevant context first, then complete the task.Reread our ICP and persona docs. Pressure-test this [campaign / message / positioning] against them. Where does it land, where does it slip, and what would tighten it?You're onboarding a new [role] to this project. Build them a 1-page brief covering what we work on, our tone, our rules, our common workflows, and where to find what they need.Stage 4 — Repeating (5)
Turn this conversation into a reusable Skill. Name, description, trigger, inputs, steps, output format, guardrails.Interview me to build a Skill for [workflow]. Capture trigger, inputs, steps, decision points, output, and guardrails. Output the skill definition.Audit this Skill for unclear logic, vague quality bar, missing steps, and the smallest set of changes that would make it noticeably more reliable.Run [skill name] with these inputs. Summarise what you understand the inputs to be. If anything is missing, ask. Then produce the output.This Skill works for [base case]. Extend it to also handle [variant] without bloating the core path. Show me what changes.Stage 5 — Connecting (5)
Pull from calendar, email, and PM tool. Build my briefing: meetings ranked by importance, blockers I own, three messages needing response with drafts, one thing nobody else will flag.Pull notes from the [date] [meeting tool] meeting. Draft the follow-up, list action items with owners and due dates, draft the team Slack update, propose tasks for [PM tool] for review.Search Drive for documents on [topic / account] from the last [period]. Timeline, current state, open questions, the 3 documents I should actually read with one-line whys.Build my weekly update across Drive, calendar, and Slack: what shipped, what slipped, what's blocked, what changed for stakeholders. Two paragraphs and a bulleted action list.Pull notes, support tickets, and product usage for [account]. Produce: health rating, three good signals, three risks, the conversation I should have at our next QBR.Stage 6 — Delegating (5)
Walk through this folder. For each document, verify [criteria], flag issues, summarise findings, propose a naming convention. Show the plan; don't change anything yet.Build a small internal tool for [purpose]. Inputs, logic, output. Show the plan, then build. Iterate with me in place.Is this workflow ready for delegation? List the 3 things I'd need to do first, the smallest safe-to-delegate version, and where human review must stay in the loop.Build an interactive prototype for [feature/idea] as a single-page tool. The point is to test the experience with stakeholders, not to ship. Make it fast and clear.I'm about to migrate [thing]. Walk through the source, list every assumption that would break the migration, propose a sequenced plan, and flag the parts a human must do.15. Implementation Checklist
Foundations (before you start)
- Named executive sponsor and rollout owner
- One-page Claude usage policy approved
- Data classifications agreed
- Approved tool surfaces (Chat / Cowork / Code) documented
- Plan / licensing decision made for the first 90 days
Stage 1 — Chatting
- ICC framework adopted as the team standard
- Context Interview pattern in regular use
- Web search behaviour understood
- Common starter prompts shared across the team
Stage 2 — Creating
- At least 3 artifact patterns identified for the team
- File handling guidelines in the policy
- Research mode use cases agreed
- Visual analysis use cases identified
Stage 3 — Organising
- At least one fully-built Project per pilot function
- Project instruction template adopted
- Knowledge base ownership assigned
- Quarterly knowledge base review scheduled
Stage 4 — Repeating
- At least 3 candidate Skills identified per function
- First Skill built, named, and assigned an owner
- Skill review process documented
- Onboarding includes existing skills
Stage 5 — Connecting
- Connector approval process exists
- First connector reviewed by IT / security
- At least 2 cross-tool workflows live
- Connector inventory maintained
Stage 6 — Delegating
- Cowork use cases scoped and authorised
- Code use cases scoped and authorised
- Human review thresholds explicit
- Production-readiness criteria agreed for any agentic workflow
Measurement and governance
- Baselines set for the first 3 workflows
- ROI tracker maintained
- Quarterly governance review scheduled
- Adoption monitored at the user level
- Lessons captured in a shared retrospective doc
16. Frequently Asked Questions
17. Get Help With Implementation
The teams getting the most from Claude treat deployment as an operations discipline — clear workflows, sane governance, and a measurable rollout. That's what we do.
A focused conversation about where Claude fits in your business and how to get to value in 30 days, not six months.
Download the complete Kit with printable prompt sheets, skill design templates, ROI calculators, and policy templates.