CCAR-P concepts, explained

The repeating model-tool-observe cycle that lets Claude act, read results, and decide the next step until a goal is met.

Workflows follow predefined code paths; agents let the model dynamically direct its own steps and tool use.

A coordinator agent decomposes a task, delegates subtasks to worker subagents, and synthesizes their results into a final answer.

Whether one agent handles a task end-to-end or several specialized agents coordinate — a tradeoff of simplicity against parallelism and isolation.

A required human approval checkpoint inserted before an agent takes a consequential or irreversible action.

Designing agent actions so that safely retrying a failed or duplicated call produces the same effect as running it once.

Choosing between interactive real-time requests and the Batch API's cheaper, high-latency asynchronous processing for large non-urgent jobs.

Match the task to the tier: Opus for hardest reasoning, Sonnet for balanced work, Haiku for fast, cheap, high-volume tasks.

You cannot retrain Claude's weights on your data; you adapt behavior through prompts, context, tools, and RAG.

Reuse a stable, up-front prompt prefix across calls so repeated tokens are cheaper and faster to process.

An optional mode where Claude produces internal reasoning before its answer, improving hard tasks at extra token cost.

Actively curating what goes into the model's finite token window so the relevant signal isn't crowded out.

Getting the model to return machine-parseable data (usually JSON) that conforms to a schema you define.

Quality decay that sets in when a context window fills with stale, irrelevant, or contradictory tokens.

An open protocol that standardizes how apps expose tools, data, and prompts to LLMs over a client/server link.

Retrieve relevant documents at query time and ground the model's answer in them instead of relying on parametric memory.

How you split source documents into retrievable units — it sets the ceiling on everything retrieval can return.

A precision second pass that reorders an over-fetched candidate set so the most relevant chunks land in the prompt.

Combines semantic (dense vector) and keyword (sparse/BM25) search so you catch both meaning and exact terms.

Enforce who can see which documents in the retrieval/data layer — never by asking the model in the prompt to filter.

MCP is a reusable standard layer for exposing tools/data to any MCP host; a direct API call is bespoke, app-specific glue.

Instrument each step of an agent/RAG run — prompts, retrievals, tool calls, tokens, latency — so you can debug and evaluate it.

Define measurable success criteria and an eval harness before building, then let scores gate every change.

Use a strong LLM to score or compare outputs against a rubric when exact-match grading is impossible.

A curated, versioned set of representative inputs with trusted expected outputs used to score every change.

Offline eval scores a fixed dataset before shipping; online eval measures real behavior on live traffic.

Separate whether RAG fetched the right context (retrieval) from whether the answer stayed true to it (faithfulness).

Re-run a fixed eval suite on every change so quality drops are caught before they reach users.

Cut spend and response time without dropping below your quality bar, using evals to guard the tradeoff.

Route to a human on fixed policy rules, never on the model's self-reported confidence score.

When a safety check errors or is unavailable, deny the action (fail-closed) rather than allow it (fail-open).

Guardrails belong at input screening, output screening, and tool-call authorization — a single output filter is not enough.

Grant an agent, tool, or credential only the minimum access needed for its task — nothing more.

Treat all retrieved and tool-returned content as untrusted data, and enforce must-hold rules in code, not the prompt.

A living map of each obligation to a named control, an accountable owner, and the evidence that proves it works.

The line between what model training covers and what your application layer must enforce itself.

Detect and remove personal data before it reaches the model, logs, or downstream systems that don't need it.

Deciding which incoming signals warrant escalation versus routine handling, using pre-agreed rules rather than in-the-moment judgment.

What it would take to undo a decision — the element most often missing from a Gains / Gives-up / Reversal-cost analysis.

The auditable record of what a project achieved, anchored to a control-in-place and a named measurement owner.

Three lifecycle stages with rising evidence bars: PoC proves it can work, pilot proves it works for real users, production owns it.

Two rollout patterns: canary exposes a small slice first; blue-green flips all traffic between two full environments.

Proving the new system produces equivalent results to the old one before you cut over — not after.

The accountable owner's recorded agreement to proceed or accept — and the point where a design only the architect understands fails.

Publishing, versioning, and governing reusable Claude Skills across a team so upgrades and spend stay controlled.

Running Claude Code non-interactively in a build pipeline with guardrails on any code it changes.

A structured review pass that confirms AI-written code is actually correct, not merely syntactically valid.

Diagnosing an agent's production symptom by mapping it to the architectural layer that actually caused it.

Opinionated, well-supported default workflows that make the safe, productive way the easy way for developers.

Choosing the right Claude build surface: raw API, the Agent SDK harness, or the full Claude Code product.