Start with the engineering question.

Choose between a fixed rule and an adaptive threshold by measuring incident detection, noise, reset behavior, and change sensitivity.

Design alert groups around a shared operational cause and preserve split evidence, ownership, and a path to reopen a merged incident.

Evaluate capacity forecasts at the decision horizon, including asymmetric underprediction cost, data revisions, and fallback controls.

Keep observed topology, declared dependencies, deployments, and validity intervals distinct in an operational graph used for incident review.

Turn an AIOps root-cause suggestion into competing hypotheses, discriminating checks, and a claim whose strength matches the observations.

Define an automation gate that binds a recovery proposal to current state, narrow authority, expected effect, and a verifiable receipt.

Build an AIOps evaluation portfolio that tests decision quality, severe misses, operator workload, data gaps, and rollback before on-call adoption.

Define a judge rubric with an exact decision, permitted evidence, disqualifying errors, and a human escalation state.

Separate ambiguous criteria, missing evidence, and legitimate expert judgment before creating a reference set for an LLM judge.

Sample ordinary and high-consequence cases separately so an LLM judge test set reveals failures hidden by prevalence and easy examples.

Build a confusion matrix for a defined judge decision and report serious misses, false alarms, prevalence, and uncertainty separately.

Test whether judge verdicts follow the rubric when answer order, length, confidence language, or irrelevant formatting changes.

Attach a judge score to its rubric, corpus, uncertainty, and intended decision so it is not mistaken for universal answer quality.

Version judge, rubric, corpus, threshold, and historical verdicts so recalibration can improve current decisions without erasing earlier evidence.

Specify a business metric’s population, event time, exclusions, aggregation, and owner before an agent translates a question into SQL.

Attach source, transformation, owner, validity, and confidence to definitions so agents can inspect how a business claim was formed.

Derive a small ontology from decisions, records, exceptions, and competency questions rather than from a large noun inventory.

Resolve task-relevant semantic definitions by identity, time, scope, and provenance before an agent builds a data query.

Distinguish a candidate gap in semantic definitions from retrieval, query, data-quality, and user-intent failures in agent traces.

Compare a proposed definition against source support, old and new business questions, data-agent outcomes, and rollback obligations.

Monitor source, definition, mapping, and usage changes separately so a data agent does not keep producing plausible answers from stale meaning.

Turn a platform comparison into timed incident, release, and planning journeys with inspectable evidence and failure states.

Compare collection, normalization, storage, query, and retention boundaries through the investigations and failure modes the platform must support.

Verify whether applications, infrastructure, digital experience, and change records connect during one incident without false correlations.

Test whether investigators can preserve a query trail, share bounded evidence, and hand off an incident without losing context or exposing unrelated data.

Set telemetry retention and sampling policies that preserve investigation value while bounding spend and sensitive-data access.

Use fixed tasks, representative data, transparent assistance, workload conditions, and scored evidence to compare candidate platforms.

Test export, semantic preservation, alert continuity, historical investigation, and ownership before a platform migration or contract renewal.

A capacity worksheet that separates record rates, payload bytes, retained storage, replicas, recovery, and the queries an observability platform must serve.

Choose collection buffers by failure domain, outage duration, replay ownership, and acknowledgement meaning instead of treating every queue as durable delivery.

Design signal tables, typed columns, sort keys, and derived views from investigation steps while preserving tenant scope, timestamps, and signal meaning.

A metric ingestion and query contract for units, temporality, start times, identity, histogram compatibility, resets, and sampling populations.

Trace duplicate handling from a retried insert through canonical rows and incremental aggregates, with a controlled replay and correction exercise.

Design empty results and signal pivots around ingestion freshness, sampling, retention, authorization, correlation quality, and visible coverage gaps.

Bound investigative queries, replay, alerts, and background work with workload classes, resource limits, freshness objectives, and overload exercises.

A discovery workshop that turns a vague enterprise AI request into a bounded decision, evidence requirements, accountable owners, and meaningful exceptions.

A boundary review for shared identity, lifecycle, constraints, source mappings, customer policies, and the commitments that justify common maintenance.

