Use transactions where possible: Make multi-step operations atomic, so partial failure doesn't leave inconsistency.

Design compensating actions: Undo completed steps on failure, so state is rolled back.

Make steps idempotent: Ensure retries are safe, so recovery doesn't compound the problem.

Checkpoint before risky steps: Save state to restore to, so you can recover cleanly.

Detect inconsistent state: Check for and repair inconsistency, so it doesn't persist.

Map to control requirements: Align system capabilities with specific controls, so compliance is demonstrable.

Provide audit evidence: Generate records proving controls are met, so verification is possible.

Document controls: Maintain clear documentation of how each requirement is satisfied, so adopters can verify.

Enable independent audit: Give auditors access to verify, so compliance isn't just claimed.

Monitor control adherence: Track that controls stay in effect, so compliance is continuous.

Capture full state on failure: Log everything needed to reproduce, so transient bugs have a record.

Record inputs and randomness: Store seeds and exact inputs, so runs can be replayed.

Snapshot context: Save retrieved data and config at failure time, so conditions are reconstructable.

Provide replay tooling: Enable re-running captured failures, so bugs can be investigated.

Increase logging on rare paths: Add detail where transient bugs occur, so next time is diagnosable.

Detect source conflicts: Identify when sources disagree, so it's not resolved silently.

Rank source authority: Weight more reliable sources higher, so conflicts favor trustworthy data.

Prefer recent data: Favor fresher information when sources conflict, so stale data doesn't win.

Surface the disagreement: Tell users when sources differ, so they can judge.

Cite competing sources: Attribute conflicting claims, so the disagreement is transparent.

Diagnose the bottleneck: Determine what's actually limiting you, so you address the real constraint.

Estimate optimization headroom: Assess how much efficiency you can gain, so you know if it suffices.

Compare cost of each: Weigh optimization effort against scaling spend, so you pick the cheaper path.

Optimize first, then scale: Exhaust cheap efficiency gains before adding capacity, so you don't overspend.

Scale when optimization runs out: Add capacity once efficiency is maxed, so growth isn't blocked.

Track data provenance: Know which parts are cached versus live, so consistency can be reasoned about.

Align freshness: Ensure combined data reflects the same point in time, so parts don't contradict.

Refresh together: Update related cached and live data jointly, so they stay coherent.

Detect inconsistency: Check combined results for contradictions, so problems are caught.

Prefer live for critical fields: Use live data where consistency matters most, so key facts are current.

Red-team systematically: Probe with adversarial inputs proactively, so weaknesses are found before attackers do.

Validate and sanitize inputs: Screen for malicious patterns, so crafted inputs are caught.

Constrain behavior: Bound what the agent can do, so adversarial inputs can't push it far.

Detect anomalies: Flag unusual input patterns, so attacks are noticed.

Fail safely: Degrade securely under attack, so exploitation doesn't cause harm.

Patch discovered weaknesses: Fix vulnerabilities as found, so robustness improves over time.

Record commitments: Log what the agent promised, so they're tracked.

Reference them later: Check commitments when relevant, so they're honored.

Follow through: Ensure promised actions actually happen, so commitments aren't empty.

Flag conflicts: Detect when new actions contradict commitments, so consistency holds.

Communicate commitment status: Tell users where promised work stands, so they can rely on it.

Parse defensively: Handle format variations gracefully, so minor changes don't break parsing.

Use structured output modes: Enforce schemas where the model supports them, so format is guaranteed.

Validate before using: Check parsed output is well-formed, so malformed data is caught.

Retry on parse failure: Re-prompt with feedback when parsing fails, so recoverable errors resolve.

Fall back gracefully: Handle unparseable output cleanly, so failures don't cascade.

Measure against goals: Track how well the system meets business objectives, so priorities tie to value.

Analyze usage and failures: Understand what's used, what breaks, and what's missing, so decisions are data-driven.

Weigh impact against effort: Rank changes by return, so you work on the highest-leverage items.

Retire what's unused: Remove low-value features, so complexity stays justified.

