title
Please take a moment to fill out this form. We will get back to you as soon as possible.
All fields marked with an asterisk (*) are mandatory.
Claude Developer Intensive
Duration
2 Days
Course
CL-210
Available Formats
Classroom Training, Online Training
Course Description
Overview
This Claude Developer Intensive course is designed to take engineers from a working orientation in Claude to a shipped, production-grade Claude application. The course is build-led: participants integrate the Messages API with streaming and complete stop_reason handling, cut cost with prompt caching and the Message Batches API, construct custom tools and an MCP server with structured error envelopes, assemble an agent with the Claude Agent SDK and hooks, defend the application against prompt injection, and deploy it on Amazon Bedrock and Google Vertex AI. Every build is preceded by the design decision behind it — workflow or agent, tool or MCP server, deterministic or model-driven — so engineers can justify what they ship as well as write it.Objectives
Upon completion of the Claude Developer Intensive course, students will be able to:
- Select between a workflow and an agent, and between a tool, a Skill, and an MCP server, for a stated requirement
- Implement a streaming Messages API integration with full-range stop_reason handling, retries, and rate-limit backoff
- Select between realtime and Message Batches API execution on latency, volume, and cost, and implement the batch path
- Configure prompt caching and cache check-pointing, and measure the effect on token consumption and cost
- Build custom tools and an MCP server with correct schemas, structured error envelopes, and tool_choice control
- Construct an agent loop with the Claude Agent SDK, including subagent delegation and hooks for deterministic actions
- Defend a Claude application against prompt injection, and implement secrets handling and PII redaction
- Deploy the same application through Amazon Bedrock and Google Vertex AI and reconcile the differences
- Diagnose production failures by isolating integration-layer faults from model output through trace analysis
Audience
AI and machine learning engineers, technical leads, and senior software engineers who build, integrate, and ship Claude-powered applications, agents, and workflows, and who are preparing for the Claude Certified Developer – Foundations (CCDV-F) exam.
Prerequisites
-
CL-100A: Claude Foundations or CL-100B: Claude Foundations, Accelerated, or equivalent knowledge. Proficiency in Python and/or TypeScript, fluency with REST APIs and CLI tools, and familiarity with asynchronous programming and version control.
Anthropic's stated candidate profile assumes one to five years of software engineering experience and roughly six months of hands-on work with Claude or a comparable LLM platform; the exam itself has no mandatory prerequisites.
Candidates should note that the published CCDV-F blueprint devotes roughly a fifth of the exam to general software-engineering and requirements competence — Software Engineering Foundations (7.4%), Technical Fundamentals (6.1%), Understanding Requirements (3.4%), and Systems Life Cycle (2.8%). This course treats that competence as an entry assumption and does not teach it.
Topics
- Workflow versus agent: the decision criteria, and the cost of reaching for an agent too early
- Tool, Skill, or MCP server: choosing the extension mechanism for a stated requirement
- What to make deterministic and what to leave to the model
- Translating a business requirement into functional and infrastructure requirements
- Lab: scope two production requirements into concrete build plans before writing code
- Request and response anatomy: messages, system prompts, tool blocks, and the usage block
- Streaming: event handling, partial message assembly, and cancellation
- Full-range stop_reason handling: end_turn, max_tokens, stop_sequence, tool_use, and refusal
- Retries, idempotency, rate limits, and backoff under 429 and 529 responses
- Multi-format input: vision, documents, and extended thinking blocks
- Lab: build a streaming client that handles every stop_reason correctly and survives a rate-limit storm
- Tokenization and the token budget: counting, capping, and modeling cost before deployment
- Prompt caching and cache check-pointing: what is cacheable, what invalidates a cache, and what it saves
- Extended thinking and effort levels: when reasoning tokens pay for themselves
- Realtime versus the Message Batches API: latency tolerance, volume, custom_id failure handling, and the 24-hour window
- Model selection across Opus, Sonnet, and Haiku, and what breaks when a model version changes
- Lab: reduce the cost of a working integration through caching, batching, and model selection, and measure the result
- Tool schemas and descriptions: the difference between a tool the model selects correctly and one it does not
- tool_choice patterns: auto, any, and forced selection, and when forcing is the right answer
- Client-side versus server-side tools, approval patterns, and tool set construction
- Tool error handling: what the model can recover from and what it cannot
- Lab: build a tool set for an internal service and measure selection accuracy across ambiguous requests
- MCP primitives: tools, resources, and prompts, and when a resource beats a tool
- Server authoring, transports (stdio and sockets), and server lifecycle
- Structured error envelopes: the isError flag, error categories, and retryable metadata
- Deployment and integration: .mcp.json project scope versus user scope, and credential expansion
- Lab: build an MCP server for a REST-backed internal service and connect it to two Claude applications
- The agent loop: request, stop_reason inspection, tool execution, result return, and termination
- Manager and subagent hierarchies, and context isolation through delegation
- Hooks for deterministic actions and prerequisite gates when compliance must be guaranteed
- Agentic frameworks in the field — Strands, LangGraph, PydanticAI — and when a framework earns its dependency
- Self-hosted versus managed agent deployment
- Lab: build an agent with subagent delegation and a hook that enforces a compliance step deterministically
- System versus user placement, output constraints, and prompt versioning in a repository
- Few-shot examples for ambiguous cases and format consistency
- Context drift and bloat: tool output pruning, compaction, and when to isolate context in a subagent
- Output handling: structured output patterns, defensive parsing, response validation, and skepticism toward confident output
- Lab: harden an extraction pipeline with schema-enforced output and a validation-retry loop
- Prompt injection: treating retrieved and user-submitted content as untrusted and isolating it from instructions
- Guardrail layering and hooks that block destructive actions before they execute
- PII redaction on the way in and on the way out, and data leakage prevention
- Secrets, credentials, and API key management across development and production; least privilege and access monitoring
- Lab: break a vulnerable summarizer with an injected instruction, then close the hole with isolation and a hook
- Deployment through Amazon Bedrock and Google Vertex AI: authentication, model identifiers, and region and quota differences
- Configuration management: CLAUDE.md, settings.json, model version pinning, prompt versioning, and plugin dependencies
- Claude Code in the developer loop: headless mode with -p, --output-format json, and custom slash commands
- Debugging: error type identification, trace analysis, and isolating integration-layer faults from model output
- Lab: port a working application from the Anthropic API to Bedrock and to Vertex AI and reconcile the differences
- Design the integration: workflow or agent, tool or MCP server, deterministic or model-driven
- Build it: a streaming Messages API integration with complete stop_reason handling, a custom tool set, and an MCP-backed service
- Optimize it: prompt caching, model selection, and a batch path for the latency-tolerant workload
- Secure it: untrusted-input isolation, a hook-enforced guardrail, PII redaction, and managed secrets
- Ship it: deploy through Bedrock or Vertex AI, instrument it, and debug a seeded production failure
- Present the working system and defend the design decisions behind it
Related Courses
-
Code faster with Agentic AI: Master AI-Powered Coding with Claude Code and Agentic Tools Video Training
PP-DSCL-105- Duration: 1 Day
- Delivery Format: Self-Paced Training (WBT)
- Price: 0.00 USD
-
Claude API for Developers - Building Intelligent Applications Video Training
PP-DSCL-110- Duration: 1 Day
- Delivery Format: Self-Paced Training (WBT)
- Price: 0.00 USD
Self-Paced Training Info
Learn at your own pace with anytime, anywhere training
- Same in-demand topics as instructor-led public and private classes.
- Standalone learning or supplemental reinforcement.
- e-Learning content varies by course and technology.
- View the Self-Paced version of this outline and what is included in the SPVC course.
- Learn more about e-Learning
Course Added To Shopping Cart
bla
bla
bla
bla
bla
bla
Self-Paced Training Terms & Conditions
??spvc-wbt-warning??
Exam Terms & Conditions
??exam-warning??
??group-training-form-area??
??how-can-we-help-you-area??
??personalized-form-area??
??request-quote-area??
Sorry, there are no classes that meet your criteria.
Please contact us to schedule a class.
STOP! Before You Leave
Save 0% on this course!
Take advantage of our online-only offer & save 0% on any course !
Promo Code skip0 will be applied to your registration
Nothing yet
Purchase Information
??elearning-coursenumber?? ??coursename??
View Cart
title
Please take a moment to fill out this form. We will get back to you as soon as possible.
All fields marked with an asterisk (*) are mandatory.