{
  "name": "Claude Code agent-engineering reference",
  "count": 45,
  "license": "CC-BY-4.0",
  "generated": "2026-10-08",
  "source": "https://shop.intirama.com/",
  "guides": [
    {
      "slug": "guide-agent-audit-logging",
      "title": "What to log when an agent acts autonomously — building a reconstructable audit trail",
      "description": "A human's mistake is explainable because you can ask them. An agent's mistake is explainable only if you logged enough to reconstruct the decision after the fact. A guide to what an audit trail for an autonomous agent actually needs: the prompt that triggered it, the tool calls it made, the inputs and outputs of each, and the state it observed before deciding.",
      "url": "https://shop.intirama.com/guide-agent-audit-logging.html"
    },
    {
      "slug": "guide-agent-canary-rollouts",
      "title": "Canary and shadow rollouts for agent changes — shipping a new prompt or model without betting all your traffic",
      "description": "A prompt or model change that passed every offline eval can still regress in production, because production traffic is never exactly the eval set. How to ship agent changes behind a shadow run and a small canary slice, so a bad change is caught on 2% of traffic instead of 100%.",
      "url": "https://shop.intirama.com/guide-agent-canary-rollouts.html"
    },
    {
      "slug": "guide-agent-code-execution-sandboxing",
      "title": "Sandboxing code an agent writes and runs — isolation, not just permission scope",
      "description": "Permission scoping limits which tools an agent can call. It doesn't limit what code the agent writes and then executes can do once it's running. A guide to isolating agent-generated code execution: process boundaries, filesystem and network scope, and resource limits.",
      "url": "https://shop.intirama.com/guide-agent-code-execution-sandboxing.html"
    },
    {
      "slug": "guide-agent-context-window-management",
      "title": "Context window management for long-running agents — what to keep, what to drop, what to summarize",
      "description": "A long agent session doesn't fail because the model got dumber — it fails because the context window filled up with stale tool output and the one fact that mattered got pushed out. Managing a context window well means deciding, deliberately, what earns a permanent place, what gets summarized, and what gets dropped.",
      "url": "https://shop.intirama.com/guide-agent-context-window-management.html"
    },
    {
      "slug": "guide-agent-cost-budgeting",
      "title": "Cost and token budgets for autonomous agents — stopping a runaway loop before the bill does",
      "description": "An autonomous agent has no innate sense of cost. A practical approach to per-task token budgets, detecting runaway loops before they burn through spend, and choosing between a cheaper model and an early stop instead of finding out from the invoice.",
      "url": "https://shop.intirama.com/guide-agent-cost-budgeting.html"
    },
    {
      "slug": "guide-agent-eval-regression-testing",
      "title": "Regression testing for AI agent behavior — why passing CI doesn't mean the agent didn't get worse",
      "description": "A prompt tweak, model swap, or tool change can silently make an agent worse at the thing it was actually good at, while every unit test stays green. Regression testing for agent behavior needs a golden task set, a scoring method that tolerates non-determinism, and a gate that runs before every change ships — not another unit test suite.",
      "url": "https://shop.intirama.com/guide-agent-eval-regression-testing.html"
    },
    {
      "slug": "guide-agent-feedback-memory",
      "title": "Designing feedback memory for agents — capturing corrections and confirmations, not just facts",
      "description": "Persistent memory stores facts about the world. Feedback memory stores something different: guidance the user gave about how to work, both corrections and confirmations. Skip the confirmations and an agent avoids old mistakes but drifts away from approaches the user already approved.",
      "url": "https://shop.intirama.com/guide-agent-feedback-memory.html"
    },
    {
      "slug": "guide-agent-human-escalation-design",
      "title": "Designing when an agent should stop and ask a human — escalation without alert fatigue",
      "description": "Permission scoping decides what an agent is allowed to do. Escalation design decides when it should stop and ask a human anyway. A practical approach to approval gates, batching, timeout defaults, and avoiding the alert fatigue that makes humans rubber-stamp everything.",
      "url": "https://shop.intirama.com/guide-agent-human-escalation-design.html"
    },
    {
      "slug": "guide-agent-permission-scoping",
      "title": "Scoping an agent's permissions — why \"can run any command\" is the bug",
      "description": "A CI permission guide covers who's watching. A secrets guide covers what leaks. This one covers a third axis: how wide the agent's tool grant is in the first place — allowlists over denylists, per-tool scope over blanket shell access, and why the fix for a bad agent action is usually a narrower grant, not a smarter prompt.",
      "url": "https://shop.intirama.com/guide-agent-permission-scoping.html"
    },
    {
      "slug": "guide-agent-persistent-memory-design",
      "title": "Designing persistent memory for agents — what survives across sessions, what doesn't",
      "description": "Context window management decides what stays inside one session. Persistent memory decides what an agent should still know a week later, in a different conversation. The two need different rules, and reusing context-window instincts for memory produces a system that either forgets everything useful or drowns in stale facts.",
      "url": "https://shop.intirama.com/guide-agent-persistent-memory-design.html"
    },
    {
      "slug": "guide-agent-prompt-injection-defense",
      "title": "Prompt injection defense for agents that read untrusted content",
      "description": "Permission scoping limits what an agent can do; secrets handling limits what it can leak. Neither stops a webpage, issue comment, or file the agent reads from talking it into misusing the access it legitimately has. A guide to defending agents against instructions hidden in the content they process.",
      "url": "https://shop.intirama.com/guide-agent-prompt-injection-defense.html"
    },
    {
      "slug": "guide-agent-prompt-versioning",
      "title": "Versioning and rolling back agent system prompts — treating instructions like a deployable",
      "description": "A system prompt that changed last Tuesday and broke a workflow is a production incident with no stack trace. How to version, diff, and roll back agent instructions the same way you'd treat any other deployable artifact — distinct from writing a good CLAUDE.md or testing a change before it ships.",
      "url": "https://shop.intirama.com/guide-agent-prompt-versioning.html"
    },
    {
      "slug": "guide-agent-rate-limit-backoff",
      "title": "Rate limits and backoff for agent tool calls — surviving 429s without cascading failure",
      "description": "An agent that retries a failing API in a tight loop turns one degraded dependency into an outage. How to design backoff, jitter, and circuit breakers for agent tool calls — distinct from cost budgeting (spend control) and idempotent tool design (retry safety), this is about not making a bad situation worse.",
      "url": "https://shop.intirama.com/guide-agent-rate-limit-backoff.html"
    },
    {
      "slug": "guide-agent-secrets-handling",
      "title": "Secrets and credentials in an AI agent's shell — where they actually leak",
      "description": "An agent with shell access can read, echo, log, and paste any secret in its environment. A checklist for where credentials actually leak in agent workflows: env var inheritance, command output, logs, and prompts — and what to scope instead of trusting the agent to avoid.",
      "url": "https://shop.intirama.com/guide-agent-secrets-handling.html"
    },
    {
      "slug": "guide-agent-structured-output-validation",
      "title": "Validating and repairing agent structured output — handling malformed JSON before it reaches downstream code",
      "description": "An agent's structured output looks like JSON almost all the time, which is exactly what makes the remaining failures dangerous. A practical approach to validating, repairing, and rejecting malformed agent output before it reaches a parser that trusts it.",
      "url": "https://shop.intirama.com/guide-agent-structured-output-validation.html"
    },
    {
      "slug": "guide-agent-supply-chain-trust",
      "title": "Supply-chain trust for AI agents — the tools and skills you didn't write",
      "description": "Permission scoping, sandboxing, prompt injection defense, and multi-agent trust boundaries all assume the agent's own tools and skills are trustworthy. Supply-chain trust is about the case where they aren't: a third-party MCP server, skill package, or dependency the agent loads is itself the attacker.",
      "url": "https://shop.intirama.com/guide-agent-supply-chain-trust.html"
    },
    {
      "slug": "guide-agent-task-checkpointing",
      "title": "Checkpointing long-running agent tasks — resuming without redoing or duplicating work",
      "description": "An agent doing a 40-step migration gets killed at step 23 by a deploy, a timeout, or an operator interrupt. A guide to checkpointing agent task progress so resuming means picking up at step 24, not re-running steps 1-23 and re-triggering every side effect they caused — distinct from persistent memory and from per-call idempotency.",
      "url": "https://shop.intirama.com/guide-agent-task-checkpointing.html"
    },
    {
      "slug": "guide-agent-tool-call-caching",
      "title": "Caching tool calls for agents — when memoizing a result is safe and when it lies",
      "description": "An agent that re-reads the same file, re-runs the same search, or re-calls the same API ten times in one session is wasting tokens and time on work it already did. Caching tool results fixes that, but only when the cache key captures everything the result actually depended on. How to design cache keys, invalidation, and staleness signals for agent tool calls — distinct from idempotent tool design (safe to retry) and cost budgeting (spend limits).",
      "url": "https://shop.intirama.com/guide-agent-tool-call-caching.html"
    },
    {
      "slug": "guide-agent-tool-call-parallelization",
      "title": "Parallel tool calls for agents — which ones are safe to fire together",
      "description": "An agent that can call several tools in the same turn will often fire them together to save time. Some of those calls are genuinely independent; others share a file, a rate limit, a bank balance, or an ordering assumption, and running them at once produces a race instead of a speedup. How to decide which tool calls are safe to parallelize, which need to be sequential, and how to design tool responses so an agent can tell the difference — distinct from caching (skipping a call) and rate-limit backoff (surviving a call that failed).",
      "url": "https://shop.intirama.com/guide-agent-tool-call-parallelization.html"
    },
    {
      "slug": "guide-agent-tool-contract-drift",
      "title": "Tool contract drift — what happens when the API underneath an agent's tool changes shape",
      "description": "A tool an agent has called successfully for months can start failing silently the day its underlying API adds a required field, renames a parameter, or changes a response shape. How to detect and contain tool contract drift — distinct from tool description design (how a tool is written) and tool error messages (how a single failure is reported), this is about a contract changing underneath a long-lived agent without anyone editing the tool.",
      "url": "https://shop.intirama.com/guide-agent-tool-contract-drift.html"
    },
    {
      "slug": "guide-agent-tool-deprecation",
      "title": "Deprecating an agent tool without breaking sessions that are already mid-task",
      "description": "Removing or renaming a tool an agent depends on is safe for new sessions and dangerous for existing ones — a session that planned around a tool that vanishes mid-task fails in a way no eval catches. A staged deprecation process: mark, warn, redirect, then remove.",
      "url": "https://shop.intirama.com/guide-agent-tool-deprecation.html"
    },
    {
      "slug": "guide-agent-tool-description-design",
      "title": "Writing tool descriptions agents actually use correctly — schema and wording that prevent wrong-tool and bad-argument calls",
      "description": "An agent doesn't fail to use a tool because it's a bad tool. It fails because the description didn't say the one thing that would have prevented the wrong call. Most tool-use failures trace back to wording and schema, not model capability.",
      "url": "https://shop.intirama.com/guide-agent-tool-description-design.html"
    },
    {
      "slug": "guide-agent-tool-error-messages",
      "title": "Designing tool error messages agents can actually recover from — the runtime half of tool design",
      "description": "A well-described tool can still fail at runtime, and what it returns when it fails decides whether the agent corrects itself in one step or burns the rest of its budget retrying the same broken call. Tool description design covers the call before it happens; this covers the response after it fails.",
      "url": "https://shop.intirama.com/guide-agent-tool-error-messages.html"
    },
    {
      "slug": "guide-agent-tool-output-sizing",
      "title": "Sizing tool output for agents — pagination, truncation, and summarization at the source",
      "description": "A tool that can return a thousand rows or a ten-thousand-line file has to decide what it hands back before the agent ever sees it. How to design tool output size at the source — cursors over silent truncation, counts over guesses, summarization only when it's the tool's job — distinct from context window management (what an agent does with output already in its context) and tool error messages (how a failed call is reported).",
      "url": "https://shop.intirama.com/guide-agent-tool-output-sizing.html"
    },
    {
      "slug": "guide-agent-tracing-observability",
      "title": "Tracing an agent's decision path — observability beyond print statements",
      "description": "A stuck or slow agent run produces a wall of chat text, not a stack trace. How to instrument agent sessions with spans and correlation IDs so you can see which step was slow, which tool call was redundant, and where a loop started — distinct from audit logging and from root-cause bug tracing.",
      "url": "https://shop.intirama.com/guide-agent-tracing-observability.html"
    },
    {
      "slug": "guide-blameless-postmortems",
      "title": "Blameless postmortems: a checklist for the three ways they quietly fail",
      "description": "Most postmortems aren't ruined by naming names. They're ruined by stopping at the trigger instead of the root cause, reconstructing the timeline with hindsight the responders didn't have, and shipping follow-up actions that don't trace back to any actual cause. A checklist for catching all three.",
      "url": "https://shop.intirama.com/guide-blameless-postmortems.html"
    },
    {
      "slug": "guide-changelog-from-git-log",
      "title": "How to generate a changelog from git log without an LLM",
      "description": "A practical guide to turning Conventional Commits into a categorized changelog and a correct semver bump using plain git log parsing — no API key, no network call, no LLM required.",
      "url": "https://shop.intirama.com/guide-changelog-from-git-log.html"
    },
    {
      "slug": "guide-concurrency-bug-finding",
      "title": "Concurrency bug finding: name the interleaving, not \"might race\"",
      "description": "Concurrency bugs are code that's individually correct and only breaks under a specific interleaving. A practical checklist for shared mutable state, lock discipline, async ordering assumptions, and init races — plus why 'this might race' isn't a finding.",
      "url": "https://shop.intirama.com/guide-concurrency-bug-finding.html"
    },
    {
      "slug": "guide-dependency-upgrade-risk-triage",
      "title": "Dependency upgrade risk: why the changelog and the semver bump both lie",
      "description": "A dependency's changelog tells you what the maintainer thinks changed. It doesn't tell you what your code actually calls, whether that call site sits behind the bump, or how deep the transitive graph moved. A checklist for triaging real risk before you upgrade.",
      "url": "https://shop.intirama.com/guide-dependency-upgrade-risk-triage.html"
    },
    {
      "slug": "guide-diagnosing-flaky-tests",
      "title": "Diagnosing flaky tests: a checklist for the four real causes",
      "description": "Flaky tests almost always come from one of four mechanisms: timing, shared state, ordering, or an external dependency. A practical checklist for telling them apart before you reach for retries.",
      "url": "https://shop.intirama.com/guide-diagnosing-flaky-tests.html"
    },
    {
      "slug": "guide-error-log-triager",
      "title": "Error log triage: volume is not impact",
      "description": "A raw error dump is a triage problem, not a read-every-line problem. A practical checklist for grouping errors by real root signature and ranking by actual impact instead of raw occurrence count.",
      "url": "https://shop.intirama.com/guide-error-log-triager.html"
    },
    {
      "slug": "guide-headless-ci-permissions",
      "title": "Running Claude Code headless in CI — what changes when no one can click \"allow\"",
      "description": "Claude Code's permission prompts assume a human at a terminal. In CI there isn't one, so a naive headless run just hangs until the job times out. Here's how allowlists, denylists, and print mode actually fit together for unattended pipelines.",
      "url": "https://shop.intirama.com/guide-headless-ci-permissions.html"
    },
    {
      "slug": "guide-hooks-vs-skills",
      "title": "Hook or skill? When automation needs to be guaranteed, not just likely",
      "description": "Hooks and skills both let Claude Code do things without being asked, but only one of them is guaranteed to run. A practical guide to picking between a harness-enforced hook and a model-triggered skill for repeatable behavior.",
      "url": "https://shop.intirama.com/guide-hooks-vs-skills.html"
    },
    {
      "slug": "guide-idempotent-tool-design",
      "title": "Designing tools for AI agents to call — idempotency, dry-run, and blast radius",
      "description": "An agent will call your tool more than once for the same intent — on retry, on ambiguity, on a re-run after a crash. A guide to designing agent-facing tools so a repeat call is safe by construction: idempotency keys, dry-run modes, and bounding blast radius instead of trusting the agent to call once.",
      "url": "https://shop.intirama.com/guide-idempotent-tool-design.html"
    },
    {
      "slug": "guide-memory-leak-hunting",
      "title": "Memory leak hunting: reference chains, not \"check for leaks\"",
      "description": "Restarting the process fixing it temporarily is the strongest leak signal there is. A practical checklist of the six mechanisms that actually cause unbounded memory growth, ranked by how often they're the real cause.",
      "url": "https://shop.intirama.com/guide-memory-leak-hunting.html"
    },
    {
      "slug": "guide-multi-agent-trust-boundaries",
      "title": "Trust boundaries between agents — when a subagent's output becomes another agent's input",
      "description": "Permission scoping, sandboxing, and prompt injection defense all bound a single agent's contact with untrusted content. Multi-agent systems add a different boundary: one agent's output becomes another agent's input, and by default it's trusted like a return value instead of treated like unreviewed text.",
      "url": "https://shop.intirama.com/guide-multi-agent-trust-boundaries.html"
    },
    {
      "slug": "guide-perf-regression-hunting",
      "title": "Perf regression hunting: it's a diff problem, not a profiling problem",
      "description": "When something got slower and there's a known-good 'before,' profiling from scratch wastes the one advantage you have: a baseline to diff against. A checklist for the five regression shapes that cover most real-world slowdowns.",
      "url": "https://shop.intirama.com/guide-perf-regression-hunting.html"
    },
    {
      "slug": "guide-reversible-agent-actions",
      "title": "Designing reversible actions for autonomous agents — undo, not just retry-safety",
      "description": "Idempotency makes a retry safe. It says nothing about whether the first call was a mistake you can take back. A guide to designing agent actions so a wrong decision has a way out: soft deletes over hard ones, snapshots before mutation, dry-run as a default not an option, and where a confirmation gate actually belongs.",
      "url": "https://shop.intirama.com/guide-reversible-agent-actions.html"
    },
    {
      "slug": "guide-reviewing-agent-diffs",
      "title": "Reviewing an AI agent's diff — what actually needs checking before you merge it",
      "description": "An agent's diff passes its own tests and still hides the wrong kind of bug. A checklist for what to actually look at before merging AI-generated changes: scope creep, silently dropped error handling, invented abstractions, and the tells that a change was never run.",
      "url": "https://shop.intirama.com/guide-reviewing-agent-diffs.html"
    },
    {
      "slug": "guide-root-cause-tracing",
      "title": "Root-cause tracing: why the first plausible cause is usually wrong",
      "description": "When a bug is traced backward, the trail almost always stops at the first plausible-looking cause instead of the real origin. A practical checklist for telling the difference: proximate cause, contributing condition, and true origin.",
      "url": "https://shop.intirama.com/guide-root-cause-tracing.html"
    },
    {
      "slug": "guide-safe-db-migration-checklist",
      "title": "Safe database migrations: a checklist for lock, rollback, and rollout risk",
      "description": "Most migration incidents come from three gaps: a lock the app can't tolerate, a rollback that isn't actually symmetric, and a rolling deploy where old and new code hit the same schema. A checklist for catching all three before you run it.",
      "url": "https://shop.intirama.com/guide-safe-db-migration-checklist.html"
    },
    {
      "slug": "guide-skill-vs-subagent-vs-slash-command",
      "title": "Skill, subagent, or slash command? Picking the right container for a workflow",
      "description": "Claude Code gives you three ways to package a repeatable workflow: a skill, a subagent, or a slash command. A practical decision guide based on what each one actually changes — context, model, and invocation — not just what it's named.",
      "url": "https://shop.intirama.com/guide-skill-vs-subagent-vs-slash-command.html"
    },
    {
      "slug": "guide-worktrees-for-parallel-agents",
      "title": "Git worktrees for parallel AI coding agents — one repo, isolated working trees",
      "description": "Running more than one Claude Code agent against the same repo at once causes edit collisions and stale state. Git worktrees give each agent its own checked-out branch on the same .git — here's when that isolation is worth it and when it isn't.",
      "url": "https://shop.intirama.com/guide-worktrees-for-parallel-agents.html"
    },
    {
      "slug": "guide-writing-a-claude-md",
      "title": "Writing a CLAUDE.md that actually changes behavior",
      "description": "Most CLAUDE.md files are ignored past the first few lines. A practical checklist for what to put in project instructions, what to leave to skills instead, and why vague preferences don't survive contact with a real task.",
      "url": "https://shop.intirama.com/guide-writing-a-claude-md.html"
    },
    {
      "slug": "guide-writing-agent-task-descriptions",
      "title": "Writing task descriptions an agent can actually execute — tickets, issues, and prompts",
      "description": "A CLAUDE.md sets repo-wide context once. A task description sets the goal for one run. Most agent failures blamed on 'the model didn't understand' are actually the ticket leaving out the one fact that mattered. A practical checklist for writing task descriptions agents can execute without guessing.",
      "url": "https://shop.intirama.com/guide-writing-agent-task-descriptions.html"
    }
  ]
}