Inspect units, identifiers, time bounds, source authority, ambiguity, and correction lineage before a field mapping becomes operational evidence.

A governed-action design separating semantic eligibility, current authorization, target state, execution, and an attributable effect receipt.

Choose one decision-shaped delivery slice and test evidence, mappings, authority, failure handling, user value, and operational handoff before expanding.

Manage a meaning change through versioned mappings, consumer impact, historical evidence, dual interpretation, migration tests, and retirement criteria.

A second-context experiment for distinguishing shared semantic commitments from copied code, local policy, mapping assumptions, and unsupported product obligations.

Choose a small collection or showcase that you understand, define a visible finish line, and add editing, storage, or accounts only when the purpose needs them.

Turn a vague request into one visible change with named inputs, expected behavior, preserved content, and a short browser check that a beginner can perform.

A practical beginner check for labels, required inputs, invalid submissions, duplicate actions, helpful errors, keyboard use, and preserved form data.

Understand local browser storage, device and origin boundaries, export files, import validation, and a restore rehearsal before trusting a personal collection.

A beginner debugging sequence using exact reproduction steps, expected and observed results, page and console evidence, one hypothesis, and a small correction.

A beginner-friendly ownership check for personal cloud apps, separating sign-in from record authorization and testing two accounts with invented data.

A small release review covering intended audience, selected files, private data, actual destinations, tested behavior, failure states, and a recoverable version.

Define the user promise, operating owner, dependency boundaries, failure response, and evidence needed before sharing an MCP tool service.

Preserve server bindings, original names, host aliases, and definition digests when an MCP host combines several tool catalogs.

Define MCP outcome denominators that distinguish transport responses, eligible tool operations, expected denial, freshness, and unknown results.

Build a directional compatibility matrix across MCP protocol revisions, host builds, server artifacts, tool definitions, policy, and backend behavior.

Plan an MCP catalog migration with compatible server behavior, measured host adoption, cache failure tests, and evidence-based retirement.

Separate MCP registry discovery from production admission using an evidence packet for origin, artifact, permissions, observed behavior, and renewal.

Rehearse removal of a remote MCP dependency while preserving workflow continuity, pending-operation evidence, credentials control, and historical meaning.

Decide whether recurring work needs a reusable agent skill, a prompt, a deterministic program, or a tool by writing the capability contract first.

Design agent skill descriptions around requested outcomes, negative examples, and ambiguity so similar skills do not compete for the same task.

Divide an agent skill into a decision spine, conditional reference material, and deterministic helpers without hiding essential rules or dependencies.

Define a skill's behavioral API, classify compatibility by observable promises, and pin package plus host dependencies before claiming a safe upgrade.

Verify a skill package by binding reviewed source, builder provenance, evaluation evidence, and signer identity to the exact artifact being installed.

Compare a candidate skill against the installed catalog to detect neighbor displacement, unintended composition, and regressions hidden by isolated tests.

Design a proposal-only skill improvement loop with sanitized failures, protected tests, independent promotion, bounded activation, and a recoverable release.

Decide whether shared agent infrastructure is warranted by production obligations, repeated ownership gaps, and the cost of maintaining another operating layer.

Design explicit outage behavior for agent configuration, task execution, evidence storage, and emergency controls using a dependency survival matrix.

Create a resolvable agent release manifest that binds code, instructions, model configuration, tools, policy, retrieval, and compatibility evidence to deployed tasks.

Plan worker compatibility, retained release cohorts, waiting tasks, migration decisions, and retirement evidence before replacing an agent revision.

Use downstream headroom, deadline feasibility, queue age, and explicit rejection rules to prevent worker autoscaling from overloading an agent service.

Allocate shared agent execution fairly with tenant queues, downstream permits, bounded borrowing, and starvation evidence beyond infrastructure quotas.

Define a bounded deployment drain that stops queue polling, accounts for active work, preserves durable handoff, and checks retirement beyond Pod readiness.

A practical test for deciding when an AI-assisted incident investigation has enough evidence to state a root cause, a contributing factor, or only a hypothesis.

