Common Team Workflows

Claude CoWork shines when integrated into your team's daily processes. This lesson presents eight battle-tested workflows with step-by-step implementation guides, ready to adapt to your organization.

1. Sprint Planning with AI Assistance

Use Claude to analyze your backlog, estimate effort, identify dependencies, and generate sprint goals — turning a 2-hour meeting into a 30-minute focused session.

1. Prepare the Backlog Summary

   Before the sprint planning meeting, use the Jira integration to pull the current backlog into a CoWork conversation. Claude analyzes ticket descriptions, comments, and linked issues.

2. Generate Effort Estimates

   Ask Claude to suggest story point estimates based on historical data from your knowledge base. It considers similar past tickets and your team's velocity.

3. Identify Dependencies and Risks

   Claude maps dependencies between tickets and flags potential blockers, cross-team dependencies, and technical risks that could derail the sprint.

4. Draft Sprint Goals

   Based on the selected tickets, Claude proposes 2-3 sprint goals that align with your product roadmap and quarterly objectives.

5. Team Reviews in Real Time

   During the meeting, the entire team views the shared conversation. Members add constraints, adjust estimates, and Claude updates its recommendations in real time.

# Sprint Planning Assistant
# Integration: Jira
# Variables: {{sprint_number}}, {{team_velocity}}, {{backlog_items}}

You are helping the engineering team plan Sprint {{sprint_number}}.

Team velocity (last 3 sprints): {{team_velocity}} story points average.

Backlog items to consider:
{{backlog_items}}

Please provide:
1. **Recommended Sprint Scope**: Which items to include, totaling
   near our velocity target
2. **Effort Estimates**: Story points for each item with reasoning
3. **Dependencies**: Cross-item and cross-team dependencies
4. **Risks**: Potential blockers or unknowns
5. **Sprint Goals**: 2-3 measurable goals for this sprint
6. **Capacity Notes**: Flag if any items need specific expertise
   that may be constrained

Reference our architecture docs and previous sprint retro notes
for historical context.

2. Code Review Workflow for Teams

Augment human code review with AI-powered analysis. Claude provides a first pass on every PR, catching common issues before human reviewers spend their time.

1. Automatic PR Analysis

   When a PR is opened, the GitHub integration automatically triggers Claude to analyze the diff. Claude posts its review as a comment on the PR within minutes.

2. Standards Compliance Check

   Claude checks the code against your team's coding standards (loaded from the knowledge base), including naming conventions, error handling patterns, and documentation requirements.

3. Security Scan

   Claude identifies potential security issues: SQL injection risks, hardcoded credentials, insecure API calls, missing input validation, and OWASP Top 10 vulnerabilities.

4. Human Reviewer Focuses on Logic

   With style, standards, and security already covered, human reviewers can focus on business logic, architecture decisions, and design patterns.

5. Feedback Loop

   Reviewers can react to Claude's suggestions with "helpful" or "not helpful" to improve future reviews.

# .cowork/review-config.yaml
# Place this in your repository root

auto_review:
  enabled: true
  trigger: pull_request
  model: claude-sonnet-4-20250514

checks:
  - name: "Code Standards"
    knowledge_base_refs: ["coding-standards.md", "style-guide.md"]
    severity: warning

  - name: "Security Review"
    knowledge_base_refs: ["security-checklist.md"]
    severity: error

  - name: "Performance"
    knowledge_base_refs: ["performance-guidelines.md"]
    severity: info

  - name: "Test Coverage"
    check_new_functions_tested: true
    severity: warning

output:
  format: github_review_comment
  categorize: true  # Group by Must Fix / Should Fix / Consider
  include_praise: true  # Also highlight what's done well

3. Documentation Generation

Keep documentation up-to-date by generating it directly from code, conversations, and team knowledge. Claude produces first drafts that your team refines.

1. Identify Documentation Gaps

   Run the documentation audit command to find undocumented APIs, missing README files, and outdated guides.

2. Generate Initial Drafts

   Claude analyzes the code and generates documentation drafts including API references, setup guides, and architecture overviews.

3. Team Review

   Share the generated docs in a CoWork conversation for team review. Members add context, correct inaccuracies, and approve sections.

