CCAR-F Flashcards — Free Claude Certified Architect - Foundations Study Cards

Use RAG to inject the relevant document snippets into the system prompt and instruct the model to only use that data.

Implementing Retrieval-Augmented Generation (RAG) forces the model to rely on provided documents rather than internal training weights. By injecting the specific legal clauses into the system prompt context, you create a rigid boundary for the model's knowledge. This architectural pattern is essential for high-stakes domains like legal or medical analysis, where accuracy is non-negotiable and hallucinations can lead to significant liability or incorrect decision-making.

Within the system prompt field.

Defining the persona in the system prompt sets the foundational behavior and context for the entire conversation. This approach ensures that Claude maintains consistency in its professional tone and adherence to specific constraints, such as statutory interpretation, without needing repetitive instructions in every user message, thereby optimizing the model's performance and output reliability.

The MCP Server.

The MCP server is the component responsible for defining and executing the tools. The client serves as the interface between the model and the server, but the server holds the actual business logic and implementation. This distinction is vital for architecting secure systems, as it allows the server to remain isolated, audit-logged, and independently scalable from the client-side model orchestration.

The tool prompts the user for manual approval before executing any shell command.

Claude Code is designed with a safety-first approach that requires explicit user consent for actions that can modify the system state. By prompting the user for approval before executing shell commands, the tool ensures that the human operator remains in control of the environment and can prevent potentially destructive actions.

Submit a message with the role 'user' containing a 'tool_result' block matching the tool_use id.

The Anthropic tool use protocol follows a strict request-response pattern where every 'tool_use' block generated by the model must be acknowledged by the client with a corresponding 'tool_result' block. This ensures that the model's context is updated with the actual outcome of the requested action before it attempts to generate further text.

They provide clear delimiters for variable content.

XML tags provide a clear, unambiguous structure that helps Claude identify where one variable ends and another begins. This is especially important when the variables contain unstructured text that might include characters like colons or dashes, which could confuse the model if simple text labels were used as delimiters.

Implement a maximum iteration counter in the application logic

Infinite loops are a common risk in agentic architectures where the model believes it hasn't found the right answer. Implementing a hard limit on the number of iterations and tracking the history of tool calls are standard safety measures to prevent runaway token usage and ensure the system remains responsive.

Return a single 'user' message containing three 'tool_result' blocks with matching IDs

Parallel tool use requires that the orchestration layer executes all requested tools and returns a 'tool_result' for each one. Crucially, each result must include the unique 'tool_use_id' generated by the model. This allows Claude to correctly map the data from the external world back to the specific requests it made, maintaining the logical flow of the agent's reasoning.

claude

Starting a session is the first step in the Claude Code workflow. The CLI command initializes the environment, scans the directory for relevant files, and establishes a connection to the Anthropic API. This process allows the model to understand the codebase context before the user begins asking questions or requesting edits.

Periodically summarize the interaction history and include the summary in the next prompt.

Managing context size and relevance is critical for long-running LLM applications. Summarizing previous turns prevents the context window from becoming cluttered with irrelevant information that might distract the model or lead to degradation in recall. By periodically condensing history, you ensure the model maintains focus on the most important state information, which directly improves the reliability of long-form conversational tasks.

Few-shot prompting.

Few-shot prompting is a foundational technique used to guide the model by showing it exactly what is expected. By providing examples within the prompt, the developer can specify the tone, format, and logic required for the task, which is particularly useful for niche or highly structured requirements.

Temperature 0

For agentic tasks where structural integrity and logical consistency are paramount, a temperature of 0 is recommended. This minimizes randomness in the model's output, ensuring that tool calls follow the required schema exactly and that the reasoning steps remain deterministic and reproducible during debugging.

The model's context for 'src/auth.ts' is outdated or incorrect.

The 'edit_file' tool works by performing a search-and-replace operation. If the model's internal representation of the file is out of sync with the actual contents on disk, the operation will fail. This often happens if the file was modified by an external process or if the model's previous 'read' was incomplete.