A hypothesis-led method for stopping an incident agent from confusing the final recorded error with the mechanism that produced the outage.

A join-order and evidence worksheet for correlating OpenTelemetry signals through explicit identity, time, exemplars, topology, and change data.

A safe observation-gap protocol for incident agents that encounter sampling, collector loss, absent instrumentation, or an unobserved dependency.

A least-privilege method for selecting SRE diagnostic tools by data scope, query cost, credential reach, side effects, and incident value.

Explicit handoff thresholds for incident impact, evidence coverage, operational authority, time, budget, and irreversible production actions.

A reproducible incident-replay design that versions observations, tools, faults, leakage controls, graders, and safe investigative behavior.

A unit-economics diagnosis for AI products where cheaper inference is offset by retries, failures, latency, escalation, and manual repair.

A fully loaded outcome-ledger method that includes accepted, rejected, reversed, and reviewed AI work instead of dividing one provider invoice by request count.

An evidence-preserving method for reducing LLM context through necessity tests, structured compression, retrieval, and paired quality evaluation.

A task-family routing experiment that compares model policies at equal quality, escalation, refusal, latency, cost, and serious-failure conditions.

A decision framework for prompt prefixes, retrieval results, tool reads, embeddings, responses, and derived artifacts under staleness and privacy constraints.

A capacity decision method that uses arrival patterns, service levels, utilization ranges, commitment risk, and failure cost instead of average tokens.

A release record that ties AI unit cost to quality, reliability, sensitive-data handling, capacity, fallbacks, owners, and rollback thresholds.

A production design boundary for deciding what the model sees now, what the system may remember later, and what remains authoritative workflow truth.

A context-frame budget for instructions, authority, state, evidence, tools, history, uncertainty, and output reserve in production agents.

A memory lifecycle with admission, provenance, scope, expiry, promotion, conflict handling, quarantine, and rollback for production agents.

An evidence supply chain connecting source records, versions, chunks, retrieval runs, context placement, claims, citations, and downstream effects.

A resume contract for durable agents that separates checkpointed state, external effects, versions, leases, approvals, revalidation, and recovery.

A retry-safe effect protocol using operation identity, idempotency, effect receipts, reconciliation, and explicit unknown completion states.

A commit-time authorization check for agents whose identity, approval, policy, target, or proposed action can change during a pause.

A judgment-loop diagnosis for developers who are shipping faster with AI but retaining less understanding, transfer, debugging skill, and design confidence.

A five-decision card for defining the user, outcome, constraints, failure behavior, and verification evidence before implementation begins.

A constraint-first architecture decision for teams considering microservices without independent change, scale, ownership, or reliability needs.

An outcome-state model that separates HTTP response success from acceptance, commit, visibility, confirmation, and durable business effect.

A failure exercise for retry amplification, duplicate effects, synchronized load, stale work, budget exhaustion, and unsafe compensation.

A learning workflow that gives AI bounded tutor and reviewer roles while preserving prediction, retrieval, debugging, and independent verification.

A progressive practice program using predictions, retrieval, failure drills, design reviews, transfer tasks, and bounded AI roles.

A measurement-contract approach that extends reference answers with environment state, tool trajectories, permissions, budgets, uncertainty, and serious failures.

A versioned portfolio method that represents task families, users, frequency, risk, difficulty, tools, environments, and changing production failures.

A versioned environment manifest for agent tests with controlled state, time, identity, tools, dependencies, faults, resets, and observations.

A grader design that makes verified outcomes primary while using trace checks selectively for policy, safety, evidence, and diagnosis.

A decision-driven trial plan using uncertainty, task slices, correlated runs, serious failures, stopping rules, and paired comparisons.

A validation card for agent-evaluation user simulators covering persona distributions, hidden goals, behavior calibration, leakage, and transfer to real users.

A versioned quality-gate record with predefined thresholds, serious failures, uncertainty, exceptions, owners, canary evidence, rollback, and expiry.

A responsibility matrix separating durable SEO foundations from the evidence design and answer-level observations added by generative search experiences.

