CCAR-F curriculum

An agent loop with no hard stop is a cost incident waiting for a bad day. Design the termination condition before you design the loop.

Manager/subagent, parallel fan-out, and sequential pipeline solve different shapes of problem. Picking by habit instead of by task shape is the exam's favorite trap.

A subagent that inherits the whole parent transcript isn't isolated, it's just expensive. Pass structured handoff data, not a history dump.

A handoff that isn't validated is a silent data-loss bug waiting for the one run where a field is missing. Enforce the boundary, don't trust it.

A prompt instruction not to call a dangerous tool is advisory. An SDK-level hook that blocks it categorically is architecture. Put enforcement in code.

Too fine and you pay orchestration overhead for nothing. Too coarse and one failure costs the whole run. Decompose by volatility, not by habit.

Conversation history isn't durable state. If a resumed step can double-fire a side effect, the architecture is missing an idempotency boundary, not a retry.

CLAUDE.md is versioned project memory, not a system prompt substitute. Layer it broad-to-specific and keep it about the repo, not the request.

A skill earns its place by being invoked more than once with the same shape. Keep its output short — its report is the thing that stays in context, not its work.

A repeatedly-invoked skill that reports its full findings into the main session will eventually crowd them back out. context: fork isolates the work and returns only the summary.

Compaction buys room by summarizing the past. It's the right tool for a session that's simply run long, and the wrong tool for one that's crowded by one noisy source.

Claude Code hooks enforce policy deterministically, in settings.json, outside the model's judgment — a different layer from an Agent SDK's own lifecycle hooks.

Permission settings resolve by precedence across enterprise, project, and user scope. Design the safe default at the top and let narrower scopes only tighten it.

The system prompt is standing instruction, not a junk drawer — per-turn data and duplicated tool descriptions belong elsewhere, or the cache never engages.

Tool-use forces a schema the model can't wander outside of; prompted JSON is a request the model can decline to honor exactly.

Chain-of-thought and few-shot examples earn their keep on genuinely hard tasks — standardize what generalizes, and stop copy-pasting what was really a fix for one prompt.

An instruction stated once at turn 1 competes with everything that comes after it — design for turn 40, not just the happy-path first message.

Well-formatted isn't the same as correct, and complete isn't the same as parseable — validate stop_reason, schema, and business rules as three separate checks.

A tool is a contract you write for a reader that can't ask you what you meant. Name and describe it for the moment of selection, not the moment of implementation.

A tool that swallows its own exception hands the agent nothing to recover with. Return the failure as data, and let the model decide what to do next.

stdio and HTTP aren't interchangeable transports with different syntax — they encode different assumptions about who runs the server and who else can reach it.

Adding a second MCP server multiplies your integration surface, not just your tool count — naming collisions and a slow server both become the architecture's problem.

Credentials belong on the tool-execution side of the boundary, never in the context the model reads — the model should request an action, not hold the key that performs it.

A context window is a budget, not a limit you hit and then panic about. Reserve headroom before the session starts, and degrade before you fail.

Caching one call is a placement problem. Caching a system is a strategy problem: which layers cache, which TTL fits the traffic, and how caching survives your own pruning.

A retry without idempotency doesn't fix a failure — it doubles a side effect. Timeouts have to match the call shape, not a single global number.

You can't fix what you can't see, and manual spot-checks don't scale past a demo. Log the loop, not just the output, and eval before users find the regression.