Version française

CASD™ — Certified AI Solutions Developer · Claude Code

Official Certification Curriculum

Trademark and independence notice. Claude is a trademark of Anthropic, PBC. The Sopheria Global Certification Board is an independent certification body, not affiliated with or endorsed by Anthropic. The CASD™ certification attests to professional competencies assessed by the SGCB against its own standards; it does not constitute a certification issued by Anthropic.

The CASD™ certification scheme is designed in alignment with the requirements of ISO/IEC 17024 for the certification of persons (impartiality, separation of training and certification, independent scheme committee). The SGCB maintains an accreditation roadmap; it claims no external accreditation it has not obtained.

1. Overview and Value of the Certification

The CASD™ — Certified AI Solutions Developer · Claude Code certification is the flagship credential of the SGCB catalogue. It validates the ability of an experienced developer to design, build, secure, and operate in production applications and agentic systems based on Anthropic's Claude models, leveraging the Claude API, the official SDKs, the Model Context Protocol (MCP), and recognized industry engineering patterns.

The certification holder demonstrates the ability to:

• integrate the Messages API and the Anthropic SDKs into real-world applications (streaming, vision, documents, tool calls);
• design production-grade prompts that exploit Claude-specific capabilities (system prompts, XML tagging, structured reasoning);
• architect agents and multi-agent systems equipped through MCP and orchestration mechanisms;
• implement robust RAG pipelines and disciplined context management (citations, prompt caching, long context windows);
• operate these systems in production: security, cost control, evaluation, observability, guardrails, compliance, and responsible use.

Value for the professional. The CASD™ provides independent, verifiable, and dated evidence of competence in the Claude ecosystem — a differentiator in a market where LLM application engineering has become a critical skill. Every certification carries a verifiable credential ID in the SGCB public registry.

Value for the employer. The competency standard is built from a job task analysis conducted with practitioners in active roles, and the examination is maintained by a scheme committee independent of the training division. Hiring or certifying a Certified AI Solutions Developer · Claude Code means having a standardized signal of the ability to deliver reliable LLM systems.

2. Target Audience

• Software developers and backend/full-stack engineers integrating LLMs into products;
• AI engineers / machine learning engineers focused on generative applications;
• Technical architects designing agentic platforms or RAG pipelines;
• Platform and DevOps engineers responsible for operating LLM workloads;
• Technical consultants and AI delivery team leads.

3. Prerequisites

3.1 Mandatory Prerequisites

No formal prerequisites are required to sit the assessment. The SGCB nonetheless strongly recommends the following profile:

• 2 to 5 years of professional software development experience;
• at least 12 months of hands-on experience with LLM APIs, including significant experience with the Claude API;
• proficiency in at least one language with an official Anthropic SDK (Python or TypeScript recommended);
• comfort with HTTP/REST, JSON, JSON Schema, Git, and basic cloud deployment practices.

3.2 Recommended Prior SGCB Certifications

These certifications are not mandatory; they constitute the recommended progression path within the SQF.

3.3 Recommended Practical Experience

The ideal candidate has already, in a real-world context or a substantial project:

• built at least one application calling the Messages API with streaming and error handling;
• implemented a complete tool use cycle (tool definition, execution, returning tool_result);
• set up prompt caching and measured its impact on cost and latency;
• developed or integrated at least one MCP server;
• delivered a RAG pipeline with response quality evaluation.

4. Competency Domains and Weightings

The CASD™ competency standard comprises six domains. The weightings reflect the relative importance of each domain in professional practice; they structure the certification project scoring rubric and the distribution of multiple-choice examination questions (see the exam blueprint, exam-blueprint.en.md).

Domain 1 — LLM Fundamentals and the Claude Model Family (10%)

Measurable learning objectives. Upon completing their preparation, the candidate is able to:

• Explain how an autoregressive language model works: tokenization, context window, token-by-token generation, intrinsic limitations (hallucinations, knowledge cutoff);
• Distinguish the tiers of the Claude family (model classes oriented toward maximum capability, cost/performance balance, and speed/economy) and select the appropriate model for a given use case based on quality, latency, cost, and context size criteria;
• Interpret model identifiers and lifecycle policies (availability, deprecation, retirement) and plan a migration strategy between versions;
• Calculate the cost of a request from input/output tokens and per-million-token pricing, accounting for reasoning tokens and discounts (batch, cache);
• Describe the cross-cutting capabilities of Claude models: multimodality (vision, documents), extended reasoning, tool calls, structured outputs;
• Compare the consumption channels for Claude models: the direct Anthropic API and partner cloud platforms, and identify feature availability gaps across platforms.