A staged diagnostic that checks access, indexing, retrieval, source selection, claim support, citation behavior, and measurement before rewriting a page.

An evidence-unit method for writing bounded technical claims with definitions, support, limitations, provenance, updates, and answer-sized structure.

A bounded experiment for llms.txt that preserves accessible HTML, sitemaps, robots controls, analytics, maintenance, and honest success criteria.

A crawler-purpose matrix separating search discovery, user-requested fetching, training, and other automated access while preserving security boundaries.

A reproducible GEO observation protocol for fixed questions, run conditions, citation support, source accuracy, visibility, behavior, and uncertainty.

A practical 90-day GEO program that ships technical access, evidence-backed content, measurement baselines, distribution experiments, and an executive decision.

A practical model for observing agent decisions, tool effects, evidence, cost, policy checks, and uncertainty instead of logging only the response text.

A field-level design for tracing agent runs across models, retrieval, tools, policy decisions, outcomes, cost, and privacy boundaries.

A model-span profile that separates queueing, request time, time to first token, streaming, completion state, token usage, and semantic-convention version.

A tool-action envelope that joins agent, MCP client, gateway, server, downstream service, and verified external effect without leaking payloads.

A memory-lineage schema for tracing proposals, admissions, versions, reads, promotion, expiry, conflict, deletion, and downstream effects.

A workflow relationship map for delegation, messages, artifacts, waits, checkpoints, resumes, retries, effects, and asynchronous links beyond a span tree.

A telemetry privacy profile for data minimization, bounded attributes, content capture, hashing, sampling, access, retention, deletion, and incident exceptions.

Why instruction wording cannot be the only prompt-injection control, and how to build boundaries around evidence, tools, authority, and effects.

A concrete authorization design for agent tools using identity, scoped capabilities, argument validation, risk tiers, confirmation, and effect receipts.

An identity chain that separates human, workload, task, resource, delegation, approval, and short-lived credentials for agent actions.

A threat-driven sandbox decision for code execution, browsers, tools, files, network, credentials, processes, time, persistence, and teardown.

A cross-session attack-chain analysis for poisoned memories that pass admission, retrieval, sharing, promotion, and action boundaries.

An audit-and-effect envelope connecting request, proposal, evidence, authorization, identity, parameters, target versions, attempts, and verified outcome.

A risk-tier rollout that increases autonomy through evidence, reversibility, least privilege, sandboxing, approvals, canaries, and incident readiness.

A decision-oriented definition of forward-deployed engineering, including ownership, customer proximity, product feedback, and boundaries with consulting.

A lifecycle responsibility matrix for comparing forward deployed engineers with solutions engineers, consultants, and implementation engineers.

An opportunity-qualification card balancing user value, repeatability, product fit, access feasibility, production risk, adoption, and learning return.

A productization decision that separates reusable capability, configuration, supported extension, service work, partner delivery, and requests to reject.

A practical escape from customer-specific code through bounded experiments, pattern thresholds, productization decisions, ownership, and deletion dates.

An FDE operating scorecard for user outcomes, workflow adoption, reliability, reuse, knowledge return, support load, ownership transfer, and exit readiness.

A customer-environment control checklist for least privilege, separation, temporary access, approvals, audit, data handling, reversibility, incidents, and handoff.

A decision guide for choosing controlled vocabularies, relationship models, graph representations, and governed analytical meaning without buying labels.

A systems diagnosis of CMDB staleness covering identity, evidence, reconciliation, lifecycle events, ownership, freshness budgets, and decision feedback.

A cross-signal identity contract using canonical IDs, aliases, source mappings, versions, valid time, and confidence without confusing correlation and identity.

An RCA evidence graph that uses semantic relationships to generate and test candidates while keeping dependency, sequence, correlation, mechanism, and cause distinct.

A modeling-stack decision that separates data model, vocabulary, inference, validation, query, storage, interoperability, operations, and team capability.

A temporal relation schema separating entity identity, changing state, events, valid time, record time, versions, provenance, and uncertain dependencies.

An ontology validation pack for competency questions, constraints, entailments, source mappings, temporal behavior, permissions, failures, and agent-use tests.