' + conn('Gmail', true, GMAIL) + conn('Slack', true, SLACK) + conn('Microsoft 365', false, M365) + '
'; }, caption: 'Each connector you turn on is a tool Cowork can reach into. as pills with gray bg; reset to inline underline \\*/ a { display: inline; background: none; padding: 0; border: none; border-radius: 0; text-decoration: underline; font-family: inherit; font-size: inherit; } /\\* Blockquotes — example prompts (Claude 101 doesn't use these) \\*/ blockquote { background: #f5f4ed; border-left: 3px solid #d1cfc5; padding: 12px 18px; margin: 16px 0; border-radius: 0 6px 6px 0; color: #3d3d3a; } blockquote pre { font-family: ui-monospace, monospace; font-size: 14px; }\n\n**Estimated time:** 5 minutes\n\n### Learning objectives\n\nBy the end of this lesson you'll be able to:\n\n- Recall the arc of Cowork 101 and what each module gave you\n- Pick the next moves that keep you using Cowork after the course ends\n\n* * *\n\n### What you've covered\n\n.mrc { --paper: #FAF9F5; --surface: #FFFFFF; --ink: #141413; --ink-2: #3D3D3A; --ink-3: #6B6A64; --ink-4: #B0AEA5; --border: rgba(31,30,29,0.12); --olive: #788C5D; --olive-soft: rgba(120,140,93,0.10); --olive-line: rgba(120,140,93,0.40); font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; color: var(--ink); line-height: 1.5; margin: 28px 0; -webkit-font-smoothing: antialiased; } .mrc \\*, .mrc \\*::before, .mrc \\*::after { box-sizing: border-box; } .mrc-shell { background: var(--paper); border: 1px solid var(--border); border-radius: 14px; padding: 22px 22px 20px; } .mrc-eyebrow { font-size: 11px; text-transform: uppercase; letter-spacing: 0.14em; font-weight: 600; color: var(--ink-4); margin: 0 0 14px 2px; } .mrc-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; } .mrc-card { background: var(--surface); border: 1px solid var(--border); border-radius: 10px; padding: 18px 18px 16px; display: flex; flex-direction: column; gap: 4px; position: relative; } .mrc-num { font-size: 10.5px; text-transform: uppercase; letter-spacing: 0.10em; font-weight: 600; color: var(--olive); margin: 0; } .mrc-name { font-family: Georgia, 'Iowan Old Style', 'Times New Roman', serif; font-size: 19px; font-weight: 500; color: var(--ink); letter-spacing: -0.01em; line-height: 1.25; margin: 2px 32px 6px 0; } .mrc-sum { font-size: 13px; color: var(--ink-2); line-height: 1.5; margin: 0; } .mrc-sum strong { color: var(--ink); font-weight: 600; } .mrc-check { position: absolute; top: 18px; right: 18px; width: 22px; height: 22px; border-radius: 50%; background: var(--olive-soft); border: 1px solid var(--olive-line); display: flex; align-items: center; justify-content: center; color: var(--olive); flex-shrink: 0; } .mrc-check svg { width: 10px; height: 10px; } .mrc-throughline { margin: 18px 4px 0; text-align: center; font-family: 'Iowan Old Style', 'Palatino Linotype', Georgia, serif; font-size: 16px; font-style: italic; color: var(--ink); letter-spacing: -0.005em; line-height: 1.45; } @media (max-width: 600px) { .mrc-grid { grid-template-columns: 1fr; } .mrc-name { font-size: 17px; } }\n\nWhat you've covered\n\nModule 1\n\n### Meet Claude Cowork\n\nWhat Cowork is, how it differs from Chat and Code, the kinds of work it's built for, and your first real task.\n\nModule 2\n\n### Make Claude Cowork Yours\n\nGlobal instructions, projects, skills, and plugins — how much more capable Cowork becomes when it knows what you know, has access to what you have access to, and does things the way your team does.\n\nModule 3\n\n### Use Claude wherever you work\n\nCowork in your browser via Claude in Chrome, and inside Word, Excel, PowerPoint, and Outlook via Claude in M365.\n\nModule 4\n\n### Sharing and safety in Claude Cowork\n\nWorking with autonomy responsibly, validating what you build, and turning personal workflows into team infrastructure.\n\nHand off a task, get a polished deliverable.\n\nThe throughline: Cowork goes beyond chat to allow you to delegate real work. Everything else in the course builds on that.\n\n### Try it now\n\nPick **one** of these to do this week.\n\n- **Set up memory.** Write a five-sentence global instructions block, or create a project for a stream of work you're already in.\n- **Schedule a task or set up Dispatch.** Take a recurring deliverable and put it on a cadence. Or set up Dispatch so that the next time something comes to mind off-hours, you can hand it to Cowork.\n- **Install a plugin.** Go to **Customize → Plugins**, install the plugin closest to your role, and run it against this week's version of your work.\n- **Try Claude in Chrome or M365.** Pick the surface that aligns with where most of your real work happens, install it, and use it on one task.\n- **Share something you built.** Share a use case you found valuable, a workflow that produced great results, or a skill you've built with your team. You could be the unlock they need to get more comfortable working with Claude.\n\n### Go deeper\n\nA few learning paths worth knowing about:\n\n- [**AI Fluency: Framework & Foundations**](https://anthropic.skilljar.com/ai-fluency-framework-foundations)**.** The foundations of working effectively with AI — prompting, evaluating output, knowing when AI is and isn't the right tool.\n- [**AI Capabilities and Limitations**](https://anthropic.skilljar.com/ai-capabilities-and-limitations)**.** A deeper survey of what generative AI tools can do across modalities and surfaces.\n- [**Claude 101**](https://anthropic.skilljar.com/claude-101)**.** The companion course on using Claude across all surfaces.\n- [**Claude use-case library**](https://claude.com/resources/use-cases)**.** Filter to Claude Cowork for ideas and inspiration on what to delegate next.\n\n#### Feedback\n\nAs you progress through the course, we'd love to hear how you're using concepts from it in your work, plus any feedback you may have. Share your feedback [here](https://docs.google.com/forms/d/e/1FAIpQLScol7ZPi1cxhXy40g0AQieFbhTNQoVNm1Bvvs2gD1giMzOXHQ/viewform).\n\n#### Acknowledgments and license\n\n_Copyright 2026 Anthropic. All rights reserved._\n",
"mcp_advanced": "\n\nBelow are notes from a video course about working with the Claude language model.\nUse these notes as a resource to answer the user's question.\nWrite your answer as a standalone response - do not refer directly to these notes unless specifically requested by the user.\n\n\nSampling = technique allowing MCP servers to request language model text generation from clients instead of directly accessing LLMs themselves.\n\nPurpose = shifts LLM access responsibility from server to client, avoiding need for servers to handle API keys, authentication, or token costs.\n\nArchitecture = Server creates message request → Client receives via sampling callback → Client calls LLM → Client returns generated text to server.\n\nBenefits = eliminates server complexity for LLM integration, removes API key requirements from servers, prevents unauthorized token usage on public servers.\n\nImplementation = Server uses create_message() function with message list, Client implements sampling callback to handle LLM requests and return create_message_result.\n\nPrimary use case = publicly accessible MCP servers that need LLM capabilities without direct LLM access or associated costs/security concerns.\n\n\n\nLog and Progress Notifications = MCP server feature that provides real-time feedback during tool execution to improve user experience.\n\nImplementation on server side:\n- Tool functions automatically receive context argument as last parameter\n- Context object provides methods: info() for logging, report_progress() for progress updates\n- Calling these methods automatically sends messages back to client\n\nImplementation on client side:\n- Create callback function for logging statements\n- Create separate callback for progress updates\n- Pass logging callback to client session\n- Pass progress callback to call_tool function\n- Callbacks handle how to display information to user (terminal output, web UI, etc.)\n\nKey benefits:\n- Prevents user confusion about stalled/failed tool calls\n- Provides visibility into long-running operations\n- Real-time feedback during tool execution\n\nOptional feature = can be omitted if not needed, purely for UX enhancement.\n\n\n\nMCP Roots = codified way for users to grant server access to specific files/folders\n\nProblem without roots: User says \"convert bikin.mp4\" but Claude can't locate file in complex filesystem without full path. Requiring full paths inconvenient for users.\n\nSolution with roots: Add 3 tools to MCP server:\n- ConvertVideo (original tool)\n- ReadDirectory (lists files/folders in directory) \n- ListRoots (returns available roots)\n\nRoot = file/folder user grants permission to access beforehand (via command line args when starting server)\n\nImplementation requirement: Tools must check that accessed files/folders are contained within granted roots using function like is_path_allowed()\n\nTwo main benefits:\n1. Permission control - limits server access to authorized areas only\n2. Autonomous discovery - Claude can search through available roots to find files without user providing full paths\n\nKey limitation: MCP SDK doesn't automatically enforce root restrictions. Server developer must implement access checks manually.\n\nListRoots tool optional - can alternatively include root list in prompt directly. Tool pattern allows Claude to dynamically check available roots when needed.\n\n\n\nJSON Message Types in MCP:\n\nMCP communication = JSON messages between clients and servers. Each message type has distinct purpose.\n\nMessage categories:\n- Request/Result pairs = Always come together (call_tool_request + call_tool_result, initialize_request + initialize_result)\n- Notifications = Events that don't need responses (progress_notification, logging_message_notification, tool_change_notification)\n\nMessage direction classification:\n- Client messages = Sent by MCP client to server\n- Server messages = Sent by MCP server to client\n\nKey insight: Servers can send messages TO clients (server requests, server notifications). This directional capability becomes critical limitation in streamable HTTP transport.\n\nSchema definition = TypeScript file in MCP spec repository (schema.ts). Not executable code, just type descriptions for convenience.\n\nMessage structure = JSON-RPC format with method, params, ID fields.\n\n\n\nMCP Transport = mechanism for moving JSON messages between client and server\n\nStdio Transport = transport where client launches server as separate process, communicates via standard input/output streams\n\nCommunication mechanism: Client writes to server's stdin, reads from server's stdout. Server writes to stdout, reads from stdin.\n\nAdvantages: Bidirectional communication - either client or server can initiate requests at any time\n\nLimitations: Only works when client and server run on same physical machine\n\nMessage exchange patterns:\n- Client-to-server request: Write to stdin, read response from stdout\n- Server-to-client request: Server writes to stdout, client responds via stdin\n\nRequired initialization sequence:\n1. Initialize request (client to server)\n2. Initialize result (server to client) \n3. Initialize notification (client to server, no response required)\n\nMessage types:\n- Requests = expect responses\n- Notifications = no response required\n- Results = responses to requests\n\nKey characteristic: Full bidirectional communication support - both parties can initiate requests\n\nContrast with HTTP transport: HTTP transport has limitations on server-initiated requests that stdio transport doesn't have\n\n\n\nStreamableHTTP Transport = MCP transport enabling client-server communication over HTTP connections, allows remote server hosting unlike standard I/O transport which requires same-machine operation.\n\nKey advantage = Remote hosting capability - servers can be publicly accessible at URLs like mcpserver.com, expanding MCP server possibilities.\n\nCritical limitation = Restricted server-to-client messaging functionality due to HTTP's unidirectional nature - clients easily request from servers, but servers cannot easily initiate requests to clients.\n\nTwo key settings impact functionality:\n- stateless HTTP (default: false)\n- JSON response (default: false)\n\nSetting these to true = Reduced functionality, breaks progress bars, logging notifications, progress notifications, and sampling requests.\n\nHTTP communication constraint = Server doesn't know client address and client may not be publicly accessible, making server-initiated requests challenging.\n\nAffected message types when using HTTP = Sampling requests, listing routes, progress notifications, logging notifications - all require server-to-client communication.\n\nCommon deployment issue = Application works fine locally with standard I/O transport but fails when deployed with HTTP transport due to these messaging restrictions.\n\nSolution exists = StreamableHTTP transport has workarounds for server-to-client communication challenges, but with caveats.\n\n\n\nStreamableHTTP Transport = HTTP-based MCP transport using server-sent events (SSE) to enable server-to-client communication\n\nCore Problem: MCP requires server-to-client requests (sampling, notifications, logging) but HTTP naturally supports only client-to-server requests\n\nWorkaround Solution: Uses SSE connections to allow server streaming messages to client\n\nSession ID = Random identifier assigned during initialization, included in all subsequent requests as HTTP header\n\nInitialization Flow:\n1. Client sends initialize request\n2. Server responds with result + MCP session ID header\n3. Client sends initialized notification with session ID\n4. Client optionally makes GET request with session ID to establish SSE connection\n\nTwo SSE Connections:\n1. Long-lived SSE connection = For server-initiated requests (sampling, notifications)\n2. Short-lived SSE connection = For specific tool call responses, automatically closed after result\n\nMessage Routing:\n- Progress notifications → Long-lived SSE connection\n- Logging messages + tool results → Short-lived SSE connection tied to specific request\n\nKey Limitation: Setting certain flags to true breaks the workaround, making StreamableHTTP complex to understand and use properly\n\nCritical Point: SSE responses enable bidirectional communication over HTTP by keeping connections open and streaming individual messages from server to client\n\n\n\n**Stateless HTTP Flag**\n\nStateless HTTP = flag set to true when MCP server needs horizontal scaling across multiple instances with load balancer\n\n**Why needed**: Single server instance can't handle high traffic. Horizontal scaling uses multiple server copies + load balancer routing requests randomly.\n\n**Problem without stateless**: Client needs 2 connections (GET SSE for server-to-client requests, POST for client-to-server). Load balancer may route these to different server instances. If tool on Server A needs sampling request, it must go through GET SSE connection on Server B - requires complex coordination.\n\n**Effect of stateless=true**:\n- No session IDs assigned to clients\n- Server cannot track individual clients\n- GET SSE response pathway disabled (server cannot send requests to client)\n- Eliminates sampling, progress logging, resource subscriptions\n- No client initialization required (skips initialize request + notification)\n- Reduces server traffic\n\n**JSON Response Flag**\n\nJSON response = flag disabling streaming responses on POST requests\n\n**Effect of JSON response=true**:\n- POST responses return final result as plain JSON only\n- No intermediate streaming messages\n- No progress/log statements during execution\n- Client waits for complete tool execution before receiving response\n\n**Key Takeaway**: Both flags significantly change server behavior. Use same transport in development as planned for production to avoid deployment issues.\n\n",
"mcp_intro": "\n\nBelow are notes from a video course about working with the Claude language model.\nUse these notes as a resource to answer the user's question.\nWrite your answer as a standalone response - do not refer directly to these notes unless specifically requested by the user.\n\n\nMCP = Model Context Protocol, communication layer providing Claude with context and tools without requiring developers to write tedious code.\n\nCore Architecture: MCP client connects to MCP server. MCP server contains tools, resources, and prompts as internal components.\n\nProblem Solved: Traditional approach requires developers to manually author tool schemas and functions for each service integration (like GitHub API tools). This creates maintenance burden for complex services with many features.\n\nMCP Solution: Shifts tool definition and execution from developer's server to dedicated MCP server. MCP server = interface to outside service, wrapping functionality into pre-built tools.\n\nKey Benefits: Eliminates need for developers to write/maintain tool schemas and function implementations. Someone else authors the tools, packages them in MCP server.\n\nCommon Questions:\n- Who authors MCP servers? Anyone, but often service providers create official implementations\n- Difference from direct API calls? Saves developer time by providing pre-built tool schemas/functions instead of manual authoring\n- Relationship to tool use? MCP and tool use are complementary, not identical. MCP focuses on who does the work of creating tools\n\nCore Value: Reduces developer burden by outsourcing tool creation to MCP server implementations rather than requiring custom tool development for each service integration.\n\n\n\nMCP Client = communication interface between your server and MCP server, provides access to server's tools.\n\nTransport agnostic = client/server can communicate via multiple protocols (stdin/stdout, HTTP, WebSockets, etc). Common setup: both on same machine using stdin/stdout.\n\nCommunication = message exchange defined by MCP spec. Key message types:\n- list tools request/result = client asks server for available tools, server responds with tool list\n- call tool request/result = client asks server to run tool with arguments, server returns execution result\n\nTypical flow: User query → Server asks MCP client for tools → MCP client sends list tools request to MCP server → Server gets tool list → Server sends query + tools to Claude → Claude requests tool execution → Server asks MCP client to run tool → MCP client sends call tool request to MCP server → MCP server executes tool (e.g., GitHub API call) → Results flow back through chain → Claude formulates final response → User gets answer.\n\nMCP client acts as intermediary - doesn't execute tools itself, just facilitates communication between your server and MCP server that actually runs the tools.\n\n\n\nMCP Learning Project = CLI-based chatbot implementing both client and server components for educational purposes.\n\nProject Structure = Custom MCP client connects to custom MCP server, both built in same project.\n\nDocument System = Fake documents stored in memory only, no persistence.\n\nServer Tools = Two tools implemented: read document contents, update document contents.\n\nReal-world Context = Normally projects implement either client OR server, not both. This project does both for learning.\n\nSetup Requirements = Download CLI_project.zip, extract, configure .env with API key, install dependencies.\n\nRunning Project = \"uv run main.py\" (with UV) or \"python main.py\" (without UV).\n\nVerification = Chat prompt appears, responds to basic queries like \"what's one plus one\".\n\n\n\nMCP server implementation = Python SDK simplifies tool creation vs manual JSON schemas\n\nTool definition syntax = @mcp.tool decorator + function with typed parameters + Field descriptions\n\nDocument storage = in-memory dictionary with doc_id keys and content values\n\nTool 1 - read_doc_contents = takes doc_id string parameter, returns document content from docs dictionary, raises ValueError if doc not found\n\nTool 2 - edit_document = takes doc_id, old_string, new_string parameters, performs find/replace operation on document content, includes existence validation\n\nMCP Python SDK benefits = auto-generates JSON schemas from decorated functions, single line server creation, eliminates manual schema writing\n\nParameter definition = use Field() with description for tool arguments, import from pydantic\n\nError handling = validate document existence before operations, raise ValueError for missing documents\n\nImplementation pattern = decorator → function definition → parameter typing → validation → core logic\n\n\n\nMCP Inspector = in-browser debugger for testing MCP servers without connecting to actual applications\n\nAccess: Run \\`mcp dev [server_file.py]\\` in terminal with activated Python environment → opens server on port → visit provided localhost address\n\nInterface: Left sidebar with Connect button → top navigation bar shows Resources/Prompts/Tools sections → Tools section lists available tools → click tool to open right panel for manual testing\n\nTesting process: Select tool → input required parameters (like document ID) → click Run Tool → verify output/success message\n\nKey features: Live development testing, tool invocation simulation, parameter input fields, success/failure feedback\n\nStatus: Inspector in active development - UI may change but core functionality remains similar\n\nUsage pattern: Essential for MCP server development and debugging before production deployment\n\n\n\nMCP Client Implementation:\n\nMCP Client = wrapper class around client session for connecting to MCP server with resource cleanup management\n\nClient Session = actual connection to MCP server from MCP Python SDK, requires cleanup when closing\n\nResource Cleanup = necessary process when shutting down, handled by connect/cleanup/async enter/async exit functions\n\nClient Purpose = exposes MCP server functionality to rest of codebase, provides interface between application code and server\n\nKey Functions:\n- list_tools() = await self.session.list_tools(), return result.tools\n- call_tool() = await self.session.call_tool(tool_name, tool_input)\n\nImplementation Flow:\n1. Application requests tool list for Claude\n2. Client calls list_tools() to get server's available tools\n3. Claude selects tool and provides parameters\n4. Client calls call_tool() to execute on server\n5. Results returned to Claude\n\nTesting = run MCP client.py directly with testing harness to verify connection and tool listing\n\nIntegration = once implemented, can run CLI to have Claude use tools (e.g., \"what is contents of report.pdf document\")\n\nCommon Practice = wrap client session in larger class rather than using directly for better resource management\n\n\n\nResources = MCP server feature that exposes data to clients for read operations\n\nResource types:\n- Direct/Static = static URI (e.g., docs://documents)\n- Templated = parameterized URI with wildcards (e.g., documents/{doc_id})\n\nResource flow:\n1. Client sends read resource request with URI\n2. MCP server matches URI to resource function\n3. Server executes function, returns result\n4. Client receives data via read resource result message\n\nImplementation:\n- Use @mcp.resource decorator\n- Define URI (route-like address)\n- Set MIME type (application/json, text/plain, etc.)\n- Templated resources: URI parameters become function keyword arguments\n- Python MCP SDK auto-serializes return values to strings\n\nCommon pattern = One resource per distinct read operation (list items vs fetch single item)\n\nMIME types = hints to client about returned data format for proper deserialization\n\n\n\nMCP Resource Access = method for clients to retrieve data from server resources\n\nClient Implementation:\n- read_resource function = takes URI parameter, requests resource from MCP server\n- Uses await self.session.read_resource(AnyUrl(uri)) for server communication\n- Accesses result.contents[0] = first resource from returned contents list\n\nResponse Parsing:\n- Checks resource.mime_type property to determine data format\n- If mime_type == \"application/json\": returns json.loads(resource.text)\n- Otherwise: returns resource.text as plain text\n\nResource Integration:\n- MCP client functions called by other application components\n- Enables document selection via CLI interface with arrow keys + space\n- Selected resource contents automatically included in LLM prompts\n- Eliminates need for tools to read document contents during chat\n\nKey Dependencies: json module, pydantic.AnyUrl for type handling\n\n\n\nPrompts = pre-written, tested instructions that MCP servers expose to clients for specialized tasks\n\nMCP Prompts Feature:\n- Servers define high-quality prompts tailored to their domain\n- Clients can access these prompts via slash commands (e.g., /format)\n- Alternative to users writing their own prompts manually\n\nImplementation Pattern:\n- Use @prompt decorator with name and description\n- Function receives arguments (e.g., document ID)\n- Returns list of messages (user/assistant format)\n- Messages sent directly to Claude\n\nKey Benefit: Server authors create optimized, tested prompts rather than leaving prompt quality to end users\n\nExample Structure:\n\\`\\`\\`\n@prompt(name=\"format\", description=\"rewrites document in markdown\")\ndef format_document(doc_id: str) -> list[messages]:\n return [base.user_message(prompt_text)]\n\\`\\`\\`\n\nWorkflow: User types /format → selects document → server returns specialized prompt → client sends to Claude → Claude uses tools to read/reformat/save document\n\nPurpose = encapsulate domain expertise in prompt engineering within specialized MCP servers\n\n\n\nMCP Client Prompt Implementation:\n\nList prompts function = await self.session.list_prompts(), return result.props\n\nGet prompt function = await self.session.get_prompt(prompt_name, arguments), return result.messages\n\nPrompt workflow = Client requests prompt by name → passes arguments as keyword parameters → MCP server interpolates arguments into prompt template → returns formatted messages for AI model\n\nArguments flow = Client arguments → prompt function keyword arguments → interpolated into prompt text (e.g., document_id parameter gets inserted into prompt template)\n\nReturn format = Messages array that forms conversation input for AI model\n\nCLI usage = /format command → select document → prompt with document ID sent to Claude → Claude uses tools to fetch document → returns formatted result\n\nKey concept = Prompts are server-defined templates that clients can invoke with parameters, enabling reusable AI instructions with dynamic content insertion.\n\n\n\nMCP Server Primitives = 3 types: tools, resources, prompts\n\nTools = model-controlled primitives where Claude decides when to execute them. Used to add capabilities to Claude (e.g., JavaScript execution for calculations). Serve the model.\n\nResources = app-controlled primitives where application code decides when to fetch data. Used to get data into apps for UI display or prompt augmentation (e.g., autocomplete options, document listings from Google Drive). Serve the app.\n\nPrompts = user-controlled primitives triggered by user actions like button clicks or slash commands. Used for predefined workflows (e.g., chat starter buttons in Claude interface). Serve users.\n\nControl patterns determine purpose: Need Claude capabilities → implement tools. Need app data → use resources. Need user workflows → create prompts.\n\nReal examples: Claude's chat starter buttons use prompts, Google Drive document selection uses resources, code execution uses tools.\n\n",
"taif": "\n\nBelow are notes from a video course about working with the Claude language model.\nUse these notes as a resource to answer the user's question.\nWrite your answer as a standalone response - do not refer directly to these notes unless specifically requested by the user.\n\n\nAI FLUENCY FRAMEWORK = dual-purpose tool that describes what happens when people work with AI AND guides them toward better practices\n\nCOURSE STRUCTURE = 3 lessons addressing: 1) How to introduce framework to students (pedagogy), 2) How to assess if students understand (assessment), 3) How to integrate with existing curriculum\n\nTEACHING APPROACHES = 4 distinct entry points for introducing AI Fluency Framework to students\n\nAPPROACH 1: STEP-BY-STEP (LINEAR)\n- Framework as sequential process: Delegation → Description → Discernment → Diligence\n- Best for: Beginning AI users who need structure and manageable progression\n- Implementation: Four-part assignments building sequentially (e.g., part 1 = Delegation/project planning, part 2 = Description/hands-on workshops, part 3 = Discernment/evaluation, part 4 = Diligence/ethics)\n- Benefits: Natural, intuitive, creates structured learning journey\n\nAPPROACH 2: START ANYWHERE (NON-LINEAR) \n- Framework as interconnected system where any competency can be starting point\n- Best for: Experienced AI users who can handle real-world complexity\n- Key insight: Competencies inform each other (Discernment problems → new Delegation decisions; Diligence requirements → different Description strategies; Description challenges → Delegation gaps)\n- Implementation: Group projects, case-based learning with real AI collaboration scenarios\n- Benefits: Reflects messy realities of actual AI collaboration, builds adaptive thinking\n\nAPPROACH 3: JUST ONE D (FOCUSED)\n- Deep exploration of single competency at a time\n- Best for: Specialized purposes, skill-building sessions, workshops\n- Implementation: Entire workshop on one competency (e.g., three Discernment sessions covering Product/Process/Performance evaluation)\n- Benefits: Masters specific area without cognitive overload, allows nuanced exploration of techniques and edge cases\n\nAPPROACH 4: TWO LOOPS\n- Most conceptually rich approach treating AI fluency as nested processes\n- Best for: Students who grasp basics and need deeper understanding\n- Structure: Delegation-Diligence loop (strategic/ethical decisions) + Description-Discernment loop (tactical/iterative work)\n- Benefits: Reveals how competencies constantly inform each other in practice\n\nDELEGATION-DILIGENCE LOOP = strategic and ethical decision-making framework for responsible AI collaboration\n\nLOOP COMPONENTS:\nDelegation = Problem Awareness + Platform Awareness + Task Delegation\nDiligence = Creation Diligence + Transparency Diligence + Deployment Diligence\n\nBIDIRECTIONAL FLOW:\nForward (Delegation → Diligence): Strategic decisions raise ethical questions\nReverse (Diligence → Delegation): Ethical constraints clarify and improve strategic choices\n\nTEACHING STRATEGIES:\n- Applied scenarios making connections visible\n- Step-by-step guides for both directions\n- Recognition that constraints enhance rather than limit creativity\n- Focus on developing clear rationales for choices\n\nDESCRIPTION-DISCERNMENT LOOP = moment-to-moment craft of building cognitive environments for human-AI collaboration\n\nCORE CONCEPT: Conversations not commands - building shared context and understanding rather than single prompt exchanges\n\nCOGNITIVE ENVIRONMENT = collaborative context including:\n- Shared vocabulary and references evolving over time\n- Well-defined goals, values, processes, methods\n- Established interaction patterns enabling optimal performance\n- Mechanisms for building on previous interactions\n\nTHREE LENSES:\nPRODUCT = what we're creating together (evolving understanding of goals and quality)\nPROCESS = shared approaches to thinking and problem-solving\nPERFORMANCE = relationship dynamics between human and AI\n\nTEACHING STRATEGIES:\n- Multi-interaction assignments requiring context accumulation\n- Share instructor's own AI collaboration processes\n- Document evolution of collaboration, not just outputs\n- Move beyond automation to augmentation\n\nSUCCESS INDICATORS:\n- Shared Language: Shorthand references to complex ideas from earlier conversations\n- Exploration Mindset: Evolution from rigid commands to flexible, interactive approaches\n\nNESTED SYSTEMS = how the two loops work together:\nDelegation-Diligence = strategic container setting direction and boundaries\nDescription-Discernment = tactical content filling container with rich interaction\nResult = Responsible, sophisticated AI collaboration transcending what either partner achieves alone\n\nLESSON DURATION = 2 hours (30 minutes video, 90 minutes exercises)\n\nEXERCISE STRUCTURE = 3 progressive exercises building teaching capability:\n1) Establish teaching context and explore approaches (30 min)\n2) Design Delegation-Diligence loop lesson (30 min) \n3) Design Description-Discernment loop lesson (30 min)\n\n\n\n# Assessing and Designing AI Fluency Notes\n\n## Core Assessment Framework\n\nAI Fluency Assessment = Outcome-based + Process-based + Reflection-based approaches combined\n\n**Outcome-based assessment** = Focus on what students produce through AI collaboration. Assess whether students achieved stated goals through human-AI partnership.\n\n**Process-based assessment** = Examine how students work with AI over time. Captures iteration patterns, recovery from failures, methodological sophistication.\n\n**Reflection-based assessment** = Focus on metacognitive awareness. Students analyze why strategies worked/didn't work, what they learned, future applications.\n\n## Assessing the 4Ds\n\n### Delegation Assessment\n- **Outcome**: Did delegation plan make sense? Were goals realistic? Right tool selection?\n- **Process**: Review annotated chat logs showing exploration of options and decision-making\n- **Reflection**: Students explain choices, alternatives considered, how delegation shaped outcomes\n\n### Description Assessment \n- **Outcome**: Quality of prompts and AI responses. Clear instructions? Good context? Evolution from initial to final versions\n- **Process**: Conversation logs showing iterative refinement, failed approaches, building shared context\n- **Reflection**: Analysis of which description techniques worked best, task-specific communication approaches, description quality vs output quality relationship\n\n### Discernment Assessment\n- **Outcome**: Students annotate AI outputs marking strengths/weaknesses. Decision logs explaining what was kept/modified/discarded\n- **Process**: In-line evaluation comments, catching/correcting errors, pattern recognition across interactions\n- **Reflection**: Analysis of evaluation criteria evolution, initially missed issues, comparison across task types\n\n### Diligence Assessment\n- **Outcome**: Quality of diligence statements, attribution/transparency documentation, fact-checking evidence\n- **Process**: Data handling in chat logs, ethical decision-making, sensitive information handling, constraint-checking\n- **Reflection**: Discussion of ethical dilemmas, responsibility understanding, surprising challenges, future improvements\n\n## Assignment Design Principles\n\n**Authenticity** = Create assignments mirroring real-world AI collaboration, genuine problems where AI partnership adds value\n\n**Iteration** = Build in refinement opportunities showcasing growth over time\n\n**Pedagogical Transparency** = Clear assessment of collaboration process and reflections, not just outputs\n\n## Assignment Types\n\n### Outcome-Based Assignments\n- **Improving AI outputs**: Transform mediocre AI output into excellent work\n- **Product comparison**: Use multiple AI systems for same task, analyze differences\n- **Constraint-based challenges**: Specific requirements (format, length, style, audience)\n- **Peer product review**: Students set goals, create with AI, swap and critique\n\n### Process-Based Assignments\n- **Annotated chat logs**: Students highlight turning points, breakthroughs, failure recovery\n- **Recorded narrations**: Real-time decision-making explanation during AI work\n- **Process playbooks**: Personal AI strategy guides for different task types\n- **AI-assisted/peer debrief**: Discussion of chat logs with AI or peer partners\n\n### Reflection-Based Assignments\n- **Guided inquiry**: Specific questions about particular assignments\n- **Learning journal**: Self-assess 4D development with evidence across course\n- **Scenarios/case studies**: Apply learnings to hypothetical or real-world situations\n- **Personal policy statements**: Develop own values/strategies for AI collaboration\n\n## Managing Assignment Volume\n\n**Detailed deliverable-based rubrics** = Clear, granular deliverables for quick verification\n\n**Self and peer review emphasis** = Students best positioned to observe development with proper guidance\n\n**Lightning round conferences** = Brief conferences replacing written feedback (5-minute discussions)\n\n**Selective sampling** = Don't read every word; students flag key moments for attention\n\n## Key Assessment Artifacts\n\n**Chat logs** = Primary process documentation\n**Diligence statements** = Transparency and attribution documentation\n**Learning journals** = Reflection and metacognitive development\n**Decision logs** = Record of what AI output was kept/modified/discarded\n**Process playbooks** = Personal strategy documentation\n\n## Assessment Focus Areas\n\nFocus on **observable actions and concrete artifacts** rather than assumptions about understanding\n\nDifferent competencies benefit from different assessment approaches\n\nAssessment should be **learning opportunity, not just measurement**\n\nStudents need to understand you care about **how they learn to work with AI**, not just what they produce\n\nEssential principle: Make invisible decision-making visible through documentation and reflection\n\n\n\nAI FLUENCY ASSIGNMENT COMPONENTS\n\nOUTCOME-BASED COMPONENTS\n\nImproving AI Outputs = Students transform mediocre AI output into excellent work through critique and iteration\n- Assessment focus: Discernment, Description\n- Deliverables: Original with annotations + improved version\n- Effective because: Forces explicit quality standards, requires domain knowledge application, develops AI guidance skills\n- Variations: Different flaw types, peer improvement exchanges\n\nProduct Comparison = Students use multiple AI systems for same task, analyze differences\n- Assessment focus: Delegation, Discernment \n- Deliverables: Multiple outputs + comparison matrix + recommendation report\n- Effective because: Builds platform awareness, creates evidence-based selection skills, reveals trade-offs\n- Process: Use standard AI assistant + reasoning-capable system + specialized system\n\nConstraint-Based Challenges = Achieve specific requirements through AI collaboration within limits\n- Assessment focus: Description, Delegation\n- Deliverables: Final product meeting all constraints\n- Effective because: Develops precise AI communication, reveals specification importance, builds problem-solving under limitations\n- Variations: Ethical constraints, conflicting constraints, time pressure\n\nPeer Product Review = Evaluate AI-assisted work by peers against goals and ethics\n- Assessment focus: Discernment, Diligence\n- Deliverables: Review feedback form\n- Criteria: Goal achievement, appropriate AI use, human oversight quality, AI attribution adequacy\n- Variations: Blind review, group sessions\n\nPROCESS-BASED COMPONENTS\n\nAnnotated Chat Logs = Submit complete chat logs with detailed annotations\n- Assessment focus: Description, Discernment\n- Annotations mark: Turning points, insights/breakthroughs, failures/recovery, communication evolution, shared context development\n- Effective because: Makes thinking visible, captures authentic problem-solving, reveals communication evolution\n- Variations: Competency-focused annotations, pattern comparisons\n\nRecorded Narrations = Screen recording with real-time audio narration of AI work\n- Assessment focus: All 4Ds\n- Narration covers: Choice rationale, response evaluation, alternatives considered, ethical considerations\n- Effective because: Captures authentic decision-making, reveals tacit knowledge, shows actual vs reported work\n- Variations: Paired commentary, before/after comparisons\n\nProcess Playbooks = Personal reference guides for AI collaboration strategies\n- Assessment focus: All 4Ds\n- Includes: Conversation guides, decision trees, quality checklists, pitfall recovery, ethical guidelines\n- Effective because: Encourages systematic documentation, creates useful resource, builds metacognitive awareness\n- Variations: Collaborative playbooks, discipline-specific requirements\n\nAI-Assisted/Peer-Assisted Debrief = Structured analysis of AI collaboration with external perspective\n- Assessment focus: All 4Ds\n- Analysis covers: Positive patterns, missed opportunities, strengths, improvement areas\n- Effective because: Provides external perspective, reveals blind spots, encourages peer learning\n\nREFLECTION-BASED COMPONENTS\n\nGuided Inquiry = Respond to specific questions promoting deep reflection\n- Assessment focus: Variable by questions\n- Question types: Surprise moments, failed strategies, communication evolution, ethical decisions\n- Effective because: Targets specific AI fluency aspects, requires evidence-based reflection\n- Variations: Discipline-tailored, progressive questions\n\nLearning Journal = Ongoing documentation of AI fluency development\n- Assessment focus: All 4Ds over time\n- Weekly entries: Attempts, successes, challenges, skill improvements, future goals\n- Monthly synthesis: Pattern identification, goal setting\n- Variations: Multimedia journals, collaborative journals, AI conversation journals\n\nScenarios and Case Studies = Apply AI fluency learning to realistic scenarios\n- Assessment focus: Diligence, Delegation\n- Analysis includes: Delegation decisions, ethical considerations, action plans, risk mitigation\n- Effective because: Develops strategic thinking, builds ethical reasoning, connects theory to practice\n- Variations: Real-world cases, discipline-specific scenarios, stakeholder role-play\n\nPersonal Policy Statements = Synthesize learning into personal AI collaboration framework\n- Assessment focus: Diligence, All 4Ds holistically\n- Components: Ethical principles, decision criteria, quality standards, transparency commitments, boundaries, learning strategies\n- Effective because: Requires deep synthesis, builds professional identity, creates accountability\n- Variations: Collaborative policies for group work\n\nASSESSMENT MATRICES\n\nDelegation Assessment Matrix:\n- Strong performance = Strategic thinking about when/why/how to collaborate with AI\n- Outcome focus: Task division quality, tool selection appropriateness, goal achievement\n- Process focus: Decision documentation, platform exploration, adaptation evidence\n- Reflection focus: Choice analysis, alternative consideration, impact evaluation\n\nDescription Assessment Matrix:\n- Strong performance = Effective AI communication regarding outputs/processes/behaviors\n- Outcome focus: Prompt evolution, context building, communication clarity\n- Process focus: Iterative refinement, recovery patterns, shared vocabulary development\n- Reflection focus: Strategy analysis, technique recognition, context insights\n\nDiscernment Assessment Matrix:\n- Strong performance = Critical evaluation using domain-specific, nuanced criteria\n- Outcome focus: Annotation quality, evaluation depth, evidence-based judgment\n- Process focus: Error catching, consistency, quality improvement over time\n- Reflection focus: Criteria evolution, missed issue analysis, meta-evaluation skills\n\nDiligence Assessment Matrix:\n- Strong performance = Integrated ethical reasoning throughout collaboration\n- Outcome focus: Attribution quality, transparency documentation, verification evidence\n- Process focus: Data handling, permission documentation, constraint checking\n- Reflection focus: Ethical dilemma discussion, responsibility understanding, values articulation\n\nMatrix Usage:\n- Rubric development: Select relevant Ds, choose assessment types, adapt indicators, define performance levels\n- Feedback provision: Use indicators to guide review, reference strong performance markers\n- Student assessment: Share criteria beforehand, encourage self-identification of competency evidence\n\n\n\n**LESSON OVERVIEW**\n- Duration = 50+ minutes (20 min video + 30 min exercises + offline discussion)\n- Focus = AI impacts on specific disciplines across curriculum/pedagogy/assessment\n- Goal = Create discipline-specific AI fluency applications using 4Ds framework\n\n**CORE PRINCIPLE**\nAI Fluency = Amplifying human expertise, not replacing it\nDisciplinary knowledge = Foundation for unprecedented achievement through AI partnership\n\n**THREE KEY QUESTIONS FOR GRADUATES**\n1. What gets automated? = Which routine career tasks will AI handle\n2. Partnership potential = Where human-AI collaboration most impactful \n3. Who's in charge? = How to manage/remain accountable for independent AI work\n\n**AI DISRUPTION PATTERNS**\nDisruption ≠ uniform across disciplines\n- Curriculum may stay stable while assessments transform\n- Pedagogy might evolve while core content constant\n- Some disruptions = opportunities to leverage\n- Others = problems to solve\n- Your expertise determines which is which\n\n**THREE EXPERTISE TYPES FOR AI RESPONSE**\n1. Disciplinary Expertise = Field content, values, methods, thinking patterns\n2. Pedagogical Expertise = Student struggle/breakthrough patterns, learning emotional journey\n3. Assessment Expertise = Recognizing genuine understanding, designing deep learning evaluations\n\n**CURRICULUM IMPACT ANALYSIS**\nTasks for discipline assessment:\n- Identify AI automation capabilities in field\n- Determine foundational concepts importance shifts with AI\n- Map AI augmentation improvements to best practices\n- Develop responses to \"Why learn X when AI does it?\" questions\n- Define how to direct AI agents effectively\n\n**PEDAGOGY TRANSFORMATION**\nEnhancement opportunities:\n- Personalized tutoring at scale\n- Interactive simulations \n- Immediate feedback systems\n- AI as educational assistant/interactive learning partner\n\nRisk assessment:\n- Distinguish AI that enhances vs diminishes learning\n- Identify teacher-student AI collaborations that leverage potential\n- Determine pedagogical approaches to embrace vs avoid\n- Address reality that students will use AI regardless\n\n**ASSESSMENT REVOLUTION** \nCore challenges:\n- When students generate essays in seconds, what are we assessing?\n- Create evaluations honoring individual growth/creativity/problem-solving\n- Assess both AI-assisted and human-only performances\n\nEssential tasks:\n- Identify authentic learning demonstration in AI-assisted work\n- Create assignments students can't shortcut with AI\n- Value process/growth, not just products\n- Determine where AI collaboration enhances vs undermines objectives\n- Adapt to student AI use reality\n\n**IRREPLACEABLE HUMAN CAPABILITIES**\n- Domain expertise\n- Real-world context understanding\n- Judgment in ambiguous situations\n- Creative problem-solving\n- Ethical reasoning\n- Relationship building\n\n**APPLYING 4DS TO DISCIPLINES**\n\n**DISCERNMENT = Quality evaluation ability**\nBuild Quality Criteria:\n- Articulate excellence beyond vague terms\n- Create detailed rubrics capturing deep quality markers\n- Document criteria students can internalize/apply\n\nCollect Outstanding Work:\n- Analyze exemplars systematically with students\n- Make expert thinking visible through annotation guides\n\nDiagnose Failures:\n- Study flawed examples forensically\n- Understand failure modes for working alone or with AI\n\n**DESCRIPTION = Field communication mastery**\nMap Discipline Products:\n- Document key field outputs with precision\n- Create templates revealing underlying logic\n- Have students reverse-engineer professional outputs\n\nReveal Expert Thinking:\n- Make expert problem-approach processes visible\n- Document micro-decisions and iterations\n- Create flowcharts of expert thinking\n\nName Field Norms:\n- Surface behaviors defining your field\n- Build behavioral performance modes with students\n\n**DELEGATION = Work decomposition understanding**\nReveal Problem Anatomy:\n- Break challenges into component parts\n- Create problem anatomy diagrams\n- Map AI automation/augmentation/agent possibilities\n\nDesign Decision Trees:\n- Create frameworks for when/how to involve AI\n- Build through case studies making delegation decisions explicit\n\n**DILIGENCE = Field values embodiment**\nCodify Ethical Frameworks:\n- Define field-specific \"do no harm\"\n- Build case studies exploring ethical edges\n- Create ethical decision matrices\n\nClarify Transparency Norms:\n- Document disclosure expectations by field\n- Create AI assistance disclosure templates\n\nCo-Create Accountability Policies:\n- Build standards with students, not impose them\n- Draft policies together\n- Develop peer review protocols\n\n**FEEDBACK LOOP BENEFITS**\nStudents who articulate quality → better evaluate any output\nStudents who understand methods → guide any process effectively \nStudents who internalize ethics → navigate any collaboration responsibly\n\n**EXERCISES**\n\n**Exercise 1: AI Impact Position Paper (40 min)**\nStep 1: Curriculum exploration with AI (10 min)\nStep 2: Pedagogical transformation analysis (10 min) \nStep 3: Assessment strategy reimagining (10 min)\nStep 4: Position synthesis (10 min)\n\n**Exercise 2: Colleague 4D Discussions**\nDiscernment discussion = \"What does quality look like?\"\nDescription discussion = \"How do we communicate?\"\nDelegation discussion = \"What work happens?\"\nDiligence discussion = \"What are our values/standards?\"\n\n**FINAL MESSAGE**\nGoal ≠ preparing students to be replaced by AI\nGoal = preparing students to be irreplaceable\nFuture needs humans who: think critically, communicate clearly, collaborate wisely, act responsibly\n\nHuman expertise + AI fluency = Foundation for thriving in AI-enhanced future\n\n",
"vertex": "\n\nBelow are notes from a video course about working with the Claude language model.\nUse these notes as a resource to answer the user's question.\nWrite your answer as a standalone response - do not refer directly to these notes unless specifically requested by the user.\n\n\nClaude models = 3 families optimized for different priorities\n\n**Opus** = highest intelligence model. For complex multi-step tasks requiring deep reasoning and planning. Can work independently for hours. Supports reasoning capability. Trade-off = higher cost + moderate latency.\n\n**Sonnet** = balanced model. Good intelligence + speed + cost efficiency. Strong coding abilities, precise code edits without breaking functionality. Fast text generation. Sweet spot for most use cases.\n\n**Haiku** = fastest model. Optimized for speed + cost efficiency. No reasoning capabilities. Best for real-time user interactions + high-volume processing.\n\n**Selection framework**: Intelligence priority → Opus. Speed priority → Haiku. Balanced needs → Sonnet.\n\n**Key insight**: Teams often use multiple models in same application. Haiku for user interactions, Sonnet for business logic, Opus for complex reasoning tasks.\n\nAll models share core capabilities = text generation, coding, image analysis.\n\n\n\nAPI Access Flow = 5-step process from user input to response display\n\nStep 1: Client sends user text to developer's server (never access Vertex directly from client - credentials must stay secret)\n\nStep 2: Server makes request to Vertex AI using SDK (Python/TypeScript/Go/Ruby). Required parameters: model name, messages list, max_tokens limit\n\nStep 3: Claude text generation process = 4 stages:\n- Tokenization = input broken into tokens (words/parts/symbols)\n- Embedding = tokens converted to number lists representing all possible meanings\n- Contextualization = embeddings adjusted based on neighboring tokens to determine precise meaning\n- Generation = output layer produces word probabilities, model selects using probability + randomness, adds selected word, repeats process\n\nStep 4: Generation stops when max_tokens reached OR model generates end-of-sequence token\n\nStep 5: API returns response with generated text, usage counts, stop reason. Server forwards to client for display\n\nKey Components:\n- Token = text chunk (word/part/symbol)\n- Embedding = numerical representation of token meanings\n- Contextualization = meaning refinement using surrounding context\n- Max tokens = generation length limit\n- Stop reason = why generation ended\n- Usage = input/output token counts\n\nSecurity: Always route API calls through server, never expose credentials in client applications.\n\n\n\n**Making a Request to Vertex AI Claude**\n\n**Setup Steps:**\n1. Install anthropic SDK: \\`%pip install \"anthropic[vertex]\"\\`\n2. Import and create client: \\`from anthropic import vertex\\` then instantiate with region=\"global\" and project_id\n3. Define model version variable for reuse\n\n**Required Arguments for client.messages.create():**\n- model = specific Claude model version string\n- max_tokens = safety limit on response length (not a target, just maximum)\n- messages = list of message dictionaries\n\n**Message Types:**\n- User message = {role: \"user\", content: \"text written by humans\"}\n- Assistant message = {role: \"assistant\", content: \"text generated by Claude\"}\n\n**Response Access:**\nRaw response contains metadata. Extract generated text with: \\`message.content[0].text\\`\n\n**Key Concepts:**\nMessages = conversation exchanges between user and Claude\nMax tokens = safety mechanism preventing excessive generation\nProject ID = unique identifier from Google Cloud console\n\n\n\nMulti-Turn Conversations = maintaining context across multiple exchanges with Claude\n\nKey constraint: Anthropic API stores no messages. Each request is stateless - no memory of previous exchanges.\n\nProblem: Sending follow-up requests without context produces irrelevant responses since Claude has no memory of prior conversation.\n\nSolution requirements:\n1. Manually maintain message list in your code\n2. Send entire conversation history with every request\n\nImplementation pattern:\n- Create empty messages list\n- Add user message to list\n- Send to Claude, get response\n- Add assistant response to list\n- Add next user message to list\n- Send entire updated list to Claude\n- Repeat\n\nEssential helper functions:\n- add_user_message(messages, text) = appends user message to conversation history\n- add_assistant_message(messages, text) = appends assistant response to conversation history \n- chat(messages) = sends message list to Claude API and returns response\n\nMessage structure = list of dictionaries with \"role\" (user/assistant) and \"content\" fields\n\nContext preservation = including full conversation history in each API call enables Claude to understand references and maintain coherent dialogue flow.\n\n\n\nSystem Prompts = instructions that customize Claude's tone, style, and behavior for specific use cases.\n\nPurpose = control how Claude responds rather than just what it responds with. Example: making Claude act as patient math tutor who gives hints instead of direct answers.\n\nImplementation = pass system prompt as plain string to create function using system keyword argument.\n\nStructure = first line typically assigns Claude a role (\"You are a patient math tutor\"), followed by specific behavioral instructions.\n\nKey principle = system prompts steer Claude's approach - tutor gives guidance and asks leading questions vs directly solving problems.\n\nTechnical consideration = system parameter cannot be None, must conditionally include in API call only when prompt exists.\n\nBest practice = make system prompts configurable rather than hard-coded for reusability across different use cases.\n\nResult = transforms direct question-answer interactions into guided, interactive experiences tailored to specific roles and contexts.\n\n\n\nTemperature = parameter controlling randomness in Claude's text generation, decimal value 0-1\n\nText generation process = tokenization → probability assignment → token selection based on probabilities\n\nTemperature effects:\n- Temperature 0 = deterministic output, always selects highest probability token\n- Higher temperature = increases chance of selecting lower probability tokens, more creative/unexpected outputs\n\nUsage guidelines:\n- Low temperature (near 0) = data extraction, factual tasks, consistent outputs\n- High temperature (near 1) = creative writing, brainstorming, jokes, marketing\n\nImplementation = add temperature parameter to model call function, defaults to 1.0 for creativity\n\nKey insight = higher temperature increases chance of variation but doesn't guarantee it, may need multiple attempts to see creative differences\n\n\n\nResponse Streaming = technique to provide immediate feedback to users during long AI response generation times instead of showing loading spinners for 10-30 seconds.\n\nHow it works: Server sends user message to Claude → Claude immediately sends initial response (no text content, just acknowledgment) → Claude sends stream of events containing text chunks → Server receives events and sends text chunks to frontend → User sees text appear progressively chunk by chunk.\n\nEvent types: message_start, content_block_start, content_block_delta (contains actual text), content_block_stop, message_delta, message_stop.\n\nImplementation: \n- Basic streaming: client.messages.create(model, max_tokens, messages, stream=True) returns iterator of events\n- Text-focused streaming: client.messages.stream() with context manager provides cleaner access to text content via stream.text_stream\n- Final message assembly: stream.get_final_message() collects all chunks into complete message for database storage\n\nKey benefit: Users see immediate progressive response instead of waiting for complete generation, improving user experience in chat interfaces.\n\n\n\nModel output control = two main techniques beyond prompt modification: pre-filling assistant messages and stop sequences.\n\nPre-filling assistant messages = manually adding assistant message at end of message list to steer response direction. Claude treats pre-filled content as already authored and continues from that point. Example: adding \"coffee is better because\" forces Claude to justify coffee preference. Response continues from end of pre-filled text, not complete replacement.\n\nImplementation: Add assistant message with partial content after user message in messages list. Claude sees this as its own previous response and builds upon it.\n\nStop sequences = forcing Claude to halt generation when specific string appears. Provides list of strings that trigger immediate response termination when generated. Generated stop sequence text excluded from final output.\n\nImplementation: Add stop_sequences parameter to API call with list of trigger strings. Generation stops immediately upon encountering any listed sequence.\n\nUse cases: Pre-filling controls response direction/stance. Stop sequences control response length/format by terminating at specific points.\n\n\n\nStructured Data Generation = combining stop sequences + assistant message prefilling to get raw output without commentary.\n\nProblem: Claude naturally adds headers/footers/explanations when generating structured data (JSON, Python, lists). Users often want just the raw content for copy/paste functionality.\n\nSolution Pattern:\n1. Pre-fill assistant message with opening delimiter (e.g., \"\\`\\`\\`json\")\n2. Set stop sequence to match closing delimiter (e.g., \"\\`\\`\\`\")\n3. Claude assumes it already wrote the opening, generates only the content, stops at closing delimiter\n\nResult: Raw structured data with no additional commentary.\n\nExample Flow:\n- User: \"generate event bridge rule as JSON\"\n- Assistant prefill: \"\\`\\`\\`json\"\n- Stop sequence: \"\\`\\`\\`\"\n- Output: Just the JSON content between delimiters\n\nKey Benefits:\n- Eliminates unwanted markdown formatting\n- Removes explanatory text\n- Enables direct copy/paste functionality\n- Works for any structured data type (JSON, code, lists)\n\nImplementation: text.strip() or JSON.loads() can clean up remaining newlines/formatting.\n\nUse Case: Any scenario requiring precise structured output without Claude's natural helpful commentary.\n\n\n\nPrompt Engineering = techniques for writing/editing prompts to help Claude understand requests and desired response format.\n\nPrompt Evaluation = automated testing of prompts using objective metrics to measure effectiveness.\n\nThree paths after writing a prompt:\n1. Test once/twice, deploy to production (trap)\n2. Test with custom inputs, minor tweaks for corner cases (trap) \n3. Run through evaluation pipeline for objective scoring (recommended)\n\nOptions 1 and 2 are common traps - engineers don't test prompts sufficiently before production use.\n\nBest practice = Use evaluation pipeline to get objective performance scores, then iterate on prompt based on results before deployment.\n\nEvaluation comes before engineering in the learning sequence - measure effectiveness first, then learn improvement techniques.\n\n\n\nTypical Eval Workflow = 5-step iterative process for prompt optimization\n\nStep 1: Initial Prompt Draft = Write basic prompt with input variables (example: \"Please answer the user's question [user_input]\")\n\nStep 2: Evaluation Dataset = Create collection of test inputs (3 examples minimum, real-world uses hundreds/thousands). Can be hand-crafted or AI-generated.\n\nStep 3: Prompt Execution = Feed each dataset input through prompt template to create complete prompts, then send to Claude for responses.\n\nStep 4: Grading = Use grader system to score each question-answer pair (typically 1-10 scale). Average all scores for overall prompt performance metric.\n\nStep 5: Iteration = Modify prompt based on results, repeat entire process, compare scores to determine better version.\n\nKey Principles:\n- No standardized methodology across industry\n- Multiple implementation options (open source packages, paid solutions, custom builds)\n- Can start simple in Jupyter notebook before scaling\n- Objective scoring enables data-driven prompt improvement\n- Process repeats until satisfactory performance achieved\n\nWorkflow enables systematic prompt optimization through measurable performance comparison rather than subjective evaluation.\n\n\n\nCustom Prompt Evaluation Workflow = Building system to evaluate AWS code generation prompts\n\nGoal = Help users write AWS-specific code by outputting one of three formats: Python, JSON configuration, or raw regular expressions\n\nPrompt Structure = \"Please provide a solution to the following task: [user task]\" with no additional explanation/headers/footers\n\nTest Dataset = Array of JSON objects with \"task\" property describing desired AWS tasks\n\nDataset Generation Methods = Manual assembly or automatic generation using Claude Haiku (faster model recommended)\n\nImplementation Process:\n1. Create generate_dataset() function with large prompt asking Claude to generate test cases\n2. Use pre-filling technique with assistant message starting \"\\`\\`\\`json\"\n3. Set stop sequence as \"\\`\\`\\`\" to ensure clean JSON output\n4. Parse response with JSON.loads()\n5. Save dataset to file using JSON.dump() for later evaluation use\n\nDataset Structure = [{task: \"description\"}, {task: \"description\"}, ...]\n\nKey Technique = Pre-filling + stop sequences for reliable JSON parsing from LLM responses\n\nNext Step = Use saved dataset file to evaluate prompt performance across all test cases\n\n\n\nTest case = individual record from generated dataset that gets merged with prompt and fed to Claude\n\nrun_prompt function = takes test case, merges with prompt (simple \"please solve the following task\" + test case), sends to Claude, returns output. Currently lacks formatting instructions so returns verbose output.\n\nrun_test_case function = takes individual case, calls run_prompt, grades result (currently hardcoded score of 10), returns dictionary with output/test case/score.\n\nrun_eval function = loads dataset, loops through each test case calling run_test_case, assembles all results into list.\n\nEval pipeline workflow = dataset → merge with prompt → send to Claude → grade results → collect outputs\n\nCurrent limitations = no grading logic implemented (hardcoded scores), no output formatting instructions in prompt, relatively slow execution time (31 seconds with Haiku model).\n\nResults format = array of objects containing Claude output, original test case, and score for each test case.\n\nNext step = implement actual graders to replace hardcoded scoring system.\n\n\n\nModel Based Grading = using AI models to evaluate outputs from other AI models by providing objective scoring signals\n\nThree grader types:\n- Code graders = programmatic checks (length, syntax, readability, word presence)\n- Model graders = additional API calls to evaluate quality, instruction following, completeness \n- Human graders = manual evaluation (flexible but time-consuming)\n\nKey requirements:\n- All graders must return objective signals (typically 1-10 scores)\n- Define evaluation criteria upfront\n- For model graders: use detailed prompts requesting strengths/weaknesses/reasoning to avoid middling scores (models default to ~6 without reasoning requirements)\n\nImplementation pattern:\n1. Create grading function that takes test case + model output\n2. Use structured prompts with role definition + clear evaluation instructions\n3. Extract JSON responses with scores/reasoning\n4. Calculate average scores across test cases for final metric\n\nCommon evaluation criteria = format compliance, syntax validation, task completion accuracy\n\nModel graders offer high flexibility for subjective quality assessment while code graders handle objective validation checks.\n\n\n\nCode Based Grading = system to validate model outputs contain only valid code (Python/JSON/RegEx) without explanations\n\nCore Components:\n- validate_json() = tries JSON parsing, returns 10 if valid, 0 if error\n- validate_python() = tries AST parsing, returns 10 if valid, 0 if error \n- validate_regex() = tries regex compilation, returns 10 if valid, 0 if error\n- grade_syntax() = dispatcher function that calls appropriate validator based on test case format\n\nImplementation Steps:\n1. Add validator functions that attempt parsing/compilation\n2. Update dataset to include \"format\" key specifying expected output type (JSON/Python/RegEx)\n3. Update prompt template to explicitly request only code without commentary\n4. Use pre-filled Assistant message with code blocks and stop sequences\n5. Merge syntax score with model score by averaging\n\nDataset Format = must include format field indicating expected code type for each test case\n\nPrompt Engineering = use \"\\`\\`\\`code\" as pre-filled Assistant message since exact format unknown beforehand\n\nScore Calculation = (model_score + syntax_score) / 2\n\nKey Insight = validates syntax through try/catch parsing rather than complex rule-based validation\n\n\n\nPrompt Engineering = improving prompts to get more reliable, higher quality outputs from language models.\n\nGoal: Generate one-day meal plans for athletes based on height, weight, physical goal, and dietary restrictions.\n\nProcess:\n1. Write initial prompt (poor first attempt)\n2. Evaluate prompt performance \n3. Apply prompt engineering techniques iteratively\n4. Re-evaluate after each improvement\n5. Monitor performance improvements\n\nInitial prompt example: \"What should this person eat?\" + basic parameter interpolation (height, weight, goal, restrictions).\n\nEvaluation setup uses Prompt Evaluator class with configurable concurrency (start low like 3, reduce to 1 if rate limits hit). Extra criteria can specify output requirements like caloric totals, macro breakdowns, exact foods/portions/timing.\n\nExpected pattern: Initial scores are poor, improve systematically through technique application. Output evaluation creates HTML report showing test case results, scores, and reasoning.\n\nKey insight: Start simple, measure performance, then incrementally apply engineering techniques while continuously evaluating improvements.\n\n\n\nBeing Clear and Direct = technique for improving prompt effectiveness by focusing on the first line of prompts.\n\nFirst line importance = most critical part of prompt that sets the foundation for AI response.\n\nStructure = use action verb + simple direct language + clear task description.\n\nAction verbs = write, generate, create, identify, analyze - tells AI exactly what to do.\n\nTask specification = include details about expected output format and content requirements.\n\nExamples:\n- \"Write three paragraphs about how solar panels work\" = action verb + output format + topic\n- \"Identify three countries that use geothermal energy and for each include generation stats\" = action verb + quantity + specific requirements\n\nImplementation = replace vague openings with direct commands that specify both the action and expected deliverable.\n\nResults = significant improvement in prompt performance (example showed increase from 2.32 to 3.92 grade).\n\n\n\nBeing Specific = adding guidelines or steps to direct model output in particular direction\n\nTwo types of guidelines:\n- Type A: Control output attributes (length, structure, qualities)\n- Type B: Provide steps for model to follow (forces consideration of specific elements, improves reasoning quality)\n\nBoth types often combined in professional prompts.\n\nWhen to use:\n- Type A: Almost always - list desired output qualities\n- Type B: Complex problems requiring broader consideration of viewpoints/data beyond model's natural scope\n\nExample improvement: Adding guidelines improved evaluation score from 3.92 to 7.86, demonstrating significant impact on output quality.\n\n\n\nXML Tags for Prompt Structure = technique to organize and clarify different content sections within prompts using custom XML-style tags.\n\nPurpose = helps language models distinguish between different types of interpolated content when large amounts of text are inserted into prompts.\n\nImplementation = wrap content sections with descriptive tags like or rather than dumping raw text.\n\nTag naming = use specific, descriptive names (sales_records > records > data) to provide context about content nature.\n\nUse cases = separating code from documentation, marking athlete information, organizing sales data, any scenario with multiple content types in single prompt.\n\nBenefits = reduces ambiguity about what text serves what purpose, improves model comprehension of prompt structure, can lead to quality improvements especially with simpler models.\n\nBest practice = even for shorter content sections, XML tags can clarify that content represents external input or specific information categories.\n\n\n\nOne-shot/multi-shot prompting = providing examples within prompts to guide model behavior. One-shot = single example, multi-shot = multiple examples.\n\nImplementation = wrap examples in XML tags with sample input and ideal output sections. Structure clearly separates example content from main prompt.\n\nCorner cases = use multi-shot prompting to handle edge cases like sarcasm detection. Add context explaining why specific scenarios need special attention.\n\nComplex outputs = examples especially effective for demonstrating intricate JSON structures or formatting requirements.\n\nPrompt evaluation integration = extract high-scoring test cases from evaluation results to use as examples. Include reasoning explanation of why output is ideal to reinforce desired behavior patterns.\n\nEffectiveness = consistently improves model performance by providing concrete behavioral templates and output format guidance.\n\n\n\nTool use = mechanism allowing Claude to access external information beyond its training data\n\nCore limitation: Claude only knows information from training data, lacks real-time/current information\n\nTool use flow:\n1. Send initial request to Claude + instructions for external data access\n2. Claude determines if external data needed, requests specific information\n3. Server runs code to fetch requested data from external sources\n4. Send follow-up request to Claude with retrieved data\n5. Claude generates final response using original prompt + external data\n\nWeather example:\n- User asks current weather in San Francisco\n- Without tools: Claude responds \"no access to current weather data\"\n- With tools: Claude requests weather data → server calls weather API → Claude receives data → provides current weather response\n\nKey concept: Tools enable Claude to augment responses with real-time external information through structured data retrieval process.\n\n\n\nProject goal = teach Claude to set time-based reminders via tools in Jupyter notebook\n\nTarget interaction = user says \"Set reminder for doctor's appointment, week from Thursday\" → Claude responds \"I will remind you at that point in time\"\n\nThree core problems identified:\n1. Claude lacks precise current time knowledge (knows date, not exact time)\n2. Claude sometimes fails at time-based calculations (e.g., \"379 days from January 13th, 1973\")\n3. Claude has no mechanism to actually set reminders (understands concept but cannot execute)\n\nSolution approach = three dedicated tools:\n1. Get current datetime tool (date + time)\n2. Add duration to datetime tool (handles time calculations)\n3. Reminder setting tool (executes actual reminder creation)\n\nImplementation = one tool at a time, eventually combining multiple tools for complete functionality.\n\n\n\nTool Functions = Python functions executed automatically when Claude needs extra information to help users\n\nKey Components:\n- Tool function = plain Python function that retrieves specific data (e.g., current datetime, weather)\n- Executed when Claude determines it needs additional information to answer user queries\n\nBest Practices:\n1. Use descriptive function/argument names\n2. Validate inputs and raise errors for invalid data\n3. Include meaningful error messages that help Claude correct mistakes\n\nError Handling Benefits:\n- Claude sees exact error messages when tool calls fail\n- Can retry tool calls with corrected parameters based on error feedback\n- Example: \"location cannot be empty\" helps Claude retry with valid location\n\nImplementation Pattern:\n\\`\\`\\`\ndef get_current_datetime(date_format=\"%Y%m%d %H:%M:%S\"):\n if not date_format:\n raise ValueError(\"date format cannot be empty\")\n return datetime.now().strftime(date_format)\n\\`\\`\\`\n\nTool functions should focus on single responsibility (getting datetime, weather, etc.) with proper input validation and clear error messaging for Claude's retry logic.\n\n\n\nTool Schemas = JSON configuration objects that describe tool functions for language models\n\nJSON Schema = data validation specification (not LM-specific) used to validate JSON data. LM community adopted it for tool calling because it's widely understood and convenient.\n\nTool Schema Structure:\n- name: tool function name\n- description: 3-4 sentences explaining what tool does, when to use, what data it returns\n- input_schema: actual JSON schema describing function arguments (type, description for each parameter)\n\nBest Practice: Use 3-4 sentence descriptions for both tool and individual arguments to help Claude understand purpose and usage.\n\nSchema Generation Trick: Ask Claude to write JSON schema for your function + attach Anthropic tool use documentation for best practices. Results in high-quality schemas.\n\nNaming Convention: function_name + function_name_schema for easy tracking.\n\nType Safety: Wrap schema in ToolParam import from anthropic.types to prevent type errors during implementation.\n\n\n\n**Step 3: Calling Claude with Tool Schema**\n\nAPI Request Structure = Include tools parameter with JSON schema list to inform Claude of available tools\n\n**Multi-Block Message Response**\n\nMessage Content Types = Text blocks (user display) + Tool use blocks (function calls)\n\nTool Use Block Contents = Function name + input arguments for execution\n\n**Critical Message History Management**\n\nConversation Persistence = Manual tracking required - Claude stores no history\n\nMulti-Block Handling = Must preserve entire content list including all blocks (text + tool use) when appending to message history\n\nImplementation = messages.append({\"role\": \"assistant\", \"content\": response.content})\n\n**Helper Function Updates Needed**\n\nCurrent Limitation = add_user_message and add_assistant_message only support single text blocks\n\nRequired Fix = Update helpers to handle multiple content blocks per message\n\n\n\nStep 4: Execute tool function that Claude requested. Extract arguments from tool use block using response.content[1].input, then call function with **kwargs syntax to convert dictionary to keyword arguments.\n\nStep 5: Send follow-up request to Claude with full conversation history plus new user message containing tool result block.\n\nTool result block structure:\n- tool_use_id = matches ID from original tool use block (enables Claude to match requests to results when multiple tools called)\n- content = tool function output converted to string \n- is_error = false (default, set true if tool execution failed)\n\nTool use ID system: When Claude makes multiple tool calls, each gets unique ID. Tool results must reference matching IDs so Claude can correlate which result belongs to which request.\n\nComplete flow: Original user message → Assistant message with tool use block → Execute tool function → User message with tool result block → Final assistant response using tool output.\n\nMust include tool schema in all requests once tools introduced, even in follow-up calls.\n\n\n\nMulti-Turn Tool Conversations = system allowing AI to make multiple sequential tool calls within single conversation\n\nProblem: Users submit queries requiring multiple tools. Example: \"What day is 103 days from today?\" needs get_current_datetime tool, then add_duration_to_datetime tool.\n\nProcess Flow:\n1. Claude requests first tool (get_current_datetime)\n2. System executes tool, returns result\n3. Claude requests second tool (add_duration_to_datetime) \n4. System executes tool, returns result\n5. Claude provides final answer\n\nImplementation Pattern:\n- run_conversation function takes initial message list\n- While loop: call Claude, check response\n- If response contains tool_use blocks: execute tools, add results to conversation, continue loop\n- If response contains no tool_use: return final answer to user\n\nRequired Refactoring:\n1. Update add_user_message/add_assistant_message helpers to handle multiple message blocks (text + tool_use blocks)\n2. Modify chat function to accept tool schemas list, return entire message instead of just text\n3. Add text_from_message helper to extract text from multi-block messages\n4. Implement conversation loop supporting sequential tool calls\n\nKey Concept: Unpredictable tool chains require flexible conversation management assuming multiple tool calls per query.\n\n\n\nMultiple Turns = Loop that keeps calling Claude until it stops requesting tools, indicated by stop_reason field\n\nStop Reason = Field in Claude's response indicating why text generation stopped. \"tool_use\" value means Claude wants to call a tool.\n\nRun Conversation Function = Main loop that:\n1. Calls Claude with messages + available tools\n2. Adds assistant response to message history\n3. Checks stop_reason - if not \"tool_use\", breaks loop\n4. If tool_use, calls run_tools function\n5. Adds tool results as user message\n6. Repeats until Claude gives final response\n\nRun Tools Function = Processes multiple tool calls from single message:\n1. Filters message.content for tool_use blocks only\n2. Iterates through each tool request\n3. Runs appropriate tool function using tool request name/input\n4. Creates tool_result blocks with: type=\"tool_result\", tool_use_id=original_id, content=JSON_encoded_output, is_error=false/true\n5. Returns list of all tool result blocks\n\nRun Tool Function = Helper that maps tool names to actual tool functions using if statements. Enables easy scaling to multiple tools.\n\nError Handling = Try/catch around tool execution, setting is_error=true and including error message in content when tools fail.\n\nMessage Flow = User message → Assistant response with tool_use → Tool results as user message → Assistant response (repeat until no tool_use) → Final response.\n\nMulti-block Messages = Single Claude message can contain multiple blocks (text + multiple tool_use blocks). Code must handle extracting and processing all tool_use blocks separately.\n\n\n\nAdding multiple tools to Claude involves updating two key functions after implementing tool schemas and functions.\n\n**Process:**\n1. Add tool schemas to tools list in RunConversation function\n2. Add corresponding function calls to RunTool function using if/elif statements\n3. Tool functions execute and return results when Claude requests them\n\n**Example Implementation:**\n- RunTool checks tool_name, calls appropriate function with **tool_input\n- Pattern: if tool_name == \"ToolName\": return ToolFunction(**tool_input)\n\n**Multi-tool Usage:**\nClaude can chain multiple tools in sequence (e.g., AddDurationToDateTime → SetReminder). Each tool call creates separate message blocks with tool_use and tool_result pairs in conversation history.\n\n**Key Pattern:**\nOnce initial framework established, adding new tools = add schema + add function + update RunTool switch statement. Process becomes standardized and scalable.\n\n\n\nBatch Tool = workaround to make Claude call multiple tools in parallel within single Assistant message\n\nProblem: Claude can technically send multiple tool use blocks in one response but rarely does so in practice. Instead sends separate sequential Assistant messages with single tool uses, creating unnecessary request rounds.\n\nSolution: Implement batch tool that acts as abstraction layer. Claude calls batch tool instead of individual tools directly.\n\nBatch Tool Schema: Takes \"invocations\" parameter = list of objects, each representing another tool to call (tool name + arguments)\n\nImplementation: \n- Add batch tool to available tools list\n- When Claude calls batch tool, extract invocations list\n- Iterate through each invocation, parse JSON arguments, call run_tool() for each\n- Return combined results as single tool result\n\nResult: Claude uses batch tool to parallelize multiple tool calls instead of making separate sequential calls. Reduces request rounds from N+1 to 2 (initial request + batch response).\n\nKey insight: This \"tricks\" Claude into parallel execution by providing higher-level abstraction it's more likely to use than native multiple tool use blocks.\n\n\n\nTools for Structured Data:\n\nAlternative method to extract structured JSON from Claude using tools instead of message pre-fill/stop sequences. More reliable but more complex setup.\n\nCore concept: Create JSON schema spec for tool where inputs match desired output structure. Claude calls tool with structured arguments containing extracted data.\n\nWorkflow:\n1. Write prompt asking Claude to analyze data and call provided tool\n2. Provide JSON schema defining tool inputs (matches desired output structure)\n3. Claude responds with tool_use block containing structured arguments\n4. Extract JSON from tool arguments - no tool_result response needed\n\nKey requirement: Force Claude to call specific tool using tool_choice parameter = {\"type\": \"tool\", \"name\": \"tool_name\"}\n\nSetup steps:\n- Define schema with tool inputs matching desired JSON structure\n- Update chat function to accept tool_choice parameter\n- Pass tool_choice to client.messages.create()\n- Access structured data via response.content[0].input\n\nAdvantage = More reliable structured output\nDisadvantage = More complex setup than prompt-based methods\n\nBoth techniques useful depending on scenario complexity requirements.\n\n\n\nText Editor Tool = Claude's built-in tool for file/text manipulation with wide text editor capabilities (open/read files, edit ranges, add/replace text, create files, undo).\n\nOnly JSON schema built into Claude, not implementation. Developers must write tool function implementation to handle Claude's text editor requests.\n\nSchema stub required based on model version:\n- Claude 3.7: specific date format\n- Claude 3.5: different date format\nSmall schema automatically expands to full schema in Claude.\n\nCapabilities = replicate code editor functionality (file operations, refactoring, testing file creation). Use cases = scenarios without access to full-featured code editors but need programmatic file manipulation.\n\nImplementation class needed with methods: view (file/directory contents), string_replace, create_file, etc.\n\n\n\nWeb Search Tool = built-in Claude tool for searching web to find up-to-date/specialized information\n\nKey Implementation:\n- Requires minimal schema: type=\"web_search_20250305\", name=\"web_search\", max_uses=5\n- No custom implementation needed - Claude handles search execution\n- max_uses = limit on total searches (single search can return multiple results)\n\nResponse Structure:\n- Text blocks = Claude's framing/answers\n- Server tool use blocks = search query inputs\n- Web search tool result blocks = search results with title/URL\n- Citation blocks = supporting text for Claude's statements\n\nSchema Configuration:\n- allowed_domains = constrains search to specific domains (e.g., \"NIH.gov\" for medical content)\n- Improves result quality by limiting to authoritative sources\n\nUI Rendering Best Practice:\n- Display text blocks as plain text\n- Highlight web search result blocks and citations separately\n- Show source domains, titles, URLs, and cited text for transparency\n- Helps users understand information sourcing\n\nUse Case = current events, specialized knowledge, fact-checking with credible sources\n\n\n\nRAG = Retrieval Augmented Generation, technique for querying large documents with LLMs.\n\nProblem: How to extract specific information from large documents (100-1000 pages) for LLM processing.\n\nOption 1 (Direct approach): Feed entire document text into prompt.\n- Limitations: Token limits, decreased effectiveness with long prompts, higher cost, slower processing.\n\nOption 2 (RAG approach): \n- Step 1: Break document into small chunks\n- Step 2: Find most relevant chunks for user question, include only those in prompt\n\nRAG advantages: LLM focuses on relevant content, scales to large/multiple documents, smaller prompts = faster/cheaper processing.\n\nRAG disadvantages: Complex preprocessing required, need search mechanism for chunk retrieval, must define \"relevance\", no guarantee chunks contain complete context, multiple chunking strategies possible (equal portions vs header-based).\n\nKey challenge: Determining optimal chunking strategy and search mechanism for specific use case.\n\nRAG trades simplicity for scalability and efficiency but requires careful implementation evaluation.\n\n\n\nText Chunking = process of dividing source documents into smaller text segments for RAG pipelines\n\nCore Problem: How text is chunked significantly impacts RAG quality. Poor chunking leads to wrong context retrieval (e.g., medical text about \"bugs\" retrieved for software engineering questions due to word overlap)\n\nThree Main Strategies:\n\nSize-based Chunking = dividing documents into equal-length strings\n- Pros: easiest to implement, most common in production\n- Cons: cuts off words mid-sentence, lacks context\n- Solution: overlap strategy = include characters from neighboring chunks to preserve context\n- Trade-off: creates text duplication but improves chunk meaning\n\nStructure-based Chunking = dividing based on document structure (headers, paragraphs, sections)\n- Works well with formatted documents (markdown, clear sections)\n- Limitation: requires structured input, fails with plain text/PDFs\n- Implementation depends on document format guarantees\n\nSemantic-based Chunking = using NLP to group related sentences/sections\n- Most advanced technique\n- Groups consecutive related content\n- Complex implementation, not covered in detail\n\nKey Parameters:\n- Chunk size = length of each text segment\n- Overlap = number of characters shared between adjacent chunks\n- Separation criteria = what defines chunk boundaries\n\nStrategy Selection depends on:\n- Document structure guarantees\n- Input format consistency\n- Use case requirements\n\nDefault recommendation: chunk by character = most reliable across document types despite suboptimal results\n\n\n\nText Embeddings = numerical representation of meaning in text, generated by embedding models\n\nEmbedding Model = takes text input, outputs long list of numbers (values range -1 to +1)\n\nEach Number = score representing some quality/feature of input text (actual qualities unknown but helpful to think as semantic features like happiness, topic relevance, etc.)\n\nSemantic Search = uses text embeddings to find related content by comparing numerical representations rather than exact word matches\n\nRAG Pipeline Process = extract text chunks → user submits query → find related chunks using embeddings → add as context to prompt\n\nGoogle's text-embedding-005 = specific embedding model available on Vertex AI for generating text embeddings\n\nKey Limitation = we don't know what each number in embedding actually represents, but can conceptualize them as semantic quality scores\n\nImplementation = use Google GenAI SDK, create client, pass text through model to get embedding vectors\n\nUse Case = finding text chunks related to user questions by comparing their numerical representations rather than keyword matching\n\n\n\nRAG Pipeline = Complete flow from document processing to query response through embeddings and vector search.\n\nStep 1: Text Chunking = Split source documents into separate text pieces for processing.\n\nStep 2: Embedding Generation = Convert text chunks into numerical vectors using embedding models. Embeddings = numerical representations where each dimension captures semantic meaning.\n\nStep 3: Normalization = Scale embedding vectors to unit length (magnitude = 1.0), typically handled automatically by embedding APIs.\n\nStep 4: Vector Database Storage = Store normalized embeddings in specialized database optimized for numerical vector operations.\n\nStep 5: Query Processing = User submits question, gets embedded using same model as source documents.\n\nStep 6: Similarity Search = Vector database finds most similar stored embeddings to query embedding.\n\nCosine Similarity = Measure of similarity between vectors, calculated as cosine of angle between them. Returns values -1 to 1, where 1 = very similar, -1 = very different.\n\nCosine Distance = 1 minus cosine similarity. Values near 0 = high similarity, larger values = less similarity.\n\nStep 7: Response Generation = Combine user query with most relevant retrieved text chunks in prompt, send to LLM for final response.\n\nKey Point: Preprocessing (steps 1-4) happens ahead of time. Real-time processing only involves steps 5-7 when user submits query.\n\n\n\nRAG Flow Implementation = Complete workflow using vector database for document retrieval\n\n5 Core Steps:\n1. Text Chunking = Split document into sections using chunk_by_section function\n2. Generate Embeddings = Create embeddings for each text chunk using generate_embedding\n3. Vector Store Population = Create vector index instance, loop through chunk-embedding pairs, insert via store.add_vector with embedding + metadata dictionary containing original text\n4. Query Processing = Generate embedding for user question using same generate_embedding function\n5. Similarity Search = Use store.search(user_embedding, num_results) to find most relevant chunks, returns documents with cosine distances\n\nKey Technical Points:\n- Vector DB stores embeddings + original text metadata (embeddings alone not useful for developers)\n- Cosine distance measures similarity (lower = more similar)\n- Multiple chunks returned for comprehensive context\n- Implementation uses class VectorIndex as sample vector database\n\nExample Query: \"What did software engineering department do last year?\" returned section 2 (distance 0.71) and methodology section (distance 0.72) as top matches.\n\nLimitation: Current implementation has scenarios where workflow doesn't work optimally, requiring additional improvements.\n\n\n\nBM25 = Best Match 25, a lexical search algorithm used in RAG pipelines for text-based search complementing semantic search.\n\nProblem with semantic search alone: Can return irrelevant results despite good performance. Example: searching \"incident 2023 Q4 011\" returned correct section 10 but also irrelevant section 3 (financial analysis) that never mentions the incident.\n\nSolution approach: Hybrid search combining semantic search (embeddings + vector database) with lexical search (BM25) running in parallel, then merging results for better balance.\n\nBM25 algorithm steps:\n1. Tokenize user query = break into individual terms by removing punctuation and splitting on spaces\n2. Count term frequency = calculate how often each term appears across all text chunks\n3. Assign importance weights = rare terms get higher importance, common terms (like \"a\") get lower importance\n4. Rank chunks = prioritize chunks containing higher-weighted terms more frequently\n\nKey advantage: BM25 prioritizes chunks with rare, specific terms (like \"incident 2023\") over generic common words, leading to more relevant results for exact term matches.\n\nImplementation: Both semantic and lexical search systems use similar APIs (add_document, search functions) enabling easy integration for hybrid search approach.\n\nNext step: Merge both search systems to get combined benefits of semantic understanding and exact term matching.\n\n\n\nMulti-Index RAG Pipeline = system combining semantic search (vector index) and lexical search (BM25 index) for improved retrieval accuracy.\n\nCore Architecture:\n- Vector Index + BM25 Index = both have identical APIs (add_document, search methods)\n- Retriever Class = wrapper that forwards queries to both indexes and merges results\n- Unified Interface = enables easy addition of new search methodologies\n\nReciprocal Rank Fusion = technique for merging results from different search methods:\n- Formula: Score = sum of (1/(1+rank)) for each search method\n- Process: collect all results → record ranks from each method → apply formula → sort by highest score\n- Example: if doc ranks 1st in vector search and 2nd in BM25, gets higher combined score than doc ranking 2nd and 3rd\n\nBenefits:\n- Improved relevance over single-method search\n- Modular design allows adding new search indexes\n- Maintains consistent API across all components\n\nKey Result: Hybrid approach produces better search results than either semantic or lexical search alone, particularly for complex queries requiring both conceptual understanding and keyword matching.\n\n\n\nReranking = post-processing technique to improve retrieval accuracy by using an LLM to reorder search results based on relevance.\n\nProcess: After hybrid retrieval (vector + BM25), pass top results to Claude with prompt asking to rank documents by relevance to user query. Claude returns reordered list with most relevant documents first.\n\nImplementation details: Use document IDs instead of full text for efficiency - assign random IDs to chunks, ask Claude to return ordered IDs rather than full content. Uses XML formatting for documents in prompt, JSON response with pre-fill and stop sequences.\n\nTrade-offs: Increases search accuracy but adds latency due to LLM call. Particularly effective when semantic understanding needed (example: \"engineering team\" query correctly prioritized software engineering section over cybersecurity).\n\nPrompt structure: User question + candidate documents + instruction to return N most relevant documents in decreasing relevance order.\n\n\n\nContextual Retrieval = RAG improvement technique that adds document context to text chunks before vector storage.\n\nProblem: Document chunking removes context from original source, reducing retrieval accuracy.\n\nSolution: Pre-processing step using LLM to generate contextual information for each chunk.\n\nProcess:\n1. Take individual chunk + original source document\n2. Send to LLM (Claude) with prompt asking to situate chunk within larger document context\n3. LLM generates brief contextual description\n4. Combine generated context + original chunk = contextualized chunk\n5. Store contextualized chunk in vector/BM25 index\n\nLarge Document Handling: When source document too large for single prompt, use selective context:\n- Include starter chunks (1-3) for document summary/abstract\n- Include chunks immediately before target chunk for local context\n- Skip middle chunks that provide less relevant context\n\nImplementation: add_context() function takes chunk + source text, generates context via LLM, concatenates context with original chunk.\n\nBenefit: Maintains document relationships and cross-references within individual chunks, improving retrieval accuracy for complex documents with interconnected sections.\n\n\n\nExtended Thinking = Claude feature that allows reasoning time before generating final response\n\nKey mechanics:\n- Displays separate thinking process in chat UIs\n- User charged for tokens generated during thinking phase\n- Increases accuracy for complex tasks but adds cost and latency\n\nWhen to enable:\n- Use prompt evals first\n- Enable only when accuracy insufficient after prompt optimization efforts\n\nTechnical implementation:\n- Response contains thinking block + text block\n- Thinking block includes cryptographic signature to prevent tampering\n- Claude verifies thinking text hasn't been modified when reused in conversations\n- Minimum thinking budget = 1024 tokens\n- max_tokens must exceed thinking_budget (recommended significant buffer)\n\nSpecial cases:\n- Redacted thinking blocks occur when thinking text flagged by safety systems\n- Redacted content provided in encrypted form to preserve context\n- Test string available to force redacted thinking blocks for testing\n\nCode requirements:\n- Add thinking parameter (default false)\n- Add thinking_budget parameter (minimum 1024)\n- Include thinking object in API params with type=\"enabled\" and budget_tokens value\n- Ensure max_tokens >> thinking_budget for adequate response generation\n\n\n\nClaude Vision Capabilities = ability to send up to 100 images per request to Claude for analysis, comparison, counting, and other visual tasks.\n\nTechnical Requirements = image size/dimension limits exist, images consume tokens based on pixel dimensions (height x width), costs calculated via specific equation.\n\nImage Integration = use image blocks in user messages containing either raw base64 image data or URLs to online images. Multiple image blocks allowed per message.\n\nCritical Success Factor = sophisticated prompting techniques essential for accurate results. Simple prompts typically fail.\n\nPrompting Techniques for Images = provide analysis steps, guidelines, one-shot/multi-shot examples. Structure prompts with specific sequential instructions rather than basic requests.\n\nExample Enhancement Methods = \n- Step-by-step analysis (identify objects, count methodically, verify count with different strategy, compare results)\n- One-shot prompting (show example image with correct answer, then present target image)\n\nMessage Structure = alternate image parts and text parts within single user message for examples and instructions.\n\nReal-world Application Example = wildfire risk assessment using satellite imagery to evaluate tree density, emergency access, roof overhang, and assign numerical risk scores.\n\nKey Takeaway = image accuracy depends entirely on prompt engineering quality, not just image clarity.\n\n\n\nClaude PDF Support = ability to read and process PDF file content directly\n\nImplementation = nearly identical to image processing code with key changes:\n- File type: \"document\" instead of \"image\" \n- Media type: \"application/pdf\" instead of \"image/png\"\n- Variable naming: file_bytes instead of image_bytes\n\nPDF capabilities = extract text, images, charts, tables, and other document elements\n\nUsage pattern = attach PDF file, modify existing image processing code with type/media changes, send to Claude with text prompt\n\nKey benefit = single tool for comprehensive PDF content extraction and analysis\n\n\n\nCitations = Claude feature allowing AI to reference specific source documents when generating responses\n\nCitation purpose = Inform users that AI response comes from actual source rather than just AI memory/training\n\nCitation types:\n- Citation page location = For PDF documents, includes cited text + document index + document title + start/end pages\n- Citation char location = For plain text, includes character position within text block\n\nImplementation = Add citations field with enabled:true to API request along with source document\n\nResponse structure = Content becomes list of text blocks, some containing citations arrays with location data\n\nUser interface benefit = Build popups/overlays showing users exactly which source text supports each AI statement\n\nSupported formats = PDF documents and plain text sources\n\nKey value = Users can verify AI interpretations by checking original source material, ensuring transparency and accuracy\n\n\n\nPrompt caching = feature that speeds up Claude's response and reduces text generation costs by reusing computational work from previous requests.\n\nNormal request process: User sends message → Claude performs extensive internal calculations on input → generates output → discards all computational work → ready for next request.\n\nProblem: When follow-up requests contain previously seen messages, Claude must redo identical calculations it already performed and discarded.\n\nSolution: Prompt caching stores computational work in temporary data store instead of discarding it. When identical input appears in subsequent requests, Claude reuses cached calculations rather than recomputing them.\n\nBenefits: Faster response times, lower costs due to avoiding redundant processing of repeated content.\n\nKey requirement: Input text must be exactly identical to previously cached content for reuse to occur.\n\n\n\nPrompt Caching = system where Claude saves processing work from initial request to reuse in follow-up requests with identical content\n\nCache Duration = 5 minutes temporary storage\n\nActivation = manual cache breakpoint required in message blocks, not enabled by default\n\nText Block Format = must use longhand format {type: \"text\", text: \"content\", cache_control: {...}} instead of shorthand string assignment to add cache control\n\nCache Scope = all content cached up to and including breakpoint, not content after breakpoint\n\nContent Identity Rule = follow-up requests must have identical content up to breakpoint or cache invalidated\n\nBreakpoint Locations = text blocks, image blocks, tool use, tool results, tool schemas, system prompts\n\nProcessing Order = tools → system prompt → messages (joined together behind scenes)\n\nMultiple Breakpoints = up to 4 total breakpoints allowed for granular caching control\n\nMinimum Cache Length = 1024 tokens required for content to be cached\n\nUse Cases = repetitive requests with same content, stable system prompts, unchanging tool schemas\n\n\n\nPrompt Caching Implementation:\n\nCache Breakpoints = multiple cache points in single request (tools + system prompt + messages)\n\nTool Schema Caching:\n- Add cache_control field to LAST tool schema only\n- Best practice = copy tools list first, clone last tool, add cache_control type=\"ephemeral\"\n- Prevents accidental modification of original tool schemas\n\nSystem Prompt Caching:\n- Convert system string to list with text block containing cache_control type=\"ephemeral\"\n- Format: [{\"type\": \"text\", \"text\": system_content, \"cache_control\": {\"type\": \"ephemeral\"}}]\n\nCache Order = tools → system prompt → messages\n\nUsage Patterns:\n- cache_creation_input_tokens = tokens written to cache (first use)\n- cache_read_input_tokens = tokens read from cache (subsequent identical requests)\n- Any change to cached content invalidates cache, forces new cache_creation\n\nToken Counts Example:\n- Base message: ~14 tokens\n- Tool schemas: ~1.7K tokens \n- System prompt: ~6.3K tokens\n\nCache invalidation = any modification to tools/system prompt creates completely new cache breakpoint\n\nUse Cases = identical content across requests (same tools, system prompts, message sequences)\n\n\n\nMCP = Model Context Protocol, communication layer providing Claude with context and tools without requiring developers to write tedious code.\n\nMCP Architecture = client-server model where server contains tools, resources, and prompts.\n\nPrimary Problem Solved = shifts burden of defining and running tools from developer's server to MCP server. Instead of authoring tool schemas and functions yourself, MCP server handles this.\n\nMCP Server = interface to outside service (like GitHub) that wraps functionality into pre-built tools. Eliminates need for developers to author/maintain tool implementations.\n\nWho Creates MCP Servers = anyone, but often service providers make official implementations (e.g., AWS releasing their own MCP server).\n\nMCP vs Direct API Calls = MCP saves development time by providing pre-built tool schemas and function implementations rather than requiring custom authoring.\n\nMCP vs Tool Use = complementary concepts, not identical. MCP focuses on who does the work (pre-built vs custom), while both involve tool usage. Common misconception stems from not understanding MCP's delegation aspect.\n\nKey Benefit = reduces developer burden of creating/maintaining integrations for complex services with extensive functionality.\n\n\n\nMCP Client = communication interface between your server and MCP server, provides access to server's tools\n\nTransport agnostic = client/server can communicate via multiple protocols (stdin/stdout, HTTP, WebSockets, etc.)\n\nCommunication method = message exchange following MCP spec\n\nKey message types:\n- list tools request = client asks server for available tools\n- list tools result = server responds with tool list \n- call tool request = client asks server to run specific tool with arguments\n- call tool result = server returns tool execution results\n\nTypical flow:\n1. User queries your server\n2. Server requests tool list from MCP client\n3. MCP client sends list tools request to MCP server\n4. MCP server responds with available tools\n5. Server sends user query + tools to Claude\n6. Claude requests tool execution\n7. Server asks MCP client to run tool\n8. MCP client sends call tool request to MCP server\n9. MCP server executes tool (e.g., GitHub API call)\n10. Results flow back through chain: MCP server → MCP client → your server → Claude → user\n\nMCP client role = intermediary that translates between your server and MCP server, doesn't execute tools directly\n\n\n\nProject Setup = CLI-based chatbot implementation to understand MCP client-server interaction\n\nComponents = MCP client + custom MCP server in single project\nDocuments = fake documents stored in memory only\nServer tools = read document contents, update document contents\n\nImportant note = typically projects implement either client OR server, not both. This project does both for learning purposes.\n\nSetup steps:\n- Download CLI project.zip starter code\n- Extract and open in code editor\n- Check readme.md for setup directions\n- Add API key to .env file\n- Install dependencies (with/without UV)\n- Run project: \"uv run main.py\" or \"python main.py\"\n- Verify chat prompt appears and responds to queries\n\nProject structure = all files in project directory, ready for feature additions\n\n\n\nMCP Server Implementation = Creating server with Python SDK using single line of code (mcp package)\n\nTool Definition Syntax = Use @mcp.tool decorator with name, description, and typed arguments instead of manual JSON schemas\n\nPython MCP SDK Benefits = Auto-generates JSON schemas from decorators and field types, eliminates manual schema writing\n\nExample Tools Created = read_doc_contents (takes doc_id string, returns document content from in-memory docs dictionary) and edit_document (takes doc_id, old_string, new_string for find/replace operations)\n\nTool Structure = Decorator specifies metadata, function implements logic, Field() from pydantic adds argument descriptions\n\nError Handling = Check if doc_id exists in docs dictionary, raise ValueError if not found\n\nDocument Storage = In-memory dictionary with doc IDs as keys, content as values\n\nImplementation Pattern = @mcp.tool decorator → function definition → typed parameters with Field descriptions → validation logic → core functionality\n\n\n\nMCP Inspector = in-browser debugger for testing MCP servers without connecting to applications\n\nAccess: Run \\`mcp dev [server-file.py]\\` in terminal with Python environment activated → generates local server URL → open in browser\n\nKey features:\n- Connect button = starts MCP server\n- Top menu bar = shows resources, prompts, tools sections\n- Tools section = lists available tools from server\n- Right panel = manual tool invocation interface\n\nTesting workflow:\n1. Click Connect to start server\n2. Navigate to Tools → List Tools\n3. Select specific tool to test\n4. Input required parameters in right panel\n5. Click Run Tool to execute and verify output\n\nTool testing example:\n- read_doc_contents tool: input document ID → returns document contents\n- edit_document tool: input doc ID + old string + new string → modifies document\n- Verify edits by re-running read tool\n\nPurpose = live development and debugging of MCP servers during implementation phase. UI may change as tool is in active development but core functionality remains similar.\n\n\n\nMCP Client Implementation:\n\nMCP Client = wrapper class around client session for resource management and cleanup\nClient Session = actual connection to MCP server from Python SDK, requires resource cleanup\nClient Purpose = exposes server functionality to codebase, bridges server tools to application code\n\nKey Functions:\n- list_tools() = await self.session.list_tools(), returns result.tools\n- call_tool() = await self.session.call_tool(tool_name, tool_input), executes specific tool with Claude-provided parameters\n\nImplementation Pattern:\nClient wraps session → manages connection lifecycle → exposes server tools → enables Claude integration\n\nTesting: Direct file execution tests connection and tool listing functionality\n\nUsage Flow: Application calls client.list_tools() → sends to Claude → Claude requests tool execution → client.call_tool() → returns results to Claude\n\nResource Management: Client handles session cleanup via async context managers (connect, cleanup, async enter/exit functions)\n\n\n\nMCP Resources = mechanism for MCP servers to expose data to clients for read operations\n\nResource Types:\n- Direct/Static Resources = fixed URI, always same address (e.g., docs://documents)\n- Templated Resources = parameterized URI with wildcards (e.g., documents/{doc_id})\n\nResource Flow:\n1. Client sends read resource request with URI to MCP server\n2. Server matches URI to defined resource function\n3. Server executes function and returns data via read resource result\n\nImplementation:\n- Use @mcp.resource decorator with URI and MIME type\n- MIME type = hint about data format (application/json, text/plain, etc.)\n- Templated resource parameters become function keyword arguments\n- MCP SDK auto-serializes return values to strings\n\nExample Use Case:\n- Resource 1: Return list of document names for autocomplete\n- Resource 2: Return specific document content by ID\n- Enables @ mention functionality where users reference documents that get auto-inserted into prompts\n\nKey Points:\n- One resource per distinct read operation\n- Resources expose data, don't modify it\n- Client responsible for deserializing returned data\n- Templated resources enable dynamic content selection\n\n\n\nMCP Resource Access Implementation:\n\nResource fetching = MCP client function reads resources from MCP server by URI, parses content based on MIME type, returns data\n\nKey imports = json module, AnyURL from pydantic for type handling\n\nFunction flow = await self.session.read_resource(AnyURL(uri)) → extract first content from results.contents[0] → check MIME type → parse accordingly\n\nContent parsing logic = if resource is TextResourceContents and mime_type == \"application/json\" → return json.loads(resource.text), else return resource.text as plain text\n\nResponse structure = result.contents list containing resource objects with type and mime_type properties\n\nIntegration = read_resource function called by other application components to fetch document contents for prompts\n\nTesting workflow = CLI shows resource list → user selects with arrow keys/space → resource content sent directly to Claude in prompt without requiring tool calls\n\nCore concept = Resources expose server information to clients, enabling direct content access rather than tool-based retrieval\n\n\n\nMCP Prompts = pre-defined, tested prompts exposed by MCP servers for specialized tasks\n\nPurpose = Allow server authors to create high-quality, domain-specific prompts rather than users writing generic prompts manually\n\nImplementation:\n- Use @prompt decorator with name and description\n- Function receives parameters (like document ID)\n- Returns list of messages (user/assistant format)\n- Import: from mcp.server.fastmcp.prompts import BaseMessage\n\nExample structure:\n\\`\\`\\`\n@prompt(name=\"format\", description=\"rewrites document in markdown\")\ndef format_document(doc_id: str) -> list[BaseMessage]:\n return [BaseMessage.user(prompt_text)]\n\\`\\`\\`\n\nKey benefit = Server authors can create specialized, tested prompts for their domain (document management, etc.) that clients can use via slash commands or direct invocation\n\nFlow = Client requests prompt → Server returns message list → Client sends to LLM → LLM executes using available tools\n\nTesting = Use MCP development inspector to test prompts before deployment\n\n\n\n**Prompts in MCP Client Implementation**\n\nClient-side prompt functions:\n- \\`list_prompts()\\` = await self.session.list_prompts(), return result.props\n- \\`get_prompt()\\` = await self.session.get_prompt(prompt_name, arguments), return result.messages\n\n**Prompt workflow:**\n1. Define prompt in MCP server with variables (e.g., document_id)\n2. Client calls get_prompt with prompt name + arguments dictionary\n3. Arguments interpolated into prompt function as keyword arguments\n4. Returns messages fed directly to Claude\n\n**Example usage:**\nFormat command → select document → prompt with document ID passed to Claude → Claude uses tools to fetch document → reformats with requested styling\n\n**Key concept:**\nPrompts = server-defined templates that clients can invoke with runtime arguments, enabling dynamic prompt generation with variable substitution.\n\n\n\nMCP Server Primitives = three core components with distinct control patterns and purposes.\n\nTools = model-controlled actions. Claude decides when to execute based on conversation needs. Purpose: add capabilities to AI model (e.g., JavaScript execution for calculations). Implementation: define tools in MCP server for model consumption.\n\nResources = app-controlled data access. Application code decides when to fetch and use data. Purpose: provide data for UI elements or prompt augmentation (e.g., autocomplete options, document listings, Google Drive integration). Implementation: fetch resources to populate app interfaces.\n\nPrompts = user-controlled workflows. Users trigger through UI buttons, menu options, or slash commands. Purpose: implement predefined workflows and optimized conversation starters. Implementation: create prompt templates for common user actions.\n\nControl Pattern Summary:\n- Tools serve the model\n- Resources serve the app \n- Prompts serve the users\n\nUsage Guidelines: Need AI capabilities → implement tools. Need app data → use resources. Need user workflows → create prompts.\n\n\n\nWorkflows and agents = strategies for handling user tasks that can't be completed by Claude in a single request.\n\nDecision rule: Use workflows when you know exact task steps ahead of time. Use agents when task details are uncertain.\n\nWorkflow = series of calls to Claude for specific problems where all steps are predetermined and plannable.\n\nAgent = letting Claude figure out how to complete tasks using provided tools (like the tools examples in previous course modules).\n\nExample workflow: Image-to-3D model converter\n- Step 1: Claude describes uploaded metal part image in detail\n- Step 2: Claude uses CADQuery Python library to create 3D model from description\n- Step 3: Generate rendering of model as image\n- Step 4: Claude compares rendering to original image\n- Step 5: If inaccurate, return to Step 2 with feedback; if accurate, output step file\n\nThis follows evaluator-optimizer pattern:\n- Producer = creates output (Claude + CADQuery modeling)\n- Evaluator = judges output quality (Claude comparing images)\n- Loop continues until evaluator accepts output\n\nKey point: Workflows are just proven patterns other engineers have used successfully. You still must write the actual implementation code yourself.\n\n\n\nParallelization Workflows = breaking one complex task into multiple parallel subtasks, then aggregating results\n\nCore Pattern:\n- Split complex analysis into specialized parallel requests\n- Each subtask focuses on one specific aspect\n- Aggregator step combines all results into final output\n\nExample Implementation:\n- Original approach: single large prompt asking Claude to analyze image and recommend best material (metal/polymer/ceramic/etc.)\n- Parallelized approach: separate simultaneous requests, each evaluating image suitability for ONE material type\n- Final step: feed all individual analyses back to Claude for final recommendation\n\nKey Benefits:\n1. Focus = each request handles single task vs. juggling multiple considerations\n2. Optimization = can improve/evaluate each specialized prompt independently \n3. Scalability = easy to add new subtasks without affecting existing ones\n\nStructure: Input → Multiple Parallel Subtasks → Aggregator → Final Output\n\nBest for scenarios where complex decision requires evaluating multiple independent criteria or options simultaneously.\n\n\n\nChaining Workflows = breaking large tasks into sequential distinct steps rather than single complex prompts.\n\nKey structure: One main task → Multiple sequential subtasks → Each step feeds into next step.\n\nExample workflow: User topic input → Twitter trending search → Claude selects best topic → Claude researches topic → Claude writes script → AI creates video → Post to social media.\n\nPrimary benefit = allows AI to focus on one task at a time rather than juggling multiple requirements simultaneously.\n\nCritical use case: Large prompts with many constraints where AI consistently violates some requirements despite repeated instructions.\n\nSolution pattern: \n1. Send initial complex prompt with all constraints\n2. Accept imperfect output that violates some constraints \n3. Follow-up prompt asking AI to fix specific violations in previous output\n4. AI focuses solely on correction tasks\n\nWhy this works = AI performs better when addressing focused corrections rather than managing numerous simultaneous constraints in single prompt.\n\nMost useful when = AI consistently ignores certain constraints despite clear instructions in complex prompts.\n\n\n\nRouting Workflows = workflow pattern that categorizes user input to determine appropriate processing pipeline\n\nProcess:\n1. User provides input/topic\n2. Routing step = AI call to categorize input into predefined genres/categories\n3. Based on category, input gets forwarded to specialized processing pipeline\n4. Each pipeline has customized prompts/tools for that category type\n\nExample: Social media video script generation\n- Programming topic → Educational category → Educational script prompt (clear explanations, definitions, examples)\n- Surfing topic → Entertainment category → Entertainment script prompt (trendy language, engaging hooks)\n\nKey components:\n- Predefined categories/genres for classification\n- Category-specific prompts tailored to expected output style\n- Single routing decision determines entire downstream processing\n- Each route can have different workflows/tools specialized for that task type\n\nPurpose = Ensures output matches nature/style appropriate for input type rather than one-size-fits-all approach\n\n\n\nAgents = AI systems that use tools to complete tasks when exact steps are unknown, unlike workflows which need precise predetermined steps.\n\nKey difference: Workflows = known step sequences, Agents = flexible tool combination for unknown step sequences.\n\nAgent advantages: Flexibility to solve wide variety of tasks using same toolset. Claude creates plans dynamically using available tools.\n\nTool abstraction principle: Agents need abstract/general tools rather than hyper-specialized ones. Example: Claude code uses bash, web fetch, file write (abstract) rather than specific refactor or install tools.\n\nTool combination examples: With get_current_datetime, add_duration, set_reminder tools, Claude can handle \"what time is it\" (single tool) or \"remind me gym next Wednesday\" (multiple tools + planning).\n\nDynamic interaction capability: Agents can request additional user information when needed, like asking warranty purchase date to calculate expiration.\n\nBest practice: Provide small set of abstract tools that can be combined creatively rather than many specialized single-purpose tools.\n\nReal example: Social media video agent with bash/FFmpeg, generate_image, text_to_speech, post_media tools enables both simple \"create video\" and complex \"generate sample cover first for approval\" workflows.\n\n\n\nEnvironment Inspection = agents examining their environment state after (or before) taking actions to understand results and progress.\n\nCore concept: Agents need feedback beyond tool return values to understand action outcomes and current state.\n\nComputer use example: Claude takes screenshot after every action (typing, clicking) because it cannot predict how actions change the environment. Button clicks might navigate pages or open menus - screenshot reveals new state.\n\nCode editing example: Before modifying files, agents must read current file contents to understand existing state.\n\nSocial media video agent applications:\n- Use Whisper CPP via bash tool to generate timestamped captions, verify audio placement\n- Use FFmpeg to extract video screenshots at intervals, verify visual output\n- Inspect generated videos to ensure task completion quality\n\nBenefits: Better progress tracking, error handling, unexpected result management through environment state awareness.\n\n\n\nWorkflows = pre-defined series of calls to Claude for tasks with known step sequences. Agents = flexible systems using basic tools that Claude combines creatively for unknown tasks.\n\nKey differences:\n\nTask approach: Workflows divide big tasks into smaller, specific subtasks for focused execution. Agents handle varied challenges through creative tool combination.\n\nAccuracy: Workflows achieve higher accuracy due to focused, specific steps. Agents have lower successful completion rates due to delegated complexity.\n\nTesting: Workflows easier to test/evaluate with known step sequences. Agents harder to test due to unpredictable execution paths.\n\nFlexibility: Workflows require specific inputs, fixed sequences. Agents adapt to varied user queries, can request additional input, flexible UX.\n\nReliability: Workflows more reliable for consistent task completion. Agents more experimental but less dependable.\n\nRecommendation: Prioritize workflows when possible for reliable problem-solving. Use agents only when flexibility truly required. Users want 100% working products over fancy but unreliable agents.\n\n"
};
const T1 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382027%2FThumb_v1_L1.1777382027832.png";
const S1 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382028%2Flesson1.1777382028458.png";
const T2 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382028%2FThumb_v1_L2.1777382028804.png";
const S2 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382029%2Flesson2.1777382029433.png";
const T3 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382029%2FThumb_v1_L3.1777382029810.png";
const S3 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382030%2Flesson3.1777382030402.png";
const T4 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382030%2FThumb_v1_L4.1777382030903.png";
const S4 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382031%2Flesson4.1777382031499.png";
const T5 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382031%2FThumb_v1_L5.1777382031855.png";
const S5 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382032%2Flesson5.1777382032774.png";
const T6 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382033%2FThumb_v1_L6.1777382033103.png";
const S6 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382033%2Flesson6.1777382033700.png";
const T7 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382034%2FThumb_v1_L7.1777382034062.png";
const S7 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382034%2Flesson7.1777382034672.png";
const T8 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382035%2FThumb_v1_L8.1777382035188.png";
const S8 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382035%2Flesson8.1777382035808.png";
const T9 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382036%2FThumb_v1_L9.1777382036731.png";
const S9 = "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1777382037%2Flesson9.1777382037298.png";
const shot = (id, url, alt) => ({ id, url, fullSizeUrl: url, alt });
const aiCapabilitiesAndLimitations = {
path: "/ai-capabilities-and-limitations",
previewId: "103846",
usesAlternateLayout: true,
title: "AI Capabilities and Limitations",
subtitle: "An introductory course about how AI works",
overview: {
description:
"Most people's first experience with a generative AI system is a mix of delight and confusion. It produces a polished summary of a dense report in seconds, then confidently invents a citation that doesn't exist. It follows a detailed instruction perfectly, then ignores a simple one in the very next message. Without a mental model of what's happening underneath, these moments feel random — and it's hard to know whether to trust the next output, or how to fix the last one.
This course gives learners that mental model. It's the companion to AI Fluency: Framework & Foundations: where that course teaches the human competencies (Delegation, Description, Discernment, Diligence), this one teaches the machine properties those competencies are responding to. The two are designed to be taken in either order, and together they form a complete picture of effective human-AI collaboration.
We organize the course around four properties that shape what an AI system can and can't do for you: Next Token Prediction (where AI answers come from), Knowledge (what the model actually knows, and why it can be confidently wrong), Working Memory (what it's paying attention to right now, and what falls off the edge), and Steerability (how much control your instructions really give you). Each property sits on a spectrum from capability to limitation, and each section pairs a short explanation with a hands-on exercise so you can feel where the edges are rather than just read about them.
The final section looks at what happens when these properties collide — because in real use, they always do. A long document pushes against working memory while also straying into knowledge the model doesn't have; a vague instruction tests steerability at the same moment next-token prediction is reaching for whatever sounds most plausible. We close with a practical diagnostic: how to look at an unexpected output, recognize which kind of unexpected it is, locate roughly where on the capability-to-limitation continuum your task landed, and respond with a targeted fix instead of a generic retry.
Recommended prerequisites
None. This course assumes no technical background and no prior experience with AI tools. If you've already completed AI Fluency: Framework & Foundations, you'll recognize where each property connects to the 4Ds — but it's not required.
Who this is for
Anyone who uses, or is about to start using, generative AI in their work or studies and wants to understand why it behaves the way it does. Educators, students, knowledge workers, and team leads will all find the same core model useful, because the properties it describes don't change across use cases.
",
},
stats: {
lectureCount: 13,
videoHours: 0.25,
quizCount: 1,
},
sections: [
{
id: "section-1",
title: "Getting started",
lessonCount: 3,
description:
"The word 'AI' covers a lot of ground. This section narrows it to the kind of system you'll actually be working with — large language models — and explains how two training stages, pretraining and fine-tuning, turn a raw text predictor into the helpful assistant you interact with. Along the way you'll meet the four-property framework that organizes the rest of the course.",
screenshots: [
shot("s1-t1", T1, "Lesson 1 video thumbnail"),
shot("s1-l2", S2, "Lesson 2 screenshot"),
shot("s1-l3", S3, "Lesson 3 screenshot"),
],
},
{
id: "section-2",
title: "Next Token Prediction",
lessonCount: 2,
description:
"Every answer an AI gives is built one token at a time, by predicting what should come next. This section shows what that means in practice: why the model is excellent at well-worn paths like summarizing or reformatting, why it can produce things that sound true but aren't, and how to recognize when a task is pushing into territory where prediction alone isn't enough.",
screenshots: [
shot("s2-t4", T4, "Lesson 4 video thumbnail"),
shot("s2-l4", S4, "Lesson 4 screenshot"),
],
},
{
id: "section-3",
title: "Knowledge",
lessonCount: 2,
description:
"A model knows what was in its training data — frequently, recently, and consistently. This section unpacks what that implies: it's strong on mainstream topics and popular languages, weaker on anything rare, recent, niche, or contested. You'll practice judging where a question sits on that spectrum, so you know when to trust the answer and when to bring your own sources.",
screenshots: [
shot("s3-t5", T5, "Lesson 5 video thumbnail"),
shot("s3-l5", S5, "Lesson 5 screenshot"),
],
},
{
id: "section-4",
title: "Working Memory",
lessonCount: 2,
description:
"The context window is the model's working memory: everything it can pay attention to right now, and nothing else. This section covers what fits, what quietly falls off the edge, why attention isn't uniform across a long document, and why a fresh session doesn't remember the last one. You'll learn to size up a task against the window before you start, instead of discovering the limit mid-conversation.",
screenshots: [
shot("s4-t6", T6, "Lesson 6 video thumbnail"),
shot("s4-l6", S6, "Lesson 6 screenshot"),
],
},
{
id: "section-5",
title: "Steerability",
lessonCount: 2,
description:
"Your instructions are how you steer — but not all instructions land equally. Short, concrete, verifiable asks ('respond as a table', 'under 100 words') work reliably; long reasoning chains, abstract requests, and demands for native precision are where steering starts to slip. This section helps you tell the difference and rewrite a wobbly instruction into one the model can actually follow.",
screenshots: [
shot("s5-t7", T7, "Lesson 7 video thumbnail"),
shot("s5-l7", S7, "Lesson 7 screenshot"),
],
},
{
id: "section-6",
title: "Putting it all together and next steps",
lessonCount: 2,
description:
"Real tasks rarely test one property at a time. A long contract review strains working memory while reaching past the model's knowledge; a vague creative brief tests steerability right where next-token prediction wants to fill in something plausible. This section shows you how the four properties collide, and gives you a diagnostic for any unexpected output: name which property is in play, place the task on its spectrum, and apply a targeted fix instead of just trying again.",
screenshots: [
shot("s6-t8", T8, "Lesson 8 video thumbnail"),
shot("s6-l9", S9, "Lesson 9 screenshot"),
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[aiCapabilitiesAndLimitations["path"]] =
aiCapabilitiesAndLimitations;
const aiFluencyForEducators = {
path: "/ai-fluency-for-educators",
previewId: "77953",
usesAlternateLayout: true,
llmContentKey: "aif4ed",
title: "AI Fluency for Educators",
subtitle:
"This course empowers faculty, instructional designers, and educational leaders to apply AI Fluency into their own teaching practice and institutional strategy.",
overview: {
description:
"At Anthropic, we believe that empowering people with AI, and ensuring that AI makes safe contributions to society, requires engaging with a wide range of human perspectives and experiences. Responsible AI development and engagement isn't something any single discipline or viewpoint can fully address. It demands collaborative approaches that span a wide range of technical, creative, business, scientific, and educational domains. That's why we partnered with educators who bring complementary expertise to create this course on AI collaboration for educators.
This course empowers faculty, instructional designers, and educational leaders to apply the 4D Framework to their own educational practice. Participants will learn to apply the 4D Framework to their own teaching practice, using AI as a thinking partner to enhance course design, create coherent learning materials, and develop authentic assessments while modeling responsible AI collaboration for their students.
This course is the result of a long partnership between Anthropic and professors Rick Dakan from Ringling College of Art and Design and Joseph Feller from University College Cork. It builds on their experiences in training fellow educators and teaching the AI Fluency Framework to their students, and on feedback and questions that arose from our earlier course: AI Fluency: Framework & Foundations This course answers the question: how can I apply this framework to my personal teaching practice?
The work was supported in part by the Higher Education Authority (Ireland) through the National Forum for the Enhancement of Teaching and Learning.
Recommended prerequisites
This course lightly covers the foundational AI Fluency concepts. However, for deeper understanding, participants should complete AI Fluency: Framework & Foundations before beginning this educator-focused curriculum.
It is also recommended that learners have active teaching or curriculum development responsibilities as well as access to an AI chat tool for hands-on practice. Examples in this course will use Claude.ai, but any chatbot will work.
",
},
stats: {
lectureCount: 4,
videoHours: 0.4,
},
sections: [
{
id: "section-1",
title: "Introduction and AI Fluency Framework",
lessonCount: 2,
description:
"A summary of Delegation, Description, Discernment, and Diligence applied to student contexts",
screenshots: [
{
id: "s1-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/01-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/01-01.webp",
alt: "Section 1 screenshot 1",
},
{
id: "s1-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/01-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/01-02.webp",
alt: "Section 1 screenshot 2",
},
{
id: "s1-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/01-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/01-03.webp",
alt: "Section 1 screenshot 3",
},
],
},
{
id: "section-2",
title: "AI Fluency Framework applications for educators",
lessonCount: 2,
description:
"Applying the 4D framework to course design and learning materials.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/02-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/02-01.webp",
alt: "Section 2 screenshot 1",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/02-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/02-02.webp",
alt: "Section 2 screenshot 2",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/02-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-educators/02-03.webp",
alt: "Section 2 screenshot 3",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[aiFluencyForEducators["path"]] = aiFluencyForEducators;
const aiFluencyForNonprofits = {
path: "/ai-fluency-for-nonprofits",
previewId: "89476",
usesAlternateLayout: true,
title: "AI Fluency for nonprofits",
subtitle:
"This course empowers nonprofit professionals to develop AI fluency in order to increase organizational impact and efficiency while staying true to their mission and values.",
overview: {
description: `At Anthropic, we believe that empowering people with AI, and ensuring that AI makes safe contributions to society, requires engaging with a wide range of human perspectives and experiences. Nonprofit professionals are uniquely positioned to leverage AI for social good—but only if they can approach it intentionally, with resilience and clear purpose.
This course helps nonprofit staff—whether in fundraising, communications, program delivery, operations, or leadership—build practical AI collaboration skills through the 4D Framework (Delegation, Description, Discernment, and Diligence). In this course, we'll explore how the framework applies to common non-profit tasks, and consider what it means to implement AI across a nonprofit organization.
This course is the result of a partnership between Anthropic and GivingTuesday, drawing on research with nonprofit professionals about their actual needs, concerns, and aspirations for AI adoption.
The work builds on our AI Fluency: Framework & Foundations course, adapted specifically for the nonprofit context where limited resources, multiple stakeholder accountabilities, and mission-driven work create unique considerations for AI collaboration.
Recommended prerequisites
This course lightly covers the foundational AI Fluency concepts. However, for deeper understanding, participants should complete AI Fluency: Framework & Foundations before beginning this nonprofit-focused curriculum.
It is also recommended that learners have access to an AI chat tool for hands-on practice. Examples in this course will use Claude.ai, but any chatbot will work.
`,
},
stats: {
lectureCount: 9,
videoHours: 0.9,
quizCount: 1,
},
instructors: [
{
name: "Kelsey Kramer",
avatar: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/kelsey.webp",
description:
"Kelsey directs partnerships for the GivingTuesday Data Commons, supporting a vibrant network of collaborators that power the Data Commons' mission to utilize data to build a more resilient social sector. She engages data and research partners, movement leaders, and strategic collaborators to build new initiatives, support ongoing research, and connect research to practice—bringing 10 years of experience from nonprofits and technology companies large and small.",
},
{
name: "Zoe Ludwig",
avatar: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/zoe.webp",
description:
"Zoe Ludwig leads Anthropic's Claude apps education, including AI Fluency work. She has a range of experience in educational roles including classroom instruction, curriculum design, and instructor led training. Prior to Anthropic, she founded and led the customer education team at Notion.",
},
],
sections: [
{
id: "section-1",
title: "Introduction",
lessonCount: 2,
description: "Define AI Fluency and learn the four interconnected competencies—Delegation, Description, Discernment, and Diligence—that form the foundation of this course.",
screenshots: [
{
id: "s1-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s1-1-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s1-1.webp",
alt: "Section 1 screenshot 1",
},
{
id: "s1-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s1-2-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s1-2.webp",
alt: "Section 1 screenshot 2",
},
{
id: "s1-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s1-3-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s1-3.webp",
alt: "Section 1 screenshot 3",
},
],
},
{
id: "section-2",
title: "Description-Discernment",
lessonCount: 2,
description: "Practice crafting context-rich prompts and critically evaluating AI outputs through research and writing examples.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s2-1-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s2-1.webp",
alt: "Section 2 screenshot 1",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s2-2-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s2-2.webp",
alt: "Section 2 screenshot 2",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s2-3-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s2-3.webp",
alt: "Section 2 screenshot 3",
},
],
},
{
id: "section-3",
title: "Delegation-Diligence",
lessonCount: 2,
description: "Make thoughtful decisions about what tasks to delegate to AI while taking responsibility for high-stakes considerations like data privacy and analytical accuracy.",
screenshots: [
{
id: "s3-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s3-1-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s3-1.webp",
alt: "Section 3 screenshot 1",
},
{
id: "s3-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s3-2-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s3-2.webp",
alt: "Section 3 screenshot 2",
},
{
id: "s3-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s3-3-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s3-3.webp",
alt: "Section 3 screenshot 3",
},
],
},
{
id: "section-4",
title: "Putting it all together",
lessonCount: 3,
description: "Apply all four dimensions of the 4D Framework to automate workflows and integrate AI thoughtfully into your organization.",
screenshots: [
{
id: "s4-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s4-1-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s4-1.webp",
alt: "Section 4 screenshot 1",
},
{
id: "s4-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s4-2-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s4-2.webp",
alt: "Section 4 screenshot 2",
},
{
id: "s4-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s4-3-medium.webp",
fullSizeUrl: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-nonprofits/s4-3.webp",
alt: "Section 4 screenshot 3",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[aiFluencyForNonprofits["path"]] = aiFluencyForNonprofits;
const aiFluencyForSmallBusinesses = {
path: "/ai-fluency-for-small-businesses",
previewId: "109367",
usesAlternateLayout: true,
title: "AI Fluency for Small Businesses",
subtitle:
"This course empowers small businesses to develop AI fluency in order to increase organizational impact and efficiency while staying true to their mission and values.",
overview: {
description: `At Anthropic, we believe that empowering people with AI, and ensuring that AI makes safe contributions to society, requires engaging with a wide range of human perspectives and experiences. Small businesses are uniquely positioned to leverage AI to advance their mission—but only if they can approach it intentionally, with resilience and clear purpose.
This course helps small business staff—whether in customer interactions, back-office management, supply chain operations, or leadership—build practical AI collaboration skills through the 4D Framework (Delegation, Description, Discernment, and Diligence). In this course, we'll explore how the framework applies to common small business tasks, and consider what it means to implement AI across a small business.
This course is the result of a partnership between Anthropic, PayPal, Prospect Butcher, and MAKS Enterprises TIPM Rebuilders, drawing on research with small business professionals about their actual needs, concerns, and aspirations for AI adoption.
The work builds on our AI Fluency: Framework & Foundations course, adapted specifically for the small business context where limited resources, business accountabilities, and customer experience create unique considerations for AI collaboration.
Recommended prerequisites
This course lightly covers the foundational AI Fluency concepts. However, for deeper understanding, participants should complete AI Fluency: Framework & Foundations before beginning this small business-focused curriculum.
It is also recommended that learners have access to an AI chat tool for hands-on practice. Examples in this course will use Claude.ai, but any chatbot will work.
`,
},
stats: {
lectureCount: 9,
videoHours: 0.9,
quizCount: 1,
},
coreLearningAreas: [],
extra: [
{
title: "About the partners",
content:
'This course was created in partnership between Anthropic, PayPal, Prospect Butcher Company, and MAKS TIPM Rebuilders. Anthropic is a frontier AI safety company and the maker of Claude. PayPal is a platform that helps businesses of all sizes make selling and shopping simple and secure. Prospect Butcher Company and MAKS TIPM Rebuilders are the two small businesses featured throughout the course — a Brooklyn butcher shop and an automotive power-module rebuilder, each using AI to grow.
',
},
{
title: "AI diligence statement",
content:
"In the development of the AI Fluency: Framework and Foundations course, we engaged in extensive collaboration with Claude from Anthropic.
The base content for this course came from:
- The AI Fluency Framework Practical Summary Document by Rick Dakan (at Ringling College of Art and Design) and Joseph Feller (at University College Cork) and related working documents and research notes.
- Technical/practical content provided by Kristen Swanson and Kyra Atekwana (Anthropic). Knowledge about AI in the small business setting came from Mak Cabessa (MAKS TIPM Rebuilders), Corey Hammond (Prospect Butcher Company), and Jordan Medina (PayPal).
Throughout this process, Claude assisted one or more of the human authors with structural development, resource and exercise design, and content drafting, critiquing, editing and rewriting. The human authors wrote, designed, edited and provided continual vision, expertise, critical judgment, and domain knowledge and made all final decisions about both content and approach.
All AI-generated and co-created content underwent thorough validation, editing, and curation by the human authors. The final materials accurately reflect the human authors' understanding, expertise, and intended pedagogical approach. While AI assistance was instrumental in producing these materials, the human authors maintain responsibility for the content.
This disclosure is made in the spirit of transparency advocated by the AI Fluency Framework and to acknowledge the evolving role of AI in educational content development and other creative and intellectual work.
",
},
],
sections: [
{
id: "section-1",
title: "Introduction and the AI Fluency framework",
lessonCount: 2,
description:
"Define AI Fluency and learn the four interconnected competencies—Delegation, Description, Discernment, and Diligence—that ground every productive AI collaboration in your business. You'll articulate your values, goals, and constraints so every future AI interaction starts from the right context.",
screenshots: [
{
id: "s1-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646111%2F01-01-medium.1778646111548.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646112%2F01-01.1778646112026.webp",
alt: "A course for small business owners — built with the business community and Anthropic's research team",
},
{
id: "s1-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646112%2F01-02-medium.1778646112785.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646113%2F01-02.1778646113139.webp",
alt: "The 4D Framework — Delegation, Description, Discernment, Diligence",
},
],
},
{
id: "section-2",
title: "How AI works",
lessonCount: 2,
description:
"Build a working mental model of what today's AI can and can't do reliably, and explore hands-on with an interactive next-token simulator so you understand why those limits matter for how you put it to work in your business.",
screenshots: [
{
id: "s2-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646114%2F02-01-medium.1778646113970.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646114%2F02-01.1778646114477.webp",
alt: "The AI context window — your prompts, AI responses, and any other info you've shared",
},
{
id: "s2-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646115%2F02-02-medium.1778646115026.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646115%2F02-02.1778646115552.webp",
alt: "Build confidence in AI capabilities by starting small, comparing, iterating, and refining",
},
],
},
{
id: "section-3",
title: "Using AI in practice",
lessonCount: 2,
description:
"Apply the Description-Discernment loop to real research and the Delegation-Diligence loop to working with customer data—practicing context-rich prompting, critical evaluation, and responsible data handling on the kinds of tasks you face every day.",
screenshots: [
{
id: "s3-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646116%2F03-01-medium.1778646115949.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646116%2F03-01.1778646116574.webp",
alt: "Essential lessons of the Description-Discernment loop",
},
{
id: "s3-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778681899%2F03-02-medium.1778681899403.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778681900%2F03-02.1778681900029.webp",
alt: "The Delegation-Diligence loop — instructors from MAKS Enterprises and Anthropic",
},
],
},
{
id: "section-4",
title: "Putting it all together",
lessonCount: 3,
description:
"Bring all four dimensions of the 4D Framework together to build a repeatable AI-augmented workflow and a short, honest AI use policy that fits your business and your team—then plan your next steps and earn your certificate of completion.",
screenshots: [
{
id: "s4-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646118%2F04-01-medium.1778646118478.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646119%2F04-01.1778646119188.webp",
alt: "Real small business example — Prospect Butcher Co.'s vendor and billing workflow",
},
{
id: "s4-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646119%2F04-02-medium.1778646119600.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778646120%2F04-02.1778646119980.webp",
alt: "What the human in the loop does — decide, evaluate, and maintain expertise",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[aiFluencyForSmallBusinesses["path"]] =
aiFluencyForSmallBusinesses;
const aiFluencyForStudents = {
path: "/ai-fluency-for-students",
previewId: "77955",
usesAlternateLayout: true,
llmContentKey: "aif4students",
title: "AI Fluency for Students",
subtitle:
"This course empowers students to develop AI Fluency skills that enhance learning, career planning, and academic success through responsible AI collaboration.",
overview: {
description:
"You've probably tried AI—maybe to help with an essay, solve a problem, or just explore what it can do. But there's a difference between using AI and being fluent with it. This course teaches students how to collaborate with AI effectively, efficiently, ethically, and safely across learning and career contexts.
Rather than focusing on shortcuts or prompt tricks, this course develops lasting skills through the 4D Framework (Delegation, Description, Discernment, and Diligence). Students learn to use AI as a thinking partner that enhances their learning and career development rather than replacing their own critical thinking and creativity.
Through practical applications in academic work and career planning, students discover how to leverage AI to understand concepts more deeply, develop professional skills, and prepare for a future where AI Fluency is essential. The course emphasizes being 'the human in the loop'— maintaining agency, judgment, and responsibility while working thoughtfully with AI systems.
This course is the result of a long partnership between Anthropic and professors Rick Dakan from Ringling College of Art and Design and Joseph Feller from University College Cork. It addresses the fundamental question students face: how can I use AI to genuinely enhance my learning and career success without compromising my own growth and integrity?
The work was supported in part by the Higher Education Authority (Ireland) through the National Forum for the Enhancement of Teaching and Learning.
Recommended prerequisites
This course lightly covers the foundational AI Fluency concepts. However, for deeper understanding, participants should complete AI Fluency: Framework & Foundations before beginning this student-focused curriculum.
It is also recommended that learners have access to an AI chat tool for hands-on practice. Examples in this course will use Claude.ai, but any chatbot will work.
",
},
stats: {
lectureCount: 5,
videoHours: 0.5,
},
sections: [
{
id: "section-1",
title: "Introduction and AI Fluency Framework",
lessonCount: 2,
description:
"A summary of Delegation, Description, Discernment, and Diligence applied to student contexts",
screenshots: [
{
id: "s1-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/01-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/01-01.webp",
alt: "Section 1 screenshot 1",
},
{
id: "s1-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/01-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/01-02.webp",
alt: "Section 1 screenshot 2",
},
{
id: "s1-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/01-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/01-03.webp",
alt: "Section 1 screenshot 3",
},
],
},
{
id: "section-2",
title: "AI Fluency Framework applications for students",
lessonCount: 2,
description: "Applying the 4D framework to learning and career planning.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/02-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/02-01.webp",
alt: "Section 2 screenshot 1",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/02-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/02-02.webp",
alt: "Section 2 screenshot 2",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/02-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/02-03.webp",
alt: "Section 2 screenshot 3",
},
],
},
{
id: "section-3",
title: "Conclusion",
lessonCount: 1,
description:
"Developing personal commitments for responsible AI collaboration and maintaining agency.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/03-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/03-01.webp",
alt: "Section 3 screenshot 1",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/03-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/03-02.webp",
alt: "Section 3 screenshot 2",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/03-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-for-students/03-03.webp",
alt: "Section 3 screenshot 3",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[aiFluencyForStudents["path"]] = aiFluencyForStudents;
const aiFluencyFrameworkFoundationsData = {
path: "/ai-fluency-framework-foundations",
previewId: "68809",
usesAlternateLayout: true,
title: "AI Fluency: Framework & Foundations",
subtitle:
"Learn to collaborate with AI systems effectively, efficiently, ethically, and safely",
overview: {
description:
"At Anthropic, we believe that empowering people with AI, and ensuring that AI makes safe contributions to society, requires engaging with a wide range of human perspectives and experiences. Responsible AI development and engagement isn't something any single discipline or viewpoint can fully address. It demands collaborative approaches that span a wide range of technical, creative, business, scientific, and educational domains. That's why we partnered with educators who bring complementary expertise to create this foundational course on AI collaboration.
This course is the result of a long partnership between Anthropic and professors Rick Dakan from Ringling College of Art and Design and Joseph Feller from University College Cork. Rick and Joe developed the AI Fluency Framework in 2023-2024, based on their research exploring how AI tools like Claude were transforming creative and business processes. When we saw the framework, we immediately recognized a shared vision: helping people interact with AI effectively and responsibly, beyond just “cool prompts.” Their framework offered exactly the kind of multidisciplinary perspective we believe is essential for navigating AI’s impact on society.
The AI Fluency Framework they created — four interconnected competencies (Delegation, Description, Discernment, and Diligence) — enables more effective, efficient, ethical, and safe human-AI collaboration, regardless of which new AI models or tools emerge. We collaborated to develop this course based on their framework, bringing together our collective expertise in AI systems, education, creativity, and business innovation. The work was supported in part by the Higher Education Authority (Ireland) through the National Forum for the Enhancement of Teaching and Learning.
This framework has already informed undergraduate and postgraduate courses at both Ringling College and University College Cork, as well as staff training initiatives and community outreach events. Now, we’re excited to share these insights more broadly through this open online course.
Our goal is to make AI Fluency accessible and useful to everyone, no matter what stage of AI expertise you find yourself at. We hope you find it valuable in navigating the evolving landscape of AI collaboration.
",
},
stats: {
lectureCount: 14,
videoHours: 1.1,
quizCount: 1,
},
instructors: [
{
name: "Drew Bent",
description:
"Drew leads education research at Anthropic. He previously co-founded the tutoring non-profit Schoolhouse.world with Sal Khan, which he ran from 2020-24 and now sits on the board. Prior to that, he wrote code at Khan Academy, taught high school math, and has been tutoring students for over a decade. Drew has degrees in physics & CS from MIT, and an education master's from Stanford.",
avatar:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/drew_bent_o-medium.webp",
},
{
name: "Rick Dakan",
description:
"Rick is the AI Coordinator and a professor at Ringling College of Art and Design in Sarasota, Florida where he teaches creative writing, interactive experience design, and AI courses. He also oversees the college's Undergraduate Certificate in Artificial Intelligence and the Professional Certificate in Fundamentals of AI for Creatives. He is a game designer and author of more than thirty games and books from video games and tabletop games to novels, nonfiction, and comics.",
avatar:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/rick_dakan_o-medium.webp",
},
{
name: "Joseph Feller",
description:
"Joseph is Professor of Information Systems and Digital Transformation at the Cork University Business School, University College Cork, Ireland. His current work focuses on AI-human hybrid creativity, innovation, and learning. His research has been published in Information Systems Research, Journal of MIS, Journal of the AIS, Journal of Information Technology, Information Systems Journal, European Journal of Information Systems, and Journal of Strategic Information Systems, and has been funded by the European Commission, Irish Research Council, Irish HEA, and other funding bodies.",
avatar:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/joseph_feller_o-medium.webp",
},
{
name: "Maggie Vo",
description:
"Maggie founded and leads Anthropic's education team. She has a varied applied research background from Harvard University, with a career and education that spans fields such as game design, organizational behavior, tech and consumer goods, and human behavioral psychology. Maggie has held previous roles at top consulting firms and innovative startups alike. Prior to Anthropic, she worked in AI strategy consulting.",
avatar:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/maggie_vo_o-medium.webp",
},
],
extra: {
title: "AI diligence statement",
content:
"In the development of the AI Fluency: Framework and Foundations course, we engaged in extensive collaboration with Claude 3.7 from Anthropic.
The base content for this course came from:
- The AI Fluency Framework Practical Summary Document by Rick Dakan (at Ringling College of Art and Design) and Joseph Feller (at University College Cork) and related working documents and research notes
- Slide decks and lecture transcripts from multiple university courses, guest lectures, and research talks delivered by Feller and/or Dakan
- Technical/practical content provided by Maggie Vo and Drew Bent (Anthropic)
Throughout this process, Claude assisted one or more of the human authors with structural development, resource and exercise design, and content drafting, critiquing, editing and rewriting. The human authors wrote, designed, edited and provided continual vision, expertise, critical judgment, and domain knowledge and made all final decisions about both content and approach.
All AI-generated and co-created content underwent thorough validation, editing, and curation by the human authors. The final materials accurately reflect the human authors' understanding, expertise, and intended pedagogical approach. While AI assistance was instrumental in producing these materials, the human authors maintain responsibility for the content.
This disclosure is made in the spirit of transparency advocated by the AI Fluency Framework and to acknowledge the evolving role of AI in educational content development and other creative and intellectual work.
",
},
sections: [
{
id: "section-1",
title: "AI Fundamentals & Framework",
lessonCount: 10,
description:
"Establish foundational understanding of generative AI systems and why developing AI fluency matters for effective collaboration. Introduces the 4D Framework as a structured approach to human-AI interaction, covering core capabilities and limitations of current AI technologies. Provides the conceptual grounding needed to approach AI tools strategically rather than reactively.",
screenshots: [
{
id: "s1-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/01-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/01-01.webp",
alt: "Three ways to interact with ai",
},
{
id: "s1-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/01-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/01-02.webp",
alt: "key takeaways",
},
{
id: "s1-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/01-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/01-03.webp",
alt: "three pillars that make ai possible",
},
],
},
{
id: "section-2",
title: "Practical AI Skills",
lessonCount: 10,
description:
"Develop hands-on competencies for effective AI collaboration through the four core areas of the framework: delegation, description, discernment, and diligence. Learn systematic approaches to project planning with AI, crafting effective prompts, evaluating outputs critically, and iterating through the description-discernment loop. Emphasizes practical application across creative, business, and educational contexts.",
screenshots: [
{
id: "s1-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/02-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/02-01.webp",
alt: "product descriptions",
},
{
id: "s1-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/02-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/02-02.webp",
alt: "foundational prompting tips",
},
{
id: "s1-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/02-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/ai-fluency-framework-foundations/02-03.webp",
alt: "creation diligence",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[aiFluencyFrameworkFoundationsData["path"]] =
aiFluencyFrameworkFoundationsData;
const claudeCode101 = {
path: "/claude-code-101",
previewId: "106034",
usesAlternateLayout: true,
title: "Claude Code 101",
subtitle:
"Learn how to use Claude Code effectively in your daily development workflow.",
overview: {
description:
"AI coding agents are changing what it means to write software. Tasks that used to take an afternoon — tracing a bug across a large codebase, scaffolding a new service, reviewing a stack of pull requests — can now happen in a single focused session, with an agent that reads your code, runs your commands, and edits files alongside you. But getting real value from an agent requires more than installing it and typing a request. It requires understanding how the agent thinks, what context it has access to, and how to steer it when it heads in the wrong direction.
This course teaches developers how to use Claude Code effectively, whether you're new to software engineering or an experienced engineer who hasn't yet worked with AI coding agents. We start from first principles — what an agentic loop actually is, how the context window shapes what Claude can see, how tools and permissions determine what it can do — so that the techniques later in the course make sense rather than feeling like a list of tricks to memorize.
You'll learn how to install Claude Code across multiple environments (terminal, VS Code, JetBrains, Claude Desktop, and the web), and how to write prompts that get good results on the first try using approval mode, auto-accept, and Plan Mode. The core of the course is the Explore → Plan → Code → Commit workflow: a repeatable rhythm for breaking down a task, letting Claude propose an approach, reviewing the work as it happens, and landing it cleanly. We also cover code review with Claude Code and the context-management commands (/compact, /clear, /context) that keep long sessions productive.
The final section is about making Claude Code your own. You'll write a CLAUDE.md file so Claude remembers your project's conventions across sessions, build custom subagents and skills for tasks you repeat often, connect external systems through MCP servers, and write hooks that add deterministic guardrails around what Claude is allowed to do. By the end, you'll have a setup tailored to how you actually work — not a generic install.
Recommended prerequisites
Basic familiarity with a code editor and the command line. You'll also need a Claude account (Pro, Max, or Enterprise) or an API key. No prior experience with AI tools is assumed.
Who this is for
New developers entering software engineering who want AI-assisted workflows from the start, and experienced engineers curious about coding agents but who haven't taken the plunge yet. If you've tried a coding assistant before and found the results underwhelming, this course is designed to show you what changes when you work with an agent rather than against it.
",
},
stats: {
lectureCount: 12,
videoHours: 1.5,
quizCount: 1,
},
sections: [
{
id: "section-1",
title: "What is Claude Code?",
lessonCount: 2,
description:
"Before you write your first prompt, it helps to know what's actually happening when Claude Code runs. This section explains what separates an AI coding agent from a chat-based assistant, then walks through the agentic loop — gather context, take action, verify results — and the tools and permissions that govern each step. You'll come away with a mental model that makes everything in the rest of the course click.",
screenshots: [
{
id: "s1-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748058%2F01-01-medium.1775748058806.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748059%2F01-01.1775748059030.webp",
alt: "What is Claude Code? introduction video",
},
{
id: "s1-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748059%2F01-02-medium.1775748059276.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748059%2F01-02.1775748059497.webp",
alt: "Agentic loop diagram: gather context, take action, verify results",
},
],
},
{
id: "section-2",
title: "Your first prompt",
lessonCount: 2,
description:
"Get Claude Code running wherever you already work — in the terminal, inside VS Code or JetBrains, in Claude Desktop, or on the web. Then write your first prompt and see how approval mode, auto-accept, and Plan Mode change the way Claude responds, so you can pick the right level of oversight for the task in front of you.",
screenshots: [
{
id: "s2-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748060%2F02-01-medium.1775748060012.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748060%2F02-01.1775748060215.webp",
alt: "Installing Claude Code from the terminal",
},
{
id: "s2-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748060%2F02-02-medium.1775748060468.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748060%2F02-02.1775748060698.webp",
alt: "Claude in Chrome browser extension",
},
],
},
{
id: "section-3",
title: "Daily workflows",
lessonCount: 3,
description:
"This is where Claude Code becomes part of how you ship. Learn the Explore → Plan → Code → Commit rhythm for tackling real tasks, use the context-management commands to keep long sessions fast and focused, and put Claude to work reviewing code — your own and your teammates' — before it lands.",
screenshots: [
{
id: "s3-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748061%2F03-01-medium.1775748060923.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748061%2F03-01.1775748061158.webp",
alt: "Spawning a code-reviewer subagent in Claude Code",
},
],
},
{
id: "section-4",
title: "Customizing Claude Code",
lessonCount: 5,
description:
"Out of the box, Claude Code is general-purpose. This section shows you how to make it yours: write a CLAUDE.md file so it remembers your project's conventions, build subagents and skills for the workflows you repeat, wire in external systems through MCP servers, and add hooks for deterministic guardrails. By the end you'll have a setup tuned to the way your team actually works.",
screenshots: [
{
id: "s4-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748061%2F04-01-medium.1775748061356.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748061%2F04-01.1775748061603.webp",
alt: "Editing a CLAUDE.md project memory file in VS Code",
},
{
id: "s4-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748061%2F04-02-medium.1775748061832.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748062%2F04-02.1775748062142.webp",
alt: "Connecting Claude Code to a Linear MCP server",
},
{
id: "s4-3",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748062%2F04-03-medium.1775748062359.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1775748063%2F04-03.1775748062927.webp",
alt: "Configuring hooks in .claude/settings.json",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[claudeCode101["path"]] = claudeCode101;
const claudeCodeInActionData = {
path: "/claude-code-in-action",
llmContentKey: "claudecode",
title: "Claude Code in Action",
subtitle:
"Practical walkthrough of using There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.
This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.
You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.
The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.
The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.
Comfort reading and writing code in at least one language, plus basic command-line familiarity. The demos use the TypeScript SDK (@anthropic-ai/sdk) with Node and npm. You don't need to be a TypeScript expert, but you should be able to follow along and run a script. (The platform also offers a Python SDK; the course examples are in TypeScript.) You'll need an Anthropic Console account and an API key from platform.claude.com, plus a small amount of prepaid credit to run the examples. You don't need prior experience building with LLMs.
Developers who've used Claude in a chat window and want to build it into their own applications, whether you're adding AI features to an existing product or prototyping an agent from scratch. If you've sent a handful of API calls but stalled at \"how do I make this act on its own\" or \"how do I connect it to my real systems,\" this course is the bridge from a single request to a production agent. You don't need prior agent experience; each lesson builds on the one before it.
",
},
stats: {
lectureCount: 12,
videoHours: 0.6,
quizCount: 1,
},
coreLearningAreas: [],
sections: [
{
id: "section-1",
title: "What is the Claude Developer Platform?",
lessonCount: 3,
description:
"Get clear on what the platform is and how it differs from the chat app you've already used. Send your first messages.create call, then pick the right model — Opus, Sonnet, or Haiku — by running a quick eval instead of guessing.",
screenshots: [
{
id: "s1-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977598%2F01-01-medium.1780977596628.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977599%2F01-01.1780977596979.webp",
alt: "Navigating the Claude Console",
},
{
id: "s1-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977599%2F01-02-medium.1780977597280.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977599%2F01-02.1780977597555.webp",
alt: "Your first messages.create API call",
},
{
id: "s1-3",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977600%2F01-03-medium.1780977598182.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977600%2F01-03.1780977598773.webp",
alt: "Choosing between Haiku, Sonnet, and Opus",
},
],
},
{
id: "section-2",
title: "Teaching your Agent",
lessonCount: 3,
description:
"This is where a single request becomes an agent. Build the agent loop by hand, define your own tools, collapse the scaffolding with the SDK's Tool Runner, and turn on extended thinking for the problems that need it.",
screenshots: [
{
id: "s2-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977601%2F02-01-medium.1780977599447.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977601%2F02-01.1780977599723.webp",
alt: "The agent loop: user, agent, and tools in conversation",
},
{
id: "s2-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977602%2F02-02-medium.1780977600314.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977602%2F02-02.1780977600552.webp",
alt: "Declaring tools in the request body",
},
{
id: "s2-3",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977602%2F02-03-medium.1780977600830.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977603%2F02-03.1780977601085.webp",
alt: "An extended thinking block in the response",
},
],
},
{
id: "section-3",
title: "Extending your Agent",
lessonCount: 4,
description:
"Reach past your own code with Anthropic's built-in tools, Skills that package a procedure once, and MCP servers that connect Claude to third-party services. Finish with the context-management patterns that keep a long-running agent inside the window and affordable.",
screenshots: [
{
id: "s3-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977603%2F03-01-medium.1780977601370.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977603%2F03-01.1780977601669.webp",
alt: "Anthropic's built-in tools",
},
{
id: "s3-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977604%2F03-02-medium.1780977601971.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977604%2F03-02.1780977602196.webp",
alt: "Connecting Slack, Asana, and Google Calendar via MCP",
},
{
id: "s3-3",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977604%2F03-03-medium.1780977602430.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977604%2F03-03.1780977602660.webp",
alt: "The four context-management patterns",
},
],
},
{
id: "section-4",
title: "Managed Agents",
lessonCount: 2,
description:
"Up to now you've run the loop yourself — managed agents hand it to Anthropic. Learn when that trade is worth it, then build one end to end and consume the event stream as it runs in a sandbox.",
screenshots: [
{
id: "s4-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977605%2F04-01-medium.1780977603498.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977606%2F04-01.1780977604049.webp",
alt: "Managed Agents in the Claude Console",
},
{
id: "s4-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977606%2F04-02-medium.1780977604375.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977606%2F04-02.1780977604644.webp",
alt: "Two managed agent sessions running in parallel on a Kanban demo",
},
{
id: "s4-3",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977607%2F04-03-medium.1780977605388.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977607%2F04-03.1780977605635.webp",
alt: "Managed agent architecture: session, environment, and event stream",
},
],
},
{
id: "section-5",
title: "Building with Claude Code",
lessonCount: 1,
description:
"A short capstone that ties the course together: stub a file, hand it to Claude Code with one well-formed prompt, and review the diff. It calls the same primitives you built by hand — Claude Code skips the keystrokes, not the understanding.",
screenshots: [
{
id: "s5-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977607%2F05-01-medium.1780977605871.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977608%2F05-01.1780977606118.webp",
alt: "The Claude Code welcome screen",
},
{
id: "s5-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977608%2F05-02-medium.1780977606358.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977608%2F05-02.1780977606595.webp",
alt: "Claude Code reading the stubbed files mid-run",
},
{
id: "s5-3",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977608%2F05-03-medium.1780977606873.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1780977609%2F05-03.1780977607474.webp",
alt: "The generated Zod weather tool",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[claudePlatform101["path"]] = claudePlatform101;
const claudeWithAmazonBedrock = {
path: "/claude-in-amazon-bedrock",
llmContentKey: "bedrock",
title: "Claude with Amazon Bedrock",
subtitle:
"This comprehensive course covers the full spectrum of working with Anthropic models using Amazon Bedrock",
overview: {
description:
"This course covers using Claude models through AWS Bedrock API, from basic requests through advanced agent implementations. You'll learn to make API calls, implement tool use, build RAG pipelines, work with MCP servers, and leverage features like Claude Code and computer use for automation.",
learningObjectives: [
"Make requests to Claude models via AWS Bedrock using boto3",
"Implement multi-turn conversations, streaming responses, and structured data extraction",
"Build and evaluate prompts using automated testing pipelines with objective scoring",
"Create custom tools and handle multi-step tool execution workflows",
"Design RAG systems with text chunking, embeddings, and hybrid search (semantic + BM25)",
"Connect Claude to external services using MCP (Model Context Protocol) servers",
"Use Claude Code for automated development workflows and parallelized task execution",
"Configure and optimize features like prompt caching, extended thinking, and image processing",
"Implement computer use for automated testing and UI interaction",
],
prerequisites: [
"Proficiency in Python programming",
"Basic knowledge of handling JSON data",
"AWS account with Bedrock access",
],
targetAudience: "Devs who want to add AI features to their apps",
},
stats: {
lectureCount: 85,
videoHours: 8.0,
quizCount: 10,
},
sections: [
{
id: "section-2",
title: "Getting started with Amazon Bedrock",
lessonCount: 16,
description:
"Start here for the fundamentals. Covers API authentication, basic requests, conversation management, system prompts, and structured output generation.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/02-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/02-01.webp",
alt: "Section 2 screenshot 1",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/02-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/02-02.webp",
alt: "Section 2 screenshot 2",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/02-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/02-03.webp",
alt: "Section 2 screenshot 3",
},
],
},
{
id: "section-3",
title: "Prompt engineering & evaluation",
lessonCount: 16,
description:
"Learn to write prompts that actually work. Focuses on prompting strategies, evaluation frameworks, and systematic testing approaches.",
screenshots: [
{
id: "s3-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/03-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/03-01.webp",
alt: "Section 3 screenshot 1",
},
{
id: "s3-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/03-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/03-02.webp",
alt: "Section 3 screenshot 2",
},
{
id: "s3-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/03-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/03-03.webp",
alt: "Section 3 screenshot 3",
},
],
},
{
id: "section-4",
title: "Tool use with Claude",
lessonCount: 14,
description:
"Extend Claude with custom tools and functions. Build apps with function calling, multi-turn tool interactions, batch tool calling, and leverage built-in utilities.",
screenshots: [
{
id: "s4-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/04-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/04-01.webp",
alt: "Section 4 screenshot 1",
},
{
id: "s4-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/04-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/04-02.webp",
alt: "Section 4 screenshot 2",
},
{
id: "s4-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/04-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/04-03.webp",
alt: "Section 4 screenshot 3",
},
],
},
{
id: "section-5",
title: "Retrieval augmented generation",
lessonCount: 10,
description:
"Implementation guide for production RAG systems. Covers text chunking, embeddings, hybrid search with BM25, multi-index architectures, reranking, and contextual retrieval.",
screenshots: [
{
id: "s5-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/05-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/05-01.webp",
alt: "Section 5 screenshot 1",
},
{
id: "s5-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/05-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/05-02.webp",
alt: "Section 5 screenshot 2",
},
{
id: "s5-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/05-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/05-03.webp",
alt: "Section 5 screenshot 3",
},
],
},
{
id: "section-6",
title: "Model Context Protocol (MCP)",
lessonCount: 12,
description:
"The protocol for building modular AI applications. Define custom tools and resources, implement MCP servers and clients, handle the full integration lifecycle.",
screenshots: [
{
id: "s6-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/06-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/06-01.webp",
alt: "Section 6 screenshot 1",
},
{
id: "s6-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/06-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/06-02.webp",
alt: "Section 6 screenshot 2",
},
{
id: "s6-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/06-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/06-03.webp",
alt: "Section 6 screenshot 3",
},
],
},
{
id: "section-7",
title: "Claude Code & Computer Use",
lessonCount: 8,
description:
"Two powerful Anthropic tools in action. Claude Code accelerates development workflows, Computer Use automates UI interactions. Includes MCP integration patterns.",
screenshots: [
{
id: "s7-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/07-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/07-01.webp",
alt: "Section 7 screenshot 1",
},
{
id: "s7-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/07-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/07-02.webp",
alt: "Section 7 screenshot 2",
},
{
id: "s7-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/07-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-in-amazon-bedrock/07-03.webp",
alt: "Section 7 screenshot 3",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[claudeWithAmazonBedrock["path"]] = claudeWithAmazonBedrock;
const claudeWithGoogleCloudsVertexAi = {
path: "/claude-with-google-vertex",
llmContentKey: "vertex",
title: "Claude with Google Cloud's Vertex AI",
subtitle:
"This comprehensive course covers the full spectrum of working with Anthropic models using Google Cloud's Vertex AI",
overview: {
description:
"This course covers using Claude models through Google Cloud's Vertex AI platform. You'll implement core API features like streaming and tool use, build systematic prompt evaluation pipelines, understand RAG systems, and investigate agent architectures.",
learningObjectives: [
"Set up and authenticate Claude through Vertex AI using the Anthropic SDK",
"Select appropriate Claude models based on intelligence, speed, and cost trade-offs",
"Write and systematically evaluate prompts using objective scoring metrics",
"Implement tool calling for web search, file operations, and custom functionality",
"Build RAG pipelines with text chunking, embeddings, and hybrid search",
"Use advanced features like extended thinking, citations, and prompt caching",
"Connect Claude to external services using MCP (Model Context Protocol)",
"Design workflows for known task sequences and agents for flexible problem-solving",
],
prerequisites: [
"Proficiency in Python programming",
"Basic knowledge of handling JSON data",
"A Google Cloud account with Vertex AI access",
],
targetAudience: "Devs who want to add AI features to their apps",
},
stats: {
lectureCount: 85,
videoHours: 8.0,
quizCount: 10,
},
sections: [
{
id: "section-2",
title: "Getting started with Claude",
lessonCount: 16,
description:
"Start here for the fundamentals. Covers API authentication, basic requests, conversation management, system prompts, and structured output generation.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/02-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/02-01.webp",
alt: "Section 2 screenshot 1",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/02-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/02-02.webp",
alt: "Section 2 screenshot 2",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/02-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/02-03.webp",
alt: "Section 2 screenshot 3",
},
],
},
{
id: "section-3",
title: "Prompt engineering & evaluation",
lessonCount: 16,
description:
"Learn to write prompts that actually work. Focuses on prompting strategies, evaluation frameworks, and systematic testing approaches.",
screenshots: [
{
id: "s3-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/03-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/03-01.webp",
alt: "Section 3 screenshot 1",
},
{
id: "s3-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/03-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/03-02.webp",
alt: "Section 3 screenshot 2",
},
{
id: "s3-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/03-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/03-03.webp",
alt: "Section 3 screenshot 3",
},
],
},
{
id: "section-4",
title: "Tool use with Claude",
lessonCount: 14,
description:
"Extend Claude with custom tools and functions. Build apps with function calling, multi-turn tool interactions, batch tool calling, and leverage built-in utilities.",
screenshots: [
{
id: "s4-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/04-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/04-01.webp",
alt: "Section 4 screenshot 1",
},
{
id: "s4-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/04-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/04-02.webp",
alt: "Section 4 screenshot 2",
},
{
id: "s4-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/04-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/04-03.webp",
alt: "Section 4 screenshot 3",
},
],
},
{
id: "section-5",
title: "Retrieval augmented generation",
lessonCount: 10,
description:
"Implementation guide for production RAG systems. Covers text chunking, embeddings, hybrid search with BM25, multi-index architectures, reranking, and contextual retrieval.",
screenshots: [
{
id: "s5-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/05-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/05-01.webp",
alt: "Section 5 screenshot 1",
},
{
id: "s5-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/05-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/05-02.webp",
alt: "Section 5 screenshot 2",
},
{
id: "s5-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/05-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/05-03.webp",
alt: "Section 5 screenshot 3",
},
],
},
{
id: "section-6",
title: "Model Context Protocol (MCP)",
lessonCount: 12,
description:
"The protocol for building modular AI applications. Define custom tools and resources, implement MCP servers and clients, handle the full integration lifecycle.",
screenshots: [
{
id: "s6-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/06-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/06-01.webp",
alt: "Section 6 screenshot 1",
},
{
id: "s6-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/06-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/06-02.webp",
alt: "Section 6 screenshot 2",
},
{
id: "s6-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/06-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/06-03.webp",
alt: "Section 6 screenshot 3",
},
],
},
{
id: "section-7",
title: "Claude Code & Computer Use",
lessonCount: 8,
description:
"Two powerful Anthropic tools in action. Claude Code accelerates development workflows, Computer Use automates UI interactions. Includes MCP integration patterns.",
screenshots: [
{
id: "s7-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/07-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/07-01.webp",
alt: "Section 7 screenshot 1",
},
{
id: "s7-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/07-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/07-02.webp",
alt: "Section 7 screenshot 2",
},
{
id: "s7-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/07-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/07-03.webp",
alt: "Section 7 screenshot 3",
},
],
},
{
id: "section-8",
title: "Agents and workflows",
lessonCount: 11,
description:
"Architecture patterns for autonomous AI systems. Understand parallel execution, operation chaining, conditional routing, and effective debugging strategies.",
screenshots: [
{
id: "s8-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/08-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/08-01.webp",
alt: "Section 8 screenshot 1",
},
{
id: "s8-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/08-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/08-02.webp",
alt: "Section 8 screenshot 2",
},
{
id: "s8-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/08-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-google-vertex/08-03.webp",
alt: "Section 8 screenshot 3",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[claudeWithGoogleCloudsVertexAi["path"]] =
claudeWithGoogleCloudsVertexAi;
const claudeWithTheAnthropicApiData = {
path: "/claude-with-the-anthropic-api",
llmContentKey: "1p",
title: "Building with the Claude API",
subtitle:
"This comprehensive course covers the full spectrum of working with Anthropic models using the Claude API",
overview: {
description:
"This course provides comprehensive coverage of the Claude API, from basic usage through advanced agent architectures. You'll learn to integrate Claude into applications, implement tool calling, build RAG pipelines, and design both deterministic workflows and flexible agent systems.",
learningObjectives: [
"Make API requests to Claude models and handle responses",
"Implement multi-turn conversations, streaming, and structured output generation",
"Build and evaluate prompts systematically using automated testing pipelines",
"Create custom tools and integrate Claude with external services",
"Design and implement RAG systems with hybrid search and reranking",
"Use MCP (Model Context Protocol) to connect Claude to various data sources",
"Understand common workflows and agent architectures",
],
prerequisites: [
"Proficiency in Python programming",
"Basic knowledge of handling JSON data",
"Access to an Anthropic API key",
],
targetAudience:
"Software engineers who need to integrate Claude into production applications. Whether you're building chatbots, automation tools, or AI-powered features, this course covers the implementation patterns you'll need.",
},
stats: {
lectureCount: 84,
videoHours: 8.1,
quizCount: 10,
},
sections: [
{
id: "section-2",
title: "Getting started with Claude",
lessonCount: 16,
description:
"Start here for the fundamentals. Covers API authentication, basic requests, conversation management, system prompts, and structured output generation.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/02-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/02-01.webp",
alt: "Section 2 screenshot 1",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/02-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/02-02.webp",
alt: "Section 2 screenshot 2",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/02-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/02-03.webp",
alt: "Section 2 screenshot 3",
},
],
},
{
id: "section-3",
title: "Prompt engineering & evaluation",
lessonCount: 16,
description:
"Learn to write prompts that actually work. Focuses on prompting strategies, evaluation frameworks, and systematic testing approaches.",
screenshots: [
{
id: "s3-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/03-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/03-01.webp",
alt: "Section 3 screenshot 1",
},
{
id: "s3-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/03-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/03-02.webp",
alt: "Section 3 screenshot 2",
},
{
id: "s3-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/03-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/03-03.webp",
alt: "Section 3 screenshot 3",
},
],
},
{
id: "section-4",
title: "Tool use with Claude",
lessonCount: 14,
description:
"Extend Claude with custom tools and functions. Build apps with function calling, multi-turn tool interactions, batch tool calling, and leverage built-in utilities.",
screenshots: [
{
id: "s4-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/04-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/04-01.webp",
alt: "Section 4 screenshot 1",
},
{
id: "s4-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/04-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/04-02.webp",
alt: "Section 4 screenshot 2",
},
{
id: "s4-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/04-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/04-03.webp",
alt: "Section 4 screenshot 3",
},
],
},
{
id: "section-5",
title: "Retrieval augmented generation",
lessonCount: 10,
description:
"Implementation guide for production RAG systems. Covers text chunking, embeddings, hybrid search with BM25, multi-index architectures, reranking, and contextual retrieval.",
screenshots: [
{
id: "s5-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/05-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/05-01.webp",
alt: "Section 5 screenshot 1",
},
{
id: "s5-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/05-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/05-02.webp",
alt: "Section 5 screenshot 2",
},
{
id: "s5-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/05-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/05-03.webp",
alt: "Section 5 screenshot 3",
},
],
},
{
id: "section-6",
title: "Model Context Protocol (MCP)",
lessonCount: 12,
description:
"The protocol for building modular AI applications. Define custom tools and resources, implement MCP servers and clients, handle the full integration lifecycle.",
screenshots: [
{
id: "s6-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/06-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/06-01.webp",
alt: "Section 6 screenshot 1",
},
{
id: "s6-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/06-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/06-02.webp",
alt: "Section 6 screenshot 2",
},
{
id: "s6-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/06-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/06-03.webp",
alt: "Section 6 screenshot 3",
},
],
},
{
id: "section-7",
title: "Claude Code & Computer Use",
lessonCount: 8,
description:
"Two powerful Anthropic tools in action. Claude Code accelerates development workflows, Computer Use automates UI interactions. Includes MCP integration patterns.",
screenshots: [
{
id: "s7-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/07-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/07-01.webp",
alt: "Section 7 screenshot 1",
},
{
id: "s7-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/07-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/07-02.webp",
alt: "Section 7 screenshot 2",
},
{
id: "s7-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/07-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/07-03.webp",
alt: "Section 7 screenshot 3",
},
],
},
{
id: "section-8",
title: "Agents and workflows",
lessonCount: 11,
description:
"Architecture patterns for autonomous AI systems. Understand parallel execution, operation chaining, conditional routing, and effective debugging strategies.",
screenshots: [
{
id: "s8-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/08-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/08-01.webp",
alt: "Section 8 screenshot 1",
},
{
id: "s8-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/08-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/08-02.webp",
alt: "Section 8 screenshot 2",
},
{
id: "s8-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/08-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/claude-with-the-anthropic-api/08-03.webp",
alt: "Section 8 screenshot 3",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[claudeWithTheAnthropicApiData["path"]] =
claudeWithTheAnthropicApiData;
const introductionToClaudeCoworkData = {
path: "/introduction-to-claude-cowork",
llmContentKey: "cowork",
title: "Introduction to Claude Cowork",
subtitle:
"Learn to work alongside Claude on your real files and projects. This hands-on course covers the Cowork task loop, skills and plugins, extending Claude into Chrome, Word, Excel, PowerPoint, and Outlook, and how to steer multi-step work responsibly — so you're productive in your first week.",
overview: {
description:
"Cowork is Claude working directly with your files, folders, and apps — reading, editing, and producing real outputs on your machine. Where Chat is a conversation, Cowork is a working session: you describe the task, Claude plans and executes it, and you steer along the way.
This course gets you from first launch to confident daily use. You'll run your first end-to-end task, give Claude standing context with projects, skills, and plugins, bring Claude into Chrome, Word, Excel, PowerPoint, and Outlook, and learn the habits that keep multi-step work safe to share with your team.
",
learningObjectives: [
"Set up Claude Cowork with a working folder, connectors, and the right permissions",
"Run your first end-to-end task — clarify, steer mid-run, and review the deliverable",
"Give Claude standing context with global instructions, projects, skills, and plugins",
"Set up scheduled tasks and Dispatch for recurring work",
"Bring Claude into the browser with Claude in Chrome and into Word, Excel, PowerPoint, and Outlook",
"Test the skills you build and share plugins with your team safely",
],
prerequisites: [
"A paid Claude plan (Pro, Max, Team, or Enterprise) with access to the Claude desktop app",
"Comfort with everyday desktop apps — no coding or command-line experience needed",
],
targetAudience:
"Knowledge workers whose day is spent moving information between files, apps, and tools and want Claude to take on real, multi-step work.",
},
stats: {
lectureCount: 14,
videoHours: 0.5,
quizCount: 1,
},
sections: [
{
id: "section-1",
title: "Meet Claude Cowork",
lessonCount: 4,
description:
"What Cowork is and how it differs from Chat, how to set it up, and your first end-to-end task: describe it, watch Claude plan and execute, and steer along the way.",
screenshots: [
{
id: "s1-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778287931%2F01-01-medium.1778287931108.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778287931%2F01-01.1778287931441.webp",
alt: "Connectors interactive: toggle which tools Cowork can reach for a task",
},
{
id: "s1-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778288339%2F01-02-medium.1778288339014.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778288339%2F01-02.1778288339343.webp",
alt: "Anatomy of a Cowork task: a prompt that names sources and ends in a real deliverable",
},
],
},
{
id: "section-2",
title: "Make Claude Cowork yours",
lessonCount: 4,
description:
"Give Claude standing context with global instructions and projects, then build skills and install plugins so Claude knows your vocabulary, your steps, and the outputs you expect.",
screenshots: [
{
id: "s2-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778287931%2F02-01-medium.1778287931754.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778287932%2F02-01.1778287932039.webp",
alt: "Inside a skill: a folder with SKILL.md, references, and assets",
},
{
id: "s2-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778287932%2F02-02-medium.1778287932429.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778287932%2F02-02.1778287932733.webp",
alt: "Two plugin shapes: a function's toolkit and an end-to-end pipeline",
},
],
},
{
id: "section-3",
title: "Use Claude wherever you work",
lessonCount: 2,
description:
"Drive web apps with Claude in Chrome, and work inside Word, Excel, PowerPoint, and Outlook with the Claude add-ins for each.",
screenshots: [
{
id: "s3-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778287933%2F03-01-medium.1778287932995.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778287933%2F03-01.1778287933260.webp",
alt: "Claude in Chrome reading a customer-health dashboard from a Cowork prompt",
},
{
id: "s3-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778288339%2F03-02-medium.1778288339684.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778288340%2F03-02.1778288339955.webp",
alt: "Claude in Chrome filters the dashboard, then Cowork takes over to build the deliverable",
},
],
},
{
id: "section-4",
title: "Sharing and safety in Claude Cowork",
lessonCount: 4,
description:
"Work safely by reviewing plans and outputs, validate skills before you rely on them, and share plugins and workflows with your team.",
screenshots: [
{
id: "s4-1",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778287933%2F04-01-medium.1778287933517.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778287933%2F04-01.1778287933787.webp",
alt: "Spot the risk: review a Cowork task for hazards before it runs",
},
{
id: "s4-2",
url: "https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778288340%2F04-02-medium.1778288340296.webp",
fullSizeUrl:
"https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F8vqsu7jt1fsbeepmjgbk7gzfi%2Fpublic%2F1778288340%2F04-02.1778288340550.webp",
alt: "Distribution paths: how to share a plugin with your team based on your org setup",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[introductionToClaudeCoworkData["path"]] =
introductionToClaudeCoworkData;
const introductionToMcpData = {
path: "/introduction-to-model-context-protocol",
llmContentKey: "mcp_intro",
title: "Introduction to Model Context Protocol",
subtitle:
"Learn how to build modular AI applications using MCP to connect Claude with external tools and data sources",
overview: {
description:
"This course covers MCP, a protocol for connecting Claude to external services and data sources without manually writing tool schemas. You'll learn to build both MCP servers that expose tools, resources, and prompts, and MCP clients that consume them. The course includes a hands-on project where you implement a document management system using MCP.",
learningObjectives: [
"Understand MCP architecture and the client-server communication model",
"Build MCP servers that expose tools using the Python SDK",
"Implement MCP clients to connect your applications to MCP servers",
"Create resources for exposing data and prompts for pre-defined workflows",
"Test and debug MCP servers using the MCP Inspector",
"Choose between tools, resources, and prompts based on control patterns",
"Handle resource cleanup and async communication in MCP implementations",
],
prerequisites: [
"Basic Python programming experience",
"Understanding of async/await patterns",
"Familiarity with API concepts",
],
targetAudience:
"Engineers who want to integrate Claude with external tools and services without writing tons of boilerplate integration code",
},
stats: {
lectureCount: 16,
videoHours: 1.0,
quizCount: 1,
},
sections: [
{
id: "section-1",
title: "MCP fundamentals & server development",
lessonCount: 8,
description:
"Start with understanding MCP's architecture and why it exists. Build your first MCP server with tools using the Python SDK, then test it with the built-in inspector.",
screenshots: [
{
id: "s1-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/01-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/01-01.webp",
alt: "MCP architecture diagram showing client-server communication",
},
{
id: "s1-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/01-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/01-02.webp",
alt: "Python code showing MCP server tool definitions",
},
{
id: "s1-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/01-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/01-03.webp",
alt: "MCP Inspector interface testing tools",
},
],
},
{
id: "section-2",
title: "MCP client implementation & advanced features",
lessonCount: 8,
description:
"Build the client side to communicate with MCP servers. Implement resources for direct data access and prompts for pre-built instructions. See how everything connects in a complete application flow.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/02-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/02-01.webp",
alt: "Client implementation code with session management",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/02-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/02-02.webp",
alt: "Resource and prompt implementation examples",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/02-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/introduction-to-model-context-protocol/02-03.webp",
alt: "Complete application flow diagram with MCP integration",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[introductionToMcpData["path"]] = introductionToMcpData;
const modelContextProtocolAdvancedTopicsData = {
path: "/model-context-protocol-advanced-topics",
llmContentKey: "mcp_advanced",
title: "Model Context Protocol: Advanced Topics",
subtitle:
"Deep dive into MCP's advanced features including sampling, notifications, and transport implementations",
overview: {
description:
"This course covers the technical implementation of MCP servers and clients, from basic message passing to production deployment strategies. You'll learn how MCP enables language models like Claude to interact with external tools and data sources through standardized protocols, transports, and message formats.",
learningObjectives: [
"Implement MCP servers with tool functions, logging, and progress notifications",
"Handle bidirectional communication between MCP clients and servers",
"Configure file system access using the roots permission model",
"Work with both stdio and HTTP transports for local and remote deployments",
"Implement sampling callbacks to enable server-initiated LLM requests",
"Debug message flows using JSON-RPC message types",
"Deploy scalable MCP servers using stateless HTTP configurations",
"Troubleshoot common issues when transitioning from development to production",
],
prerequisites: [
"Basic understanding of MCP servers and clients",
"Familiarity with async programming patterns",
],
targetAudience:
"Engineers building production MCP servers who need to understand the protocol's advanced capabilities",
},
stats: {
lectureCount: 15,
videoHours: 1.1,
quizCount: 2,
},
sections: [
{
id: "section-1",
title: "Core MCP features",
lessonCount: 8,
description:
"Learn the advanced features that make MCP servers more powerful. Covers sampling to offload AI costs to clients, implementing progress notifications for better UX, and using roots to safely handle file access.",
screenshots: [
{
id: "s1-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/01-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/01-01.webp",
alt: "Section 1 screenshot 1",
},
{
id: "s1-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/01-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/01-02.webp",
alt: "Section 1 screenshot 2",
},
{
id: "s1-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/01-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/01-03.webp",
alt: "Section 1 screenshot 3",
},
],
},
{
id: "section-2",
title: "Transports and communication",
lessonCount: 7,
description:
"Understand how MCP messages flow between clients and servers. Explores the JSON message protocol, STDIO transport for local development, and the complexities of StreamableHTTP including when to sacrifice features for scalability.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/02-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/02-01.webp",
alt: "Section 2 screenshot 1",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/02-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/02-02.webp",
alt: "Section 2 screenshot 2",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/02-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/model-context-protocol-advanced-topics/02-03.webp",
alt: "Section 2 screenshot 3",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[modelContextProtocolAdvancedTopicsData["path"]] =
modelContextProtocolAdvancedTopicsData;
const teachingAiFluencyData = {
path: "/teaching-ai-fluency",
previewId: "78076",
usesAlternateLayout: true,
llmContentKey: "taif",
title: "Teaching AI Fluency",
subtitle:
"This course empowers academic faculty, instructional designers, and others to teach and assess AI Fluency in instructor-led settings.",
overview: {
description:
" At Anthropic, we believe that empowering people with AI, and ensuring that AI makes safe contributions to society, requires engaging with a wide range of human perspectives and experiences. Responsible AI development and engagement isn't something any single discipline or viewpoint can fully address. It demands collaborative approaches that span a wide range of technical, creative, business, scientific, and educational domains. That's why we partnered with educators who bring complementary expertise to create this course on AI collaboration for educators.
This course empowers faculty, instructional designers, and educational leaders to apply the 4D Framework to their own educational practice. Participants will learn to apply the 4D Framework to their own teaching practice, using AI as a thinking partner to enhance course design, create coherent learning materials, and develop authentic assessments while modeling responsible AI collaboration for their students.
This course is the result of a long partnership between Anthropic and professors Rick Dakan from Ringling College of Art and Design and Joseph Feller from University College Cork. It builds on their experiences in training fellow educators and teaching the AI Fluency Framework to their students, and on feedback and questions that arose from our earlier course: AI Fluency: Framework & Foundations This course answers the question: how can I apply this framework to my personal teaching practice?
The work was supported in part by the Higher Education Authority (Ireland) through the National Forum for the Enhancement of Teaching and Learning.
This course lightly covers the foundational AI Fluency concepts. However, for deeper understanding, participants should complete AI Fluency: Framework & Foundations before beginning this educator-focused curriculum.
It is also recommended that learners have active teaching or curriculum development responsibilities as well as access to an AI chat tool for hands-on practice. Examples in this course will use Claude.ai, but any chatbot will work.
",
},
stats: {
lectureCount: 7,
videoHours: 0.6,
quizCount: 1,
},
sections: [
{
id: "section-1",
title: "Teaching approaches",
lessonCount: 3,
description: "Scaffolding student AI Fluency through the 4D Framework.",
screenshots: [
{
id: "s1-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/01-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/01-01.webp",
alt: "Section 1 screenshot 1",
},
{
id: "s1-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/01-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/01-02.webp",
alt: "Section 1 screenshot 2",
},
{
id: "s1-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/01-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/01-03.webp",
alt: "Section 1 screenshot 3",
},
],
},
{
id: "section-2",
title: "Assessment & Assignment",
lessonCount: 2,
description:
"Designing assessments and assignments that develop and measure student AI Fluency alongside disciplinary expertise.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/02-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/02-01.webp",
alt: "Section 2 screenshot 1",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/02-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/02-02.webp",
alt: "Section 2 screenshot 2",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/02-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/02-03.webp",
alt: "Section 2 screenshot 3",
},
],
},
{
id: "section-3",
title: "AI's impact and your discipline",
lessonCount: 2,
description:
"Building institutional capacity for responsible and meaningful AI integration in pedagogy, assessment, and curricula across disciplines.",
screenshots: [
{
id: "s2-1",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/03-01-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/03-01.webp",
alt: "Section 3 screenshot 1",
},
{
id: "s2-2",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/03-02-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/03-02.webp",
alt: "Section 3 screenshot 2",
},
{
id: "s2-3",
url: "https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/03-03-medium.webp",
fullSizeUrl:
"https://d7juhi4i8fsw0.cloudfront.net/images/teaching-ai-fluency/03-03.webp",
alt: "Section 3 screenshot 3",
},
],
},
],
};
if (typeof window._clpdata !== "object") {
window._clpdata = {};
}
window._clpdata[teachingAiFluencyData["path"]] = teachingAiFluencyData;
// Modal Carousel for Course Landing Page Screenshots
function renderScreenshot(screenshot, sectionId) {
if (screenshot.url) {
return `
${generateHeroSection(courseData, videoElement, enrollHref)}
${generateMainContent(courseData)}
`;
return html.trim();
}
function generateHeroSection(courseData, videoElement, enrollHref) {
// Determine what to show for video
let videoContent;
if (videoElement) {
// If we have an existing video element, use it directly
videoContent = `
${generateAboutThisCourse(courseData)}
${generateCourseSections(courseData.sections)}
${courseData.instructors ? generateInstructorsSection(courseData.instructors) : ''}
${courseData.extra ? (Array.isArray(courseData.extra) ? courseData.extra : [courseData.extra]).map(generateExtraSection).join('') : ''}
`;
}
function generateCourseSections(sections) {
if (!sections || sections.length === 0) return "";
return `
' +
eapHero(registerUrl, nonPartnerEmail, inPartnerGroup, maintenanceLockout) +
eapStats() +
eapCompetencies() +
eapScenarios() +
eapRecommended() +
eapFaq() +
eapCtaFooter(registerUrl, nonPartnerEmail, maintenanceLockout) +
'
';
return html;
}
function eapInMaintenanceLockout() {
return !!(window.MAINTENANCE_WINDOW && window.MAINTENANCE_WINDOW.inExamLockout());
}
function eapHero(registerUrl, nonPartnerEmail, inPartnerGroup, maintenanceLockout) {
var partnerNote = inPartnerGroup ? '' :
'' +
'Exam registration is paused for scheduled maintenance and will reopen after ' +
'' + window.MAINTENANCE_WINDOW.reopensLabel + '.' +
'
';
} else if (nonPartnerEmail) {
domainWarning =
'' +
'You aren’t signed in with a partner company employee email. ' +
'Sign in with your partner email to register.' +
'
';
}
return '' +
'
' +
'
' +
'
' +
'
' +
'