Study guide

4.3 Requirements Analysis & Claude Application Design

Claude Certified Developer - Foundations CCDV-F

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Core Messages API & Streaming

1.1 Messages API Fundamentals & Request Lifecycle 1.2 Streaming & Server-Sent Events (SSE) 1.3 Thinking: Adaptive Mode, Effort & Reasoning Budgets

2 Chapter 2: Optimization & Asynchronous Batches

2.1 Prompt Caching Mechanics & Breakpoints 2.2 Message Batches API & Asynchronous Workloads

3 Chapter 3: Structured Outputs, Documents & Files API

3.1 Structured Outputs & JSON Extraction 3.2 Files API, Document Blocks & Citations

4 Chapter 4: Application Design, Resilience & Delivery Life Cycle

4.1 API Resilience, Error Handling & Retries 4.2 Production Backend Architecture & State Management 4.3 Requirements Analysis & Claude Application Design 4.4 The Claude Application Life Cycle & Configuration Management

5 Chapter 5: LLM Fundamentals, Model Selection & Versioning

5.1 LLM & Technical Fundamentals: Tokens, Context Windows & Sampling 5.2 Claude Model Family Selection 5.3 Model Versioning, Snapshot Pinning & Migration 5.4 Latency & Throughput Optimization

6 Chapter 6: Cost Engineering & Context Management

6.1 Production Cost Optimization Strategies 6.2 Context Window Management & Compaction

7 Chapter 7: Foundations of Workflows & Deterministic Patterns

7.1 Agent vs. Workflow Architectural Foundations 7.2 Workflow Patterns: Prompt Chaining & Routing 7.3 Workflow Patterns: Parallelization & Voting

8 Chapter 8: Autonomous Agents & Multi-Step Systems

8.1 Workflow Patterns: Orchestrator-Workers & Evaluator-Optimizer 8.2 Agent Loop Implementation & State Tracking 8.3 Agent Frameworks & Human-in-the-Loop (HITL)

9 Chapter 9: Prompt and Context Engineering

9.1 System Prompt Design & Role Framing 9.2 XML Tags & Structural Prompt Delimiters 9.3 Few-Shot Prompting & In-Context Learning 9.4 RAG Context Injection & Document Formatting

10 Chapter 10: Tool Calling & Model Context Protocol (MCP)

10.1 Tool Schema Design & Parameter Validation 10.2 Tool Execution, Multi-Tool Calls & Error Handling 10.3 MCP Architecture & Core Primitives 10.4 MCP Transports & Client/Server Integration 10.5 Agentic Customization: Built-in Tools, Custom Tools, Skills & MCP

11 Chapter 11: Security, Safety & Governance

11.1 Direct & Indirect Prompt Injection Defenses 11.2 Tool Permissions, Sandboxing & Least Privilege 11.3 Data Privacy, Redaction & Audit Logging 11.4 Identity, Secrets & API Key Management

12 Chapter 12: Claude Code Developer Tooling

12.1 Claude Code Architecture & Project Configuration 12.2 Permissions, Modes & Hooks

13 Chapter 13: Evaluation, Testing & Production Observability

13.1 Evaluation Design & Golden Datasets 13.2 Production Observability, Tracing & Debugging

4.3 Requirements Analysis & Claude Application Design

Key Takeaways Explain This Topic AI

The first requirements question is whether an LLM belongs in the solution at all: strict determinism, regulated arithmetic, and sub-50ms latency budgets should route to ordinary code rather than to Claude.

Every stakeholder statement must be converted into a testable requirement with a number attached, because an unevaluable requirement produces an unevaluable system.

Elicit five dimensions on every project - quality bar and failure cost, latency envelope, volume and budget, data sensitivity, and determinism needs - because each one changes the architecture.

Start with the simplest design that works: a single augmented call, then a deterministic workflow, and only then an agent, because each step adds cost, latency, and non-determinism.

Separate the control plane of system instructions and tool schemas from the data plane of untrusted user content, retrieved documents, and tool output.

Last updated: October 2026

Requirements Analysis & Claude Application Design

Exam Blueprint Focus: Understanding Requirements (3.4%) and Claude Application Design (8.6%) together make up 12% of CCDV-F — more than Tools and MCPs. These sub-skills are not about API syntax at all. They test whether you can read a stakeholder's request and decide, before writing code, whether Claude belongs in the solution and what shape the system should take.

The First Question: Should Claude Do This At All?

The most valuable requirements skill on this exam is recognising when an LLM is the wrong component. Claude is probabilistic, latency-variable, and priced per token. Three categories of requirement should route away from it:

Requirement signal Why Claude is wrong Use instead

"Must produce the same answer every time, auditable to a rule" Probabilistic generation cannot guarantee determinism Deterministic code, a rules engine, a lookup table

"Must compute a figure that appears on a regulated statement" Arithmetic is not a language task and errors are silent Compute in code; use Claude to explain the result

"Sub-50 ms P99" A generative model call over the network, even on the fastest tier (Claude Haiku 5.5), is the wrong fit for that budget Cached lookup, classical ML classifier

A hybrid is usually the right answer rather than a binary: let code do what code does well, and give Claude the language-shaped part of the task. A tax application should compute the liability in Python and use Claude to explain it in plain English. Getting that split right is what "Claude Application Design" means.

Eliciting Testable Requirements

Vague requirements produce unevaluable systems. Convert each stakeholder statement into something you could write an assertion against.

Vague ask Testable requirement