Subtopics. 1.1 Transformer architecture and autoregressive generation (conceptual level); 1.2 Tokenization and token counting (counting endpoint, model-specific tokenizer characteristics); 1.3 The Claude model family: positioning, capabilities, context windows, output caps; 1.4 Model lifecycle and migration strategies; 1.5 Economic model: input/output pricing, reasoning costs, batch and cache discounts; 1.6 Distribution platforms (Anthropic API, partner clouds) and feature availability matrix.

Domain 2 — Claude API and Anthropic SDKs (20%)

Measurable learning objectives. The candidate is able to:

• Construct valid Messages API requests: messages structure (roles, alternation, content blocks), system, max_tokens, generation parameters, and diagnose common validation errors (400/401/404/413/429/500/529);
• Implement SSE streaming: event cycle (message_start, content_block_start, content_block_delta, content_block_stop, message_delta, message_stop), final message accumulation, interruption handling;
• Integrate multimodal inputs: images (base64, URL), PDF documents, file reuse via the Files API, and apply the documented limits (sizes, formats, pages);
• Implement tool use / function calling: tool definitions in JSON Schema, tool_choice, parallel tool execution, correct return of tool_result blocks (including is_error), and differentiate client tools (executed by the application) from server tools (executed on the Anthropic side);
• Produce reliable structured outputs (constrained JSON schemas, strict tool parameter validation) and handle every stop_reason (end_turn, max_tokens, tool_use, stop_sequence, pause_turn, refusal);
• Leverage the supporting endpoints: Message Batches (asynchronous processing at reduced cost), Token Counting, Models API;
• Use the official Anthropic SDKs (Python, TypeScript, and others) idiomatically: credential management, timeouts, automatic retries, typed exceptions.

Subtopics. 2.1 Anatomy of the Messages API: request, response, content blocks, usage; 2.2 Authentication and client configuration (API keys, environment variables, version and beta feature headers); 2.3 SSE streaming and SDK helpers; 2.4 Vision and document processing (images, PDF, Files API, document citations); 2.5 Tool use: schemas, elementary agentic loop, tool results and errors, Anthropic-defined tools; 2.6 Structured outputs and validation; 2.7 Batches, token counting, model discovery; 2.8 Error handling, retries, rate limits, and HTTP status codes; 2.9 Multi-turn conversations: stateless API, history reconstruction, response block preservation.

Domain 3 — Advanced Prompt Engineering for Claude (15%)

Measurable learning objectives. The candidate is able to:

• Write production-grade system prompts: role definition, constraints, tone, output format, and correctly separate operator instructions (system) from user content;
• Structure complex prompts using XML tags to delimit instructions, context, examples, and data, in line with the practices recommended for Claude;
• Apply reasoning elicitation techniques: chain-of-thought, task decomposition, extended/adaptive reasoning and effort-level tuning, trading off quality, latency, and cost;
• Use output control techniques suited to the model's generation: few-shot examples, imposed formats, structured outputs — and identify when response prefilling (prefill) is or is not applicable depending on model generations;
• Diagnose and correct prompt failures: ambiguous instructions, over-direction, instruction conflicts, format leakage, sensitivity to context ordering;
• Design prompts that are robust against adversarial inputs (prompt injection) and deploy first-line defenses at the prompt level.

Subtopics. 3.1 Architecture of a production prompt: system prompt, instruction hierarchy, operator vs. user channels; 3.2 XML tagging and context organization; 3.3 Chain-of-thought, extended and adaptive reasoning, effort parameter; 3.4 Few-shot prompting and canonical examples; 3.5 Output format control (structured outputs, imposed formats, length constraints, prefill and its limits by model generation); 3.6 Prompt iteration and testing: test sets, variant comparison, non-regression; 3.7 Robustness: prompt injection, data/instruction separation, defensive instructions; 3.8 Adapting prompts across model versions (increased instruction literalness, directive calibration).

Domain 4 — Building Agents: Agent SDK, MCP, and Orchestration (20%)