Balance new against maintenance: Allocate between features and reliability, so the system stays healthy while growing.

Revisit priorities regularly: Reassess as the system and needs evolve, so evolution stays aligned.

Analyze remaining failures: Categorize what still goes wrong, so the loss sources are identified.

Establish the ceiling: Test with ideal conditions, so you know the achievable maximum.

Attribute loss by stage: Measure where quality drops, so the biggest losses are found.

Compare against best-case: Diff current performance from the ceiling, so the gap is quantified.

Target the largest gaps: Focus effort where most quality is lost, so improvement resumes.

Model the timing window: Define when action is appropriate, so the agent knows the right moment.

Wait for sufficient signal: Avoid acting before enough information arrives, so early action is prevented.

Set deadlines: Bound how long to wait, so late action is prevented.

Monitor conditions: Watch for the trigger to act, so timing is responsive.

Handle the edges: Manage what happens if the window is missed, so failures are graceful.

Identify hidden defaults: Surface assumptions about units, formats, and norms, so they're visible.

Make defaults configurable: Let region determine defaults, so assumptions adapt.

Detect user region: Infer or ask for locale, so the right defaults apply.

Avoid hardcoding norms: Don't bake in one region's conventions, so behavior generalizes.

Test across regions: Validate for multiple locales, so region-specific assumptions surface.

Inject faults deliberately: Simulate error conditions on demand, so they can be tested.

Mock failing dependencies: Force dependencies to fail in tests, so error handling is exercised.

Use chaos testing: Randomly introduce failures, so untested paths are triggered.

Replay past incidents: Recreate real error conditions from history, so known cases are covered.

Assert on error behavior: Verify graceful handling under each condition, so error paths are validated.

Validate batch completeness: Check a batch is whole before processing, so incomplete ones are caught.

Detect missing records: Identify gaps against expected counts, so incompleteness surfaces.

Wait or flag: Hold for completion or mark as partial, so you don't treat incomplete as whole.

Process what's valid: Handle complete portions where safe, so partial data still provides value.

Communicate incompleteness: Signal when results are based on partial data, so users judge accordingly.

Show intermediate steps: Surface the reasoning path, so users can follow and check it.

Cite evidence per step: Ground each step in data, so claims are verifiable.

Make assumptions explicit: State what the reasoning rests on, so users can validate premises.

Enable drill-down: Let users inspect any step in detail, so verification is possible.

Separate conclusion from working: Give the answer plus its derivation, so both quick use and verification are served.

Externalize policy: Store policy as config or retrievable content, so it's not baked into prompts.

Retrieve current policy: Pull the latest policy at answer time, so answers reflect what's current.

Version policy: Track policy changes, so you know which applied when.

Update centrally: Change policy in one place, so all answers stay aligned.

Validate against policy: Check answers comply with current policy, so violations are caught.

Segment your metrics: Slice quality by user type, region, and use case, so segment issues surface.

Compare across segments: Look for segments underperforming the average, so localized problems are found.

Build segmented eval sets: Test each segment separately, so gaps are caught in testing.

Alert on segment divergence: Flag when a segment degrades, so you notice before it spreads.

Diagnose per segment: Investigate why a segment differs, so fixes are targeted.

Match source to need: Use the fast source for tolerant cases and the authoritative one where accuracy is critical, so each fits.

Serve fast, verify async: Return the fast answer, then confirm against the authoritative source, so you get speed with a correctness check.

Cache the authoritative source: Store its results to serve fast, so you avoid the slow path on repeats.

Escalate on stakes: Use the authoritative source when being wrong is costly, so risk drives the choice.

Communicate the trade-off: Signal when an answer is fast-but-provisional, so users know its reliability.

Externalize behavior: Store prompts, rules, and config outside code, so changes don't need redeploys.

Make it data-driven: Drive behavior from configuration, so requirements change by editing data.

Hot-reload changes: Apply updates without restart, so changes take effect immediately.

Validate before applying: Check changes are safe, so live updates don't break things.

Enable instant rollback: Revert changes without redeployment, so mistakes are quickly undone.