To encourage the model to verbalize its internal reasoning before executing a tool.

The ReAct pattern combines reasoning and acting by prompting the model to generate a 'Thought' before a 'Tool Use.' This approach improves the model's ability to plan, adjust to new information, and explain its decision-making process, making the agent more transparent and reliable in complex scenarios.

Use a single request with a stop sequence on the tool_use block, execute the requested tools, then send a follow-up user message containing the tool_result blocks and repeat until Claude returns a final text response.

The agentic tool-use loop is the correct orchestration pattern because it alternates model reasoning with real tool execution, letting Claude observe each tool_result before selecting the next action. This supports decomposition, execution, and final synthesis in one evolving conversation. Batching all calls, splitting into separate conversations, or simulating tool outputs each break the observe-then-decide contract or inflate cost and latency without satisfying the stated constraints.

A clear, concise, and specific system prompt.

The quality and clarity of the system prompt serve as the primary source of truth for the model's behavior. A well-defined system prompt sets clear expectations, boundaries, and formatting requirements. By investing in prompt design, you create a stable foundation for the application, ensuring the model acts predictably even when users provide ambiguous or challenging inputs, which is essential for enterprise-grade reliability.

The Router pattern

The Router pattern is ideal for this scenario because it uses a primary model to classify the user's intent and then routes the request to specialized sub-processes or distinct system prompts. This prevents the need for a single, massive system prompt containing all instructions, which reduces input token costs and improves the accuracy of the specialized responses.

Defining explicit JSON Schema objects for every argument with strict validation.

Providing specific, constrained schema definitions within the MCP tool declaration ensures the Claude model understands the exact parameters required. This minimizes ambiguity and prevents the model from attempting to pass invalid data types. By explicitly defining the input schema using JSON Schema, the architect enforces strict structural integrity, which is critical for tool reliability and successful integration with Anthropic's platform capabilities during runtime execution.

Wrap the loop in application code that counts iterations and tool calls, stops when either budget is exhausted, and lets Claude signal completion by returning a final answer with no tool_use block.

Hard cost and safety limits belong in the orchestrator, which can count model calls and tool executions and stop deterministically at a budget boundary. Allowing Claude to end the loop by returning a response with no tool_use block keeps the agent in control of when its task is complete, so the two mechanisms together give bounded but adaptive behavior.

Wrap each retrieved article in clearly labeled XML tags with source identifiers, and instruct Claude to synthesize across all provided sources before answering.

The failure is a context-structuring problem: two retrieved articles are present but Claude anchors on one. Delimiting each article with labeled tags and explicitly instructing synthesis across all sources gives the model clear document boundaries and a reason to reconcile them. Output limits, temperature, and text merging do not change how Claude parses or prioritizes the supplied context.

Use the Anthropic API's tool use feature by defining a tool with an input schema that specifies the required "category" field and its allowed enum values, then force the model to call that tool.

Forcing the model to use a tool with a strict input schema ensures the output conforms exactly to the required JSON structure, including the key name and allowed enum values. Unlike prompt instructions or temperature adjustments, tool use provides a hard constraint enforced by the API, making it the most reliable and efficient method for schema adherence in production.

Provide the six allowed labels in a fixed, lowercase form and instruct Claude to return exactly one of those labels with no other characters.

Label uniformity is achieved by enumerating the allowed values in their canonical form and restricting the output to exactly one of them. This closes off the model's latitude to change case or append punctuation, so returned strings match database keys directly. Downstream normalization, higher temperature, and reasoning text all either mask the problem or make the output harder to consume reliably.

Use `inputSchema` with `required` arrays and property descriptions, and return `isError: true` with a structured message naming the missing field.

The MCP contract has two halves: the input schema that declares required nested properties, and the tool result that reports validation failures. Declaring `required` arrays with descriptive properties guides argument construction, while returning `isError: true` with a structured message that names the missing field gives the model a concrete correction target. Permissive schemas, plain text errors, and tool fragmentation each leave one half of the loop open.