Measurable learning objectives. The candidate is able to:

• Decide on the appropriate architectural level — single call, code-orchestrated workflow, or autonomous agent — based on task complexity, value, feasibility, and the cost of error;
• Implement a complete agentic loop on the Messages API: iterating on stop_reason == "tool_use", tool execution, returning results, stop conditions, and safety bounds (maximum iterations, budgets);
• Use the tool-execution mechanisms provided by the SDKs (tool runners) and choose between an automated loop and a manual loop according to control needs (human approval, interception, logging);
• Explain the architecture of the Model Context Protocol (MCP) — hosts, clients, servers; tools, resources, prompts; transports — and develop or integrate an MCP server exposing business capabilities;
• Position the Claude Agent SDK (a complete harness with built-in tools: files, shell, search) relative to direct API integration, and select the appropriate approach (manual loop, tool runner, Agent SDK, managed agents);
• Design multi-agent architectures: orchestrator and sub-agents, parallel delegation, per-agent context isolation, result handoff, and prevent anti-patterns (unnecessary delegation, implicit shared contexts);
• Equip agents with memory and persistence: file-based memory, cross-session state, context compaction and pruning in long-running loops;
• Secure agent execution: sandboxing, least privilege, tool input validation, human confirmation of irreversible actions.

Subtopics. 4.1 Decision criteria: single call → workflow → agent; 4.2 Agentic loop on the Messages API and SDK tool runners; 4.3 Tool surface design: dedicated tools vs. generic shell, prescriptive schemas, parallelizability; 4.4 MCP: concepts, primitives (tools, resources, prompts), transports, session lifecycle, server security and authentication; 4.5 Claude Agent SDK: built-in tools, hooks, sub-agents, permissions; 4.6 Server-side managed agents: the notion of persisted, versioned agent configuration, sessions, execution environments; 4.7 Multi-agent orchestration and coordinator/specialist patterns; 4.8 Memory, state, and long duration: compaction, context editing, persistent memory; 4.9 Execution safety: sandbox, approvals, iteration and budget limits.

Domain 5 — RAG and Context Management (15%)

Measurable learning objectives. The candidate is able to:

• Design an end-to-end RAG pipeline: ingestion, chunking, vectorization via embeddings (through specialized providers, as Anthropic does not offer its own embeddings API), vector storage, hybrid search, reranking, context injection;
• Trade off RAG against long context windows (direct loading of large corpora) based on corpus size, freshness, cost, and latency;
• Implement Claude's native citations on document blocks to produce sourced, verifiable answers;
• Implement prompt caching effectively: the prefix invariant (any upstream change invalidates everything downstream), the tools → system → messages rendering order, breakpoints (cache_control), TTL, hit verification via the usage fields, and detect silent invalidators (timestamps, non-deterministic serialization, variable tool sets);
• Optimize context window usage: placement of stable vs. volatile content, context budgeting, compaction and summarization, overflow handling;
• Evaluate the quality of a RAG pipeline: retrieval relevance (recall/precision), faithfulness of answers to the context (groundedness), correct citation rate.

Subtopics. 5.1 Reference RAG architecture and variants (hybrid search, reranking, multi-index); 5.2 Embeddings and vector databases: embedding model selection, sizing, similarity metrics; 5.3 Chunking and metadata strategies; 5.4 Document citations and sourced answers; 5.5 Prompt caching: prefix mechanics, breakpoints, TTL, economics (write vs. read costs), invalidator audits; 5.6 Long context: when to load the corpus into context, limits and costs; 5.7 Context management in long conversations: compaction, pruning, external memory; 5.8 RAG evaluation: reference question sets, retrieval and generation metrics.

Domain 6 — Production: Security, Cost, Evaluation, Observability — and Responsible Use (20%)

Measurable learning objectives. The candidate is able to:

• Secure a Claude application in production: secrets management (never hard-coded or client-side keys), network perimeters, systematic validation of model inputs and outputs, defense against prompt injection and tool-based exfiltration;
• Control costs: token budgeting, per-route model selection, prompt caching, the Batches API for non-urgent processing, caps (max_tokens, task budgets), consumption tracking via the usage fields;
• Design an evaluation framework: reference test sets, automated evaluations (assertions, model-as-judge scoring), human evaluation, non-regression testing before any prompt or model change;
• Instrument observability: structured request/response logging (with request identifiers), tracing of agentic loops, metrics (latency, error rate, tokens, cost per request, cache hit rate), alerting;
• Deploy guardrails: input/output filtering and moderation, handling of model refusals (stop_reason: "refusal") and fallback strategies, human-in-the-loop for consequential actions, application-level rate limits;
• Design for resilience: retries with exponential backoff, handling of 429/529 errors, graceful degradation strategies and model fallback;
• Apply responsible-use principles: compliance with the provider's usage policy, personal data protection (minimization, retention, applicable regulations such as the GDPR), transparency toward end users (disclosure of AI use), human oversight of high-impact decisions, documentation of system limitations;
• Assess the ethical stakes of a deployment: bias and fairness, misuse, impact on vulnerable users, traceability and accountability.

Subtopics. 6.1 Application security: secrets, perimeter, least privilege, OWASP LLM Top 10; 6.2 Prompt injection and tool/MCP security (path validation, allowlists, human confirmation); 6.3 Cost engineering: caching, batch, model routing, budgets and quotas; 6.4 Evaluation: eval design, LLM-as-judge and its limits, non-regression, A/B testing; 6.5 Observability: logs, traces, metrics, request identifiers, dashboards; 6.6 Guardrails and moderation, refusal handling and fallbacks; 6.7 Reliability: retries, backoff, fault tolerance, graceful degradation; 6.8 Ethics and compliance: usage policy, personal data, transparency, human oversight, documentation; 6.9 Governance: managing model and prompt changes, security reviews, decision log.

5. Preparation Pathways

In keeping with its principle of strict separation between training and certification, the SGCB mandates no training. The recognized preparation pathways are:

1. Official training — "Claude Developer Program" (Sopheria Global Academy). An intensive 4-week program — each week: one 3-hour group session (maximum 5 participants) and two one-hour individual meetings with the instructor — covering the entire competency standard, with the capstone project built throughout the program. The capstone may be submitted as the certification project, but it is then assessed independently by the SGCB using its own rubric. Detailed syllabus: sga-course-syllabus.md. Completing the training confers no advantage in the certification assessment, which is identical for all candidates.
2. Self-preparation. Official Anthropic documentation (API, SDKs, MCP, prompt engineering best practices), the Model Context Protocol specification, and project practice — a project completed outside any training program is admissible as the certification project provided it meets the published project requirements.
3. Candidate handbook and SGCB materials. The SGCB publishes a candidate handbook, this competency framework, the public scoring rubrics for the project and the oral defense, and a calibrated practice examination (available on the candidate portal).
4. Professional experience. The most decisive pathway: the competency standard is designed to reflect real-world practice, not documentation recall.

6. Assessment Methods

The CASD™ assessment is described exhaustively in the exam blueprint (exam-blueprint.en.md). In summary, the certification rests on a project-based assessment comprising three components:

Overall score on a 100–1000 scale with a passing score of 700, together with a minimum equivalent threshold of 500 per component; the scheme is available in French and English; the use of AI assistants (including Claude) is permitted and expected for building the project, with the candidate required to understand and take ownership of every choice (signed authenticity declaration, verification during the oral defense).

7. Validity, Maintenance, and Recertification

7.1 Validity

The CASD™ certification is valid for 3 years from the date the certification assessment is passed. This period reflects the rapid pace of change in the model and API ecosystem.

7.2 Recertification Pathways

Before expiration, the holder recertifies through one of the following pathways:

7.3 Status and Registry

Holders in good standing are listed in the SGCB public verification registry with their certification ID. An expired certification is marked "inactive"; the holder has a 90-day grace period to recertify without reverting to new-candidate status. Use of the title "Certified AI Solutions Developer · Claude Code" and of the CASD™ digital badge is reserved for holders in active status, in accordance with the SGCB title usage policy.

7.4 Certification Integrity

Every candidate undertakes to comply with the SGCB code of ethics (prohibition of examination content disclosure, fraud, and identity misrepresentation). Violations result in the invalidation of results and may lead to permanent exclusion from SGCB programs.

© Sopheria Global Institute of Technology — Sopheria Global Certification Board. "Scientia. Integritas. Futurum." Claude is a trademark of Anthropic, PBC. The SGCB is an independent body, not affiliated with Anthropic.