4. Publish and Sync

   Approved documentation is automatically synced to your documentation platform (Confluence, Notion, or GitHub Pages).

# Audit existing documentation
cowork docs audit --repo ./my-service
# Output:
# Undocumented endpoints: 12/45
# Outdated files (>6 months): 5
# Missing README: ./services/auth/
# Missing CHANGELOG: ./

# Generate API documentation from code
cowork docs generate --type api \
  --source ./src/routes/ \
  --output ./docs/api-reference.md \
  --format markdown

# Generate onboarding guide from existing docs + code
cowork docs generate --type onboarding \
  --knowledge-base "architecture,standards,setup" \
  --output ./docs/onboarding-guide.md

# Update existing docs based on recent code changes
cowork docs update --file ./docs/api-reference.md \
  --since "last-release" \
  --diff-only

4. Onboarding New Team Members

Give new hires an AI-powered onboarding buddy that knows your codebase, processes, and team norms. This dramatically reduces ramp-up time and the burden on existing team members.

1. Create an Onboarding Conversation

   When a new team member joins, create a dedicated onboarding conversation pre-loaded with your team's knowledge base. The new hire can ask Claude any question about the codebase, processes, or team culture.

2. Guided Learning Path

   Claude walks the new hire through a structured onboarding checklist: setting up their development environment, understanding the architecture, and making their first contribution.

3. Codebase Exploration

   The new hire can ask questions like "How does authentication work in our system?" or "Walk me through the deployment pipeline" and get answers grounded in your actual documentation.

4. Mentor Check-ins

   Their assigned mentor can view the onboarding conversation to see what questions have been asked and where the new hire might need additional human guidance.

# New Team Member Onboarding
# Category: Operations
# Variables: {{new_hire_name}}, {{new_hire_role}}, {{team_name}}

Welcome {{new_hire_name}} to the {{team_name}} team!

You are an onboarding assistant for a new {{new_hire_role}}.
Use the team knowledge base to answer questions accurately.
When you're unsure, say so and suggest who on the team to ask.

Your priorities:
1. Help them set up their development environment
2. Explain our codebase architecture at a high level
3. Walk through our development workflow (branching, PRs, deploys)
4. Introduce key systems, services, and their owners
5. Point to relevant documentation for deep dives

Onboarding checklist to track:
- [ ] Dev environment set up and running locally
- [ ] First successful build and test run
- [ ] Understand the service architecture diagram
- [ ] Review coding standards document
- [ ] Set up access to all required tools
- [ ] Complete first "good first issue" ticket
- [ ] Attend first sprint planning/standup

Be patient, thorough, and encouraging. Reference specific
files and documentation when possible.

5. Incident Response with AI

During incidents, every minute counts. Claude CoWork provides an AI incident co-pilot that helps diagnose issues, suggest mitigations, and draft communications — all while maintaining a complete audit trail.

1. Incident Triggered

   When an alert fires, CoWork automatically creates an incident conversation and loads relevant runbooks from the knowledge base. The on-call engineer is notified.

2. Rapid Diagnosis

   Paste error logs, metrics, or stack traces. Claude cross-references them with your architecture docs and past incident reports to suggest root causes.

3. Mitigation Suggestions

   Based on your runbooks and the diagnosed issue, Claude suggests specific mitigation steps in order of impact and risk.

4. Status Updates

   Claude drafts status page updates and stakeholder communications. The incident commander reviews and posts them, saving valuable time during active incidents.

5. Post-Incident Report

   After resolution, Claude generates a post-incident report from the conversation timeline, including root cause, timeline of events, actions taken, and follow-up items.

# Incident Response Co-Pilot
# Category: Operations | Priority: Critical
# Auto-triggered by: PagerDuty/OpsGenie integration

You are an incident response assistant for the engineering team.

Current incident:
- Alert: {{alert_name}}
- Service: {{affected_service}}
- Severity: {{severity}}
- Started: {{start_time}}

Reference our runbooks and architecture docs. For each step:
1. Explain WHAT to check and WHY
2. Provide the exact commands to run
3. Explain what the output means
4. Suggest next steps based on findings