"Summarise support tickets" "Produce a 2-3 sentence summary naming the product area and the customer's requested outcome, for 95% of tickets under 2,000 tokens"

"It should be fast" "P95 end-to-end latency under 3 s; first token visible under 1 s"

"It shouldn't hallucinate" "Every factual claim traceable to a retrieved passage; the model answers 'not in the provided documents' when unsupported"

"Keep costs reasonable" "Under $0.02 per interaction at 50,000 interactions/day"

Five dimensions to elicit on every project, because each one changes the architecture:

Quality bar and failure cost. What happens when the output is wrong? A wrong product recommendation is a bad day; a wrong medication instruction is an incident. This sets the model tier and whether you need human review.

Latency envelope. Interactive, near-real-time, or offline? Offline unlocks the Batch API's 50% discount immediately.

Volume and budget. Requests per day multiplied by cost per request is the number that decides whether caching and routing are optional or mandatory.

Data sensitivity and residency. PII, PHI, or regulated data changes redaction, logging, and possibly inference_geo .

Determinism requirements. Which parts of the output must be structurally guaranteed? Those become JSON schemas (structured outputs or strict tools), not prose instructions.

Requirements to Architecture: A Decision Path Is the task language-shaped? --no--> Write ordinary code.

| yes

Does one model call with good context solve it? --yes--> Augmented LLM. Ship it.

| no

Are the steps known in advance? --yes--> Deterministic workflow (chain / route / parallelize).

| no

Does the task need dynamic tool selection over many turns? --yes--> Agent, with hard turn and budget ceilings.

The governing principle is to start with the simplest design that works. Each step down that path adds cost, latency, non-determinism, and debugging surface. An agent is not a more advanced answer to a workflow question; on the exam it is the wrong answer to a workflow question.

  • Designing the Claude Application
  • 1. Separate the control plane from the data plane

The control plane is your instructions: the system prompt, tool schemas, and business rules. The data plane is untrusted content: user messages, retrieved documents, tool output, uploaded files. Keep them structurally distinct — instructions in system , third-party content (retrieved documents, web pages, tool output) delivered inside tool_result blocks rather than in system or plain user text blocks, with its source stated — so that Claude treats text arriving from a document as data to evaluate, not as instructions. Structure lowers the risk; it does not enforce anything, so authorization still lives in your backend.

2. Make the API boundary explicit

Claude sits behind your service, never in front of it. Your backend owns authentication, authorization, rate limiting, quota enforcement, and audit logging. The model never decides whether a caller is allowed to do something.

3. Choose the output contract before the prompt

Decide what the caller needs — prose, a typed object, or a side effect — and pick the mechanism accordingly:

  • Need Mechanism
  • Human-readable prose Plain text blocks, streamed

A typed object your code consumes Structured outputs ( output_config.format ) or a strict tool ( strict: true ); forced tool_choice returns a 400 error on Claude Fable 5.1, Claude Opus 5.5, and Claude Sonnet 5.5

  • An action in another system Tool call executed by your backend, with server-side authorization
  • Grounded answer with provenance Document blocks with citations enabled
  • 4. Design for statelessness from turn one

The Messages API holds no session. Conversation state is your database's job, and the schema needs to hold whole content blocks — thinking blocks with signatures, tool_use and tool_result pairs — not flattened strings. Teams that store only role and text discover on the first tool-use turn that they cannot rehydrate a valid conversation.

5. Plan the cost model with the design, not after it

Sketch the token budget while the architecture is still on a whiteboard: what is static across requests (cache it), what is bulk and asynchronous (batch it), what is simple enough for a cheaper tier (route it). Retrofitting a cache breakpoint into a system whose prompt starts with a timestamp is far more expensive than designing the prefix to be stable.

A Worked Requirements Translation

"We want AI to handle our insurance claim intake. Adjusters spend hours reading PDFs. It needs to be accurate because these are legal documents, and we process about 8,000 claims a day."

Decompose it:

  • Stated Implied requirement Design consequence
  • "reading PDFs" Document ingestion at scale Files API; upload once, reference by ID

"accurate ... legal documents" High failure cost; provenance required Capable tier; citations enabled; human review on low confidence

  • "adjusters spend hours" Batch/offline, not interactive Message Batches API at 50% off
  • "8,000 claims a day" Volume; cost per claim matters Cache the static extraction schema and instructions
  • (unstated) Output feeds a claims system Structured outputs with the claim schema, not prose
  • (unstated) Claim documents contain PII Redaction before logging; restricted audit vault

Resulting architecture: upload each PDF through the Files API, submit extraction requests through the Message Batches API on a capable tier with a cached instruction prefix and structured outputs for the claim schema, run a citations-enabled pass where adjusters need fields tied to a page (as a separate request, because enabling citations together with output_config.format returns a 400 error), and route any claim whose confidence falls below threshold to an adjuster instead of straight into the claims system.

Notice how much of that came from requirements the stakeholder never stated. Surfacing the unstated requirements is the skill being tested.

Common Traps

Building an agent because agents are interesting. If the steps are knowable, a workflow is cheaper, faster, and debuggable.

Accepting "it shouldn't hallucinate" as a requirement. Convert it into a grounding rule and an eval you can run.

Asking Claude to do arithmetic that appears on a regulated document. Compute in code; let Claude explain.

Designing the prompt before the output contract. The contract determines whether you need a JSON schema, citations, or streamed prose.

Treating cost as a post-launch optimisation. Prefix stability and batch eligibility are architectural decisions, not tuning knobs.

Loading diagram... From Stakeholder Request to Claude Application Architecture