PACER Learning Map
PACER classifies every concept by how to learn it, then routes it to the right technique. Work the path in order — build understanding first (Conceptual → Analogous → Procedural), then drill facts to memory (Reference), and pin the numbers last (Evidence).
| Type | Goal | Technique | Site mode |
|---|---|---|---|
| Conceptual | Understand | concept maps, elaboration, why/when | map |
| Analogous | Anchor | anchor to prior knowledge; state the analogy | analogy |
| Procedural | Walk the steps | flowcharts + spaced practice | steps |
| Reference | Drill | flashcards + spaced repetition (SM-2) | flashcards |
| Evidence | Attach | attach the stat to its concept; low drill | evidence |
Understood—
Conceptual · Procedural · Analogous concepts you've marked understood.
Memorised—
Reference facts matured (interval ≥ 21d) or not yet due in spaced repetition.
All 115 concepts by type
Conceptual51Analogous5Procedural21Reference36Evidence2
By domain
Conceptual17Analogous2Procedural4Reference5Evidence0
Conceptual 17
- Tool execution types (client vs server) Map the client-vs-server boundary; drill that bash/text_editor/computer/memory are client-executed.
- Subagent decision criteria Map when-to/when-not tradeoffs: parallelism/isolation/independence vs sequential/shared-state.
- Adaptive thinking and effort Understand effort levels and when to use each; SRS-drill the effort enum and the budget_tokens 400 error.
- Interleaved thinking Understand thinking-between-tool-calls; SRS-drill which models auto-enable vs need the beta header.
- Extended thinking with tool use Anchor the rule: echo the unmodified signed thinking block with the tool_result; drill the any/tool incompatibility.
- Task decomposition (chaining vs adaptive) Map the tradeoff: static prompt chaining vs dynamic adaptive decomposition; pick per predictability of the path.
- State across context windows Understand durable-state tradeoffs; trace the framework-first-then-todo-iteration workflow.
- Workflows vs Agents Map the tradeoff: predefined code paths vs self-directed agents; start simple, add complexity only when it pays off.
- Augmented LLM Anchor the triad: LLM + retrieval + tools + memory as the building block of all patterns.
- Routing Workflow Recognise classify -> specialized handler; use only for distinct, accurately-classifiable categories.
- Parallelization Workflow Distinguish the two variants: sectioning (speed) vs voting (confidence); subtasks are pre-defined.
- Autonomous Agents Anchor 'agent = LLM using tools in a loop'; drill the ACI/poka-yoke terms and when-to-use-agents rule.
- Goal-oriented delegation Contrast goals+criteria vs procedural micromanagement; remember enum params guide behavior.
- PreToolUse hook enforcement Anchor the signature rule: PreToolUse hook is the only reliable enforcement; drill exit-2 vs JSON deny mechanics.
- Structured Intermediate Representations Trace the lossy-handoff fix: subagent outputs -> format conversion layer -> common claim/evidence/source/confidence schema.
- The Production Architecture Blueprint Anchor to the three mottos: intelligence at the edges, strict typing in the middle, shared memory sustaining the lifecycle.
- Zero-Tolerance Compliance Anchor the rule: hard limits enforced at the app-layer intercept, not prompts; remember the 3% failure stat.
Analogous 2
- Hub-and-spoke orchestration Anchor to the hub-and-spoke analogy: orchestrator hub + specialist spokes in isolated context.
- Evaluator-Optimizer Workflow Anchor to the writer-editor analogy: generate -> critique -> refine in a loop.
Procedural 4
- Agentic loop Trace the while-loop: tool_use -> execute -> append tool_result -> resend; note only tool_use continues.
- pause_turn handling Memorise the recovery step: resend the conversation unmodified (no tool_result to build).
- Prompt Chaining Workflow Trace the fixed step sequence with optional gates; contrast with dynamic decomposition.
- Orchestrator-Workers Workflow Trace orchestrator -> dynamic subtasks -> workers -> synthesis; key distinction is runtime-determined subtasks.
Reference 5
- Stop reasons SRS-drill the exact stop_reason strings and what each one means for the loop.
- Task and Agent tool SRS-drill the exact facts: Task->Agent rename v2.1.63, allowedTools, run_in_background default, built-in tool names.
- AgentDefinition SRS-drill the field lists and precedence chains (programmatic > filesystem; env > invocation > frontmatter > main).
- Workflow tool SRS-drill the exact facts: Workflow tool, TS Agent SDK v0.3.149+, scripts dozens-hundreds of agents.
- Architect's Reference Matrix SRS-drill the 4x4 grid: constraint rows x domain columns -> the pattern in each cell (and the blanks).
Conceptual3Analogous0Procedural1Reference11Evidence0
Conceptual 3
- Skills And Slash Commands Understand lazy-loading vs always-loaded CLAUDE.md (the why); drill SKILL.md frontmatter fields.
- Checkpointing and Rewind Understand the scope limit (bash file changes are NOT tracked); drill the /rewind menu actions.
- Output Styles Understand that styles swap the system prompt; drill the built-in style names and the /output-style removal.
Procedural 1
- Plan Mode And Explore Subagent Trace the plan -> approve -> edit flow and how to enter/exit plan mode.
Reference 11
- Config Hierarchy SRS-drill the precedence order: Managed > CLI > Local > Project > User.
- CLAUDE.md Hierarchy Memorize the load order and which CLAUDE.md files are read at each scope.
- CLAUDE.md Imports And Rules SRS-drill the exact @import syntax and the 4-hop depth limit.
- Auto Memory Memorize MEMORY.md path, the 200-line/25KB load cap, default-on toggle, and disable env var.
- Permissions Merge And Deny Beats Allow Memorize the merge rule: deny always beats allow, across all scopes.
- Hook Types And Events SRS-drill the exact event names and when each fires.
- Hook Exit Codes And JSON Output Memorize exit codes 0/2/other and the deny > defer > ask > allow precedence.
- Custom Slash Commands SRS-drill the substitution syntax ($ARGUMENTS, $N, !bash) and that skill wins on a name clash.
- Filesystem Subagents (.claude Agents) SRS-drill the frontmatter fields (model defaults to inherit) and the file-precedence chain.
- CI CD Headless Flags SRS-drill the flag names and what each does (-p, --output-format, etc.).
- Session Resume And Fork SRS-drill the flags (--resume/-r, --continue/-c, --fork-session) and that fork never mutates the original.
Conceptual6Analogous0Procedural6Reference4Evidence0
Conceptual 6
- Prompt Clarity And Motivation Grasp why explaining the why improves outputs; reason it through, not memorize
- Role Prompting Understand how a system-prompt persona shifts tone/expertise; reason not rote
- XML Structuring Understand why tags reduce ambiguity, then note which tag names Claude expects
- Long-Context Ordering Understand the query-last / docs-first ordering principle and why it helps
- Opus Severity-Filter Trap Understand the failure mode conceptually so you recognize it in scenarios
- Building Evals Understand what makes an eval valid, then practice authoring graded test cases
Procedural 6
- Few-Shot Prompting Practice building 3-5 relevant/diverse/structured examples; cite inconsistent-output rule
- Validation-Retry Loops Rehearse the validate -> re-prompt -> retry loop steps until automatic
- Multi-Pass And Multi-Instance Review Walk through the pass/instance review steps on a sample output
- Mathematical consistency enforcement Practice the dual-total + mismatch-flag pattern; cite the 18% invoice error stat
- Resilient schema design Practice converting fragile enums into catch-all + detail fields on real schemas
- Routing for cost and SLA Drill the SLA decision tree; cite the 50% batch savings and sub-30m threshold
Reference 4
- Prefill Migration SRS-drill the exact version/prefill rules; then practice the migration steps
- Structured Outputs SRS-drill the schema limits: additionalProperties:false, 20/24/16, unsupported features
- Message Batches API SRS-drill the exact limits: 100k requests, 256MB, 24h window, custom_id
- Prompt Technique Taxonomy Flashcard the list of technique names until recall is automatic
Conceptual11Analogous1Procedural2Reference6Evidence0
Conceptual 11
- Strict Tool Use understand what strict mode enforces; drill the flag
- Input Examples practice writing good input examples
- Effective Tool Descriptions practice writing a clear tool description
- Tool Choice understand the auto/any/tool/none tradeoffs
- MCP Connector understand connector role; drill beta header mcp-client-2025-11-20
- MCPToolset Allowlist and Denylist understand allowlist vs denylist precedence
- Defer Loading and Tool Search understand why defer loading saves context
- Tool Namespacing understand why namespacing prevents collisions
- Poka-Yoke Tool Design understand error-proofing; anchor to physical poka-yoke
- Token-Efficient Tool Responses understand response trimming; cite token-savings figures
- MCP Primitives understand the primitive types and their roles
Analogous 1
- MCP Architecture anchor to the USB-C-for-AI analogy
Procedural 2
- Subagent Error Handling trace the error-handling flow step by step
- Agentic Tool Evaluation Loop rehearse the eval loop steps in order
Reference 6
- Tool Definition Schema memorize required schema fields, then reason about why
- Tool Name Regex SRS-drill the exact regex ^[a-zA-Z0-9_-]{1,64}$
- Structured Tool Errors SRS-drill fields isError/errorCategory/isRetryable
- MCP Config Scopes SRS-drill the exact scope names and precedence
- Built-in Tools SRS-drill the built-in tool names (Grep/Glob/Read)
- Token-Efficient Tool Use SRS-drill the beta header; cite token-savings figures
Conceptual7Analogous2Procedural3Reference9Evidence0
Conceptual 7
- Progressive Summarisation Risk Understand why summarising a summary compounds loss; recall the verbatim-active mitigation
- Context Engineering Understand it as the superset discipline; prompt engineering is one subset
- System Prompt Altitude Understand the Goldilocks zone between over-specific brittleness and vagueness
- Just-in-Time Retrieval Understand load-on-demand vs pre-load; contrast the two retrieval models
- Structured Note-Taking Understand write-out/pull-back memory loop; recall the verbatim definition
- Error Propagation In Multi-Agent Systems Understand structured error context vs generic status; recall the metadata fields
- Stratified Sampling And Confidence Scores Understand confidence-score routing and why stratified sampling audits high-risk segments
Analogous 2
- Context Rot Frame as a token 'budget' where accuracy decays as the window fills
- Lost In The Middle Picture attention as a U-curve strong at start/end, weak in the middle
Procedural 3
- Server-side Compaction Step through the compaction flow; note which models support the beta
- Scratchpad Pattern Walk the record-then-reread flow; know what fields the scratchpad holds
- Tool Context Pruning Rehearse the filter-to-needed-fields step before results enter context
Reference 9
- Context Windows By Model Memorize which models are 1M vs 200k and their max-output caps
- Context Awareness Memorize the exact tags <budget:token_budget> and <system_warning>
- Context Editing Memorize the beta header context-management-2025-06-27 and clear_tool_uses strategy
- Memory Tool Memorize the tool type memory_20250818 and the GA / no-beta-header caveat
- Prompt Caching SRS-drill the cache math: 0.1x read, 1.25x/2x write, TTLs, min-token thresholds
- Caching Plus Batching SRS-drill the stacked cost math: 50% batch on top of 0.1x/1.25x/2x cache
- ZDR Eligibility Memorize the eligible-vs-disqualifying feature list
- Model Lineup And Pricing Memorize the model-ID / context / price table; verify against live docs
- model_context_window_exceeded behaviour Memorize the two cases: 400 on input-only overflow vs graceful stop_reason on 4.5+
Conceptual5Analogous0Procedural3Reference0Evidence1
Conceptual 5
- Escalation triggers internalize the three valid triggers and why complexity/sentiment/confidence are not
- Wrong escalation signals internalize that sentiment, confidence scores, and complexity are always-wrong triggers
- Explicit-request-overrides rule internalize the rule: explicit human request escalates immediately, overrides everything
- Minimal footprint principle internalize least-drastic/reversible action, but unhelpfulness is not trivially safe
- Claude's Constitution internalize the principal hierarchy and reversibility-weighted harm as the why behind escalation
Procedural 3
- Structured handoff summary memorize the five required handoff fields; never dump a raw transcript
- Limits of automated retry trace the retry loop and the 2-3 attempts then fail-fast rule
- The Escalation Handoff trace the two-branch handoff tree: immediate escalation vs context-gathering
Evidence 1
- Human-in-the-loop calibration cite the >90% auto-resolve threshold with field-level confidence scores
Conceptual2Analogous0Procedural2Reference1Evidence1
Conceptual 2
- MCP Tool Specificity understand why granular single-purpose tools plus good descriptions beat one broad tool
- Shared Memory Architecture grasp shared vector store vs daisy-chaining logs via the state-decoupling analogy
Procedural 2
- Compressing Long Sessions trace the split: narrate resolved turns, keep active issue verbatim; anchor on 48 turns
- Graceful Tool Failure memorize the flag names isError/errorCategory/isRetryable and the return-in-result pattern
Reference 1
- Forcing Execution Order memorize the tool_choice:{type:tool,name:...} param set on the first call
Evidence 1
- Parallelization and Caching cite 12 subagents / 80K+ tokens / 40+s; fan-out cuts latency, caching cuts transfer