Communication templates needed:
- Initial status page update (within 5 min)
- Stakeholder email (within 15 min)
- Resolution update (when fixed)

IMPORTANT: Always recommend safe, reversible actions first.
Flag any destructive operations clearly.

6. Research and Analysis Pipelines

For teams that need to analyze data, research competitors, or evaluate technologies, CoWork provides structured research workflows that produce thorough, well-organized reports.

1. Define the Research Question

   Start a shared conversation with a clear research question and scope. Include constraints like timeline, budget, and decision criteria.

2. Structured Analysis

   Use a research template that guides Claude through systematic analysis: defining criteria, evaluating options, identifying trade-offs, and summarizing findings.

3. Team Input

   Team members add their domain expertise, challenge assumptions, and request deeper analysis on specific areas.

4. Final Report

   Claude compiles all findings into a structured report with executive summary, detailed analysis, recommendations, and appendices.

# Technology Evaluation Framework
# Variables: {{technology_options}}, {{evaluation_criteria}}, {{context}}

Evaluate the following technology options for our team:
{{technology_options}}

Evaluation criteria (weighted):
{{evaluation_criteria}}

Context: {{context}}

For each option, provide:
1. **Overview**: What it is and how it works
2. **Pros**: Advantages specific to our context
3. **Cons**: Disadvantages and limitations
4. **Cost Analysis**: Licensing, infrastructure, training costs
5. **Migration Effort**: What it takes to adopt
6. **Risk Assessment**: Technical and organizational risks
7. **Team Fit**: How well it matches our skills and culture

Conclude with:
- **Recommendation Matrix**: Options scored against each criterion
- **Top Recommendation**: Your suggested choice with reasoning
- **Decision Criteria**: What factors would change the recommendation

7. Content Creation Workflows

Marketing teams, developer advocates, and technical writers use CoWork to produce consistent, high-quality content with AI assistance and team review baked into the process.

1. Content Brief

   Start with a content brief template that defines the audience, goals, key messages, tone, and SEO requirements.

2. AI-Assisted Draft

   Claude generates a first draft based on the brief and your brand voice guidelines (stored in the knowledge base).

3. Collaborative Editing

   The team reviews the draft in a shared conversation. Writers refine messaging, subject matter experts verify accuracy, and legal reviews compliance.

4. Final Review and Approval

   Use the review workflow to get formal approval from stakeholders before publishing.

8. Customer Support Escalation

When support tickets require engineering involvement, CoWork bridges the gap between support and engineering teams with AI-assisted triage and context transfer.

1. Ticket Triage

   When a support ticket is escalated, Claude analyzes the customer's issue against known bugs, documentation, and past support conversations to provide initial diagnosis.

2. Context Packaging

   Claude compiles a summary for the engineering team: customer impact, reproduction steps, relevant logs, similar past issues, and suggested investigation areas.

3. Engineering Investigation

   Engineers investigate in a shared conversation, with Claude providing code context, suggesting debug approaches, and referencing architecture documentation.

4. Resolution and Knowledge Capture

   Once resolved, Claude drafts a customer response, updates the knowledge base with the fix, and creates a runbook entry if the issue could recur.

# Support Escalation to Engineering
# Variables: {{ticket_id}}, {{customer_tier}}, {{issue_description}},
#            {{reproduction_steps}}, {{customer_logs}}

## Escalated Support Ticket: {{ticket_id}}
**Customer Tier:** {{customer_tier}}

### Issue Description
{{issue_description}}

### Reproduction Steps
{{reproduction_steps}}

### Customer Logs
{{customer_logs}}

Please provide:
1. **Initial Diagnosis**: Based on the symptoms and our codebase
2. **Similar Past Issues**: Check knowledge base for related tickets
3. **Investigation Plan**: Ordered list of things to check
4. **Customer Impact Assessment**: Scope and severity
5. **Workaround**: Any temporary fix we can offer the customer
6. **Draft Customer Response**: For the support team to send

Priority based on customer tier and impact scope.

Choosing the Right Workflow

Use this reference table to match your team's needs to the right workflow template: