Presentation 8 of 10

Productivity & Workflows

Practical patterns for getting more done with Claude

Anthropic Claude Series

The Productivity Promise

AI assistants fundamentally change how we work, not just how fast.

Before Claude

Manual research across dozens of tabs
Blank-page syndrome for writing tasks
Line-by-line code review fatigue
Hours drafting boilerplate documentation
Context-switching between tools

After Claude

Synthesized research in seconds
Structured first drafts instantly
Automated review with explanations
Generated docs from code/specs
Single interface for many tasks

Key insight: The biggest gains come not from speed alone, but from eliminating low-value work so you can focus on high-value decisions.

Prompt Engineering Fundamentals

The four pillars of effective prompting:

Clear Instructions

Be specific about what you want
State the desired output format
Use imperative verbs: "Write", "List", "Analyze"

Provide Context

Who is the audience?
What is the background situation?
What prior knowledge applies?

Include Examples

Show input/output pairs
Demonstrate desired style/tone
Clarify edge cases with samples

Set Constraints

Length limits (words, paragraphs)
Things to avoid or exclude
Required sections or structure

// Bad:  "Write about databases"
// Good: "Write a 500-word introduction to PostgreSQL for junior developers.
//        Cover: what it is, key features, when to use it vs MySQL.
//        Tone: friendly but technical. Include a comparison table."

Advanced Prompting Techniques

Chain of Thought

Ask Claude to reason step by step before answering. Improves accuracy on complex problems.

"Think through this step by step
before giving your final answer."

Few-Shot Examples

Provide 2-3 input/output examples so Claude learns your pattern.

Input: "happy" -> Output: "joyful"
Input: "sad"   -> Output: "melancholy"
Input: "angry" -> Output: ?

Role-Playing

Assign Claude a persona to get domain-specific responses.

"You are a senior security engineer
reviewing this code for vulnerabilities."

Structured Output

Request specific formats: JSON, XML, Markdown tables, YAML.

"Return the analysis as JSON with
keys: summary, risks, recommendations"

The CRAFT Framework

A repeatable framework for constructing high-quality prompts:

C — Context

Background info, project details, constraints, audience. "I'm building a SaaS dashboard for enterprise clients..."

R — Role

Who should Claude be? "Act as a senior full-stack engineer with expertise in React and PostgreSQL."

A — Action

The specific task. "Review this function for performance issues and suggest optimizations."

F — Format

Desired output structure. "Return a numbered list with severity ratings (High/Med/Low)."

T — Tone

Communication style. "Be direct and concise. Use technical language appropriate for experienced developers."

Writing Workflows

Drafting

Outline first, then expand
Provide key points to cover
Specify word count & structure
Iterate section by section

Editing & Revision

"Make this more concise"
"Improve clarity of paragraph 3"
"Fix grammar, keep my voice"
"Simplify for a general audience"

Summarizing

Specify target length
Key points vs. executive summary
Bullet points vs. prose
Audience-appropriate detail level

Translating

Natural-sounding translations
Preserve tone and cultural context
Technical term consistency
Side-by-side comparison review

Technical Writing

API documentation from specs
User guides from feature lists
Release notes from changelogs
Runbooks from architecture docs

Coding Workflows

Bug Fixing

Paste error + relevant code. Ask Claude to identify the root cause, explain why, and provide the fix.

// "Here's the error trace and the
// function. Find the bug and fix it."

Feature Development

Describe the feature, provide existing patterns from your codebase, and let Claude generate consistent code.

Code Review

Paste a diff or function. Ask for security, performance, readability, and maintainability feedback.

Refactoring

Extract methods/functions
Reduce complexity
Apply design patterns
Modernize syntax

Test Generation

Unit tests from functions
Edge case identification
Integration test scaffolds
Mock/stub generation
Property-based test ideas

Research & Analysis

Document Analysis

Extract key findings from papers
Compare multiple documents
Identify contradictions
Create annotated summaries

Data Extraction

Pull structured data from prose
Convert tables between formats
Parse unstructured logs
Normalize inconsistent data

Literature Review

Summarize related work
Identify research gaps
Compare methodologies
Generate bibliography entries

Data Analysis

CSV & Spreadsheet Analysis

Paste data directly or describe schema
Ask for statistical summaries
Identify outliers and trends
Generate pivot table logic

Prompt: "Analyze this sales CSV. Find
top 5 products by revenue, monthly
trend, and any seasonal patterns."

Visualization Generation

Generate Python matplotlib/seaborn code
Create D3.js or Chart.js configs
SVG diagram generation
Mermaid diagram syntax

Insights Pattern

1. Provide the raw data
2. Ask: "What patterns do you see?"
3. Follow up: "What would you
   investigate next?"
4. Request: "Write the SQL/Python
   to validate hypothesis X"

Best Practices

Always verify calculations independently
Ask Claude to show its work
Use small samples to validate approach
Request confidence levels

Content Creation

Blog Posts

Generate outlines from topic + audience
Write section-by-section for quality control
Add SEO-friendly headings and meta descriptions
Create variations for A/B testing

Presentations

Structure slide content from raw notes
Generate speaker notes per slide
Create consistent narrative flow
Suggest visual aids and diagrams

Documentation

API references from code
User guides from feature specs
Migration guides for version upgrades
FAQ generation from support tickets

Marketing Copy

Product descriptions at scale
Email campaign sequences
Social media post variations
Landing page copy with CTAs

Pro tip: Always provide your brand voice guidelines and 2-3 examples of existing content to maintain consistency.

Software Architecture

System Design

Describe requirements, get architecture proposals
Compare monolith vs. microservices tradeoffs
Identify scaling bottlenecks early
Generate architecture decision records (ADRs)

API Design

RESTful endpoint design from user stories
OpenAPI/Swagger spec generation
GraphQL schema from data models
Versioning strategy recommendations

Database Schema

Entity-relationship modeling
Migration script generation
Index optimization suggestions
Normalization vs. denormalization advice

Architecture Docs

C4 model diagram descriptions
Sequence diagrams from code flow
Data flow documentation
Non-functional requirements analysis

Code Review Workflow

A hybrid human + Claude review pipeline for thorough, fast reviews:

Test-Driven Development with Claude

Why TDD + Claude Works

Tests define exact expected behavior
Claude has clear success criteria
Catches regressions immediately
Forces modular, testable design

Workflow

1. You: Write tests for the feature
2. Claude: Implement to pass tests
3. You: Run tests, report failures
4. Claude: Fix until all tests pass
5. You: Review & refactor together

Documentation Generation

API Documentation

Prompt: "Generate OpenAPI 3.0 docs
for this Express router. Include
request/response examples and
error codes."

Auto-generate from route handlers
Include authentication details
Add usage examples per endpoint

README Files

Prompt: "Create a README.md for this
project. Include: overview, setup,
usage, API reference, contributing
guidelines."

Standardized structure
Badge generation
Quick-start guides

Inline Comments

JSDoc / docstring generation from functions
Explain complex algorithms
Add parameter/return type docs
Document edge cases and assumptions

Architecture Docs

System overview from codebase
Component interaction diagrams
Data flow descriptions
Deployment architecture guides

Project Planning

Breaking Down Tasks

Prompt: "I need to build a user
authentication system. Break this
into subtasks with dependencies,
estimated hours, and priority."

Claude generates a structured work breakdown with realistic estimates.

Sprint Planning

Convert user stories to tasks
Estimate story points with rationale
Identify blockers and dependencies
Suggest sprint goals and capacity

Example Output

Task	Est.	Priority
DB schema design	2h	P0
Auth middleware	4h	P0
Login/signup API	3h	P0
JWT token mgmt	3h	P1
Password reset flow	4h	P1
OAuth integration	6h	P2

Estimation Tips

Ask Claude to provide optimistic, likely, and pessimistic estimates (three-point estimation).

Meeting & Communication

Meeting Summaries

Paste transcript or notes
Extract decisions, action items, owners
Generate follow-up email
Track open questions

"Summarize this meeting.
List: decisions made,
action items (who + when),
open questions."

Email Drafting

Professional tone calibration
Difficult conversation handling
Follow-up sequence creation
Multi-audience variants

"Draft a polite but firm
email to the vendor about
the missed deadline."

Status Reports

Weekly/monthly from raw notes
Highlight blockers and risks
Format for different audiences
Track progress against goals

"Create a weekly status
from these bullet points.
Format for exec audience."

Learning & Onboarding

Use Claude as a personalized tutor for learning new technologies and codebases.

Learning New Codebases

"Explain the architecture of this project"
"What does this function do and why?"
"Walk me through the request lifecycle"
"What patterns does this codebase use?"
"Where would I add a new feature like X?"

Learning New Technologies

Ask for progressively harder exercises
Request explanations at your skill level
Compare to technologies you already know
"Explain Kubernetes like I know Docker but not K8s"
Get hands-on project suggestions

Onboarding Accelerator

New team members can use Claude to understand existing code, conventions, and architecture—reducing ramp-up time from weeks to days. Pair with existing documentation for best results.

Measuring Productivity Gains

Metric	Without AI	With Claude
Code review time	45 min	15 min
First draft (blog)	3 hours	30 min
Bug diagnosis	2 hours	20 min
Test writing	1 hour	15 min
Documentation	4 hours	45 min
New codebase ramp	2 weeks	3 days

ROI Calculation

Track time saved per task category
Multiply by hourly cost
Subtract Claude subscription/API costs
Typical ROI: 5-20x for dev teams

Quality Metrics

Bugs caught in review (before prod)
Documentation coverage increase
Test coverage improvement
Developer satisfaction scores

Caveat: Times vary by task complexity. Always validate AI output—review time is reduced, not eliminated.

Team Workflows

Shared Prompt Libraries

Version-controlled prompt templates
Standardized for common tasks
Include examples and expected outputs
Review and iterate as a team

prompts/
  code-review.md
  bug-report.md
  feature-spec.md
  release-notes.md

Consistent Workflows

Define team conventions for AI use
Agree on review requirements
Share effective prompting patterns
Document what works and what doesn't

Knowledge Bases

Feed Claude your team's style guides
Include architecture decisions
Add coding standards as system prompts
Build institutional knowledge into prompts

Team tip: Create a #claude-tips channel where team members share effective prompts, surprising results, and lessons learned.

Automation Patterns

Recurring Tasks

Daily standup summaries
Weekly changelog generation
PR descriptions from diffs
Dependency update analysis

Template Systems

# Bug Report Template
Context: {{error_log}}
Code: {{relevant_function}}
Action: Diagnose root cause
Format: 1) Cause 2) Fix 3) Prevention

Batch Processing

Process multiple files with same prompt
Bulk content generation
Mass code migration assistance
Multi-language translation runs

API integration: Use Claude's API with scripts to automate repetitive workflows. Chain prompts for multi-step tasks.

Common Workflow Anti-patterns

What NOT to do — and the better alternative:

Anti-patterns

Vague prompts: "Make this better"
No context: Pasting code without explaining the goal
Blind trust: Copying output without review
One-shot everything: Asking for an entire app in one prompt
Ignoring iterations: Not refining outputs
No examples: Expecting perfect format without showing one

Better Alternatives

Specific: "Reduce cyclomatic complexity of fn X"
Contextual: "This is a payment handler, fix the race condition"
Verify: Review, test, and validate all outputs
Incremental: Build feature by feature, test each
Iterate: Refine with follow-up prompts
Exemplify: "Format like this example: ..."

The Golden Rule

Treat Claude like a brilliant junior colleague: give clear instructions, provide context, review the work, and iterate. The quality of output is proportional to the quality of input.

Summary & Quick Reference

Prompting

Use CRAFT framework
Be specific and contextual
Include examples
Set format constraints
Iterate and refine

Key Workflows

Writing & content creation
Code review & TDD
Research & data analysis
Documentation generation
Project planning

Team Practices

Shared prompt libraries
Consistent conventions
Automation via API
Measure and track ROI
Avoid anti-patterns

Quick-Start Checklist

1. Identify repetitive or time-consuming tasks 2. Template your most common prompts 3. Iterate to find what works for your domain 4. Share effective patterns with your team

Next up: Presentation 9 — The Future of Claude