Track deprecation timelines: Monitor provider announcements, so you're not caught off guard.

Abstract the model: Route through a gateway, so swapping is low-friction.

Test replacements early: Evaluate successor models ahead of deprecation, so you're ready to switch.

Re-tune for the new model: Adjust prompts for successor behavior, so quality is preserved.

Migrate before forced: Switch proactively, so you're not scrambling at the deadline.

Re-check before acting: Verify state right before the action, so you act on current reality.

Use optimistic locking: Detect if state changed since read, so stale-state actions are caught.

Make actions conditional: Execute only if state still holds, so changes don't cause wrong actions.

Handle conflicts: Retry or re-evaluate on state change, so you adapt rather than fail.

Minimize read-to-action gap: Shorten the window, so less can change in between.

Isolate use cases: Keep them modular, so adding one doesn't affect others.

Regression-test existing cases: Verify old use cases still work on every change, so regressions are caught.

Route by use case: Direct requests to appropriate handling, so use cases don't interfere.

Avoid shared-prompt bloat: Don't cram all cases into one prompt, so they don't dilute each other.

Monitor per use case: Track quality by case, so regressions surface.

Detect emotional signals: Recognize stress or upset in the user, so responses can adapt.

Adjust tone: Respond with appropriate empathy, so the answer fits the emotional context.

Address the underlying need: Attend to what's driving the emotion, so you help beyond the literal request.

Avoid tone-deafness: Don't respond mechanically to distress, so the interaction feels human.

Escalate genuine distress: Route serious cases to human support, so real needs get proper care.

Checkpoint frequently: Save progress often, so preemption doesn't lose much work.

Make work resumable: Design tasks to continue after interruption, so preemption isn't fatal.

Handle preemption signals: React to reclaim warnings, so you save state before shutdown.

Distribute redundantly: Spread work across instances, so losing one doesn't halt everything.

Retry preempted work: Automatically reschedule interrupted tasks, so they complete eventually.

Define scope explicitly: Specify what the agent is designed to handle, so boundaries are clear.

Detect out-of-scope requests: Recognize when a question exceeds scope, so drift is caught.

Decline gracefully: Redirect out-of-scope requests, so the agent doesn't wander into unreliability.

Route to alternatives: Point users to better-suited resources, so out-of-scope needs are still served.

Monitor scope creep: Track out-of-scope requests, so recurring needs inform expansion decisions.

Structure for screen readers: Use proper semantic structure, so assistive tech can parse output.

Provide text alternatives: Describe non-text content, so it's accessible.

Use clear language: Favor plain, readable phrasing, so content is broadly understandable.

Follow accessibility standards: Conform to guidelines like WCAG, so requirements are met.

Test with assistive tools: Validate output with screen readers, so accessibility gaps surface.

Externalize rules as config: Store business rules outside code, so non-engineers can change them.

Provide a safe interface: Give a controlled way to edit rules, so changes don't require code.

Validate rule changes: Check edits against constraints, so bad rules are rejected.

Test before applying: Run rules through evals, so changes are verified.

Enable rollback: Let rule changes be reverted, so mistakes are recoverable.

Keep numbers out of generation: Handle precise values in code, not the model, so they aren't approximated.

Pass by reference: Use identifiers for values and compute externally, so the model doesn't retype numbers.

Validate against source: Check output numbers match inputs, so corruption is caught.

Preserve significant figures: Enforce precision requirements, so rounding doesn't lose accuracy.

Compute with tools: Route calculations to exact tools, so precision is guaranteed.

Track spend against pace: Monitor burn rate versus time elapsed, so you see if you're on track.

Set pacing targets: Allocate budget across the period, so spend is distributed.

Throttle as budget depletes: Slow non-essential usage when running low, so you don't exhaust early.

Prioritize under constraint: Reserve remaining budget for critical work, so essentials are protected.

Alert on overpace: Flag when spend outpaces the plan, so you react before running out.

Degrade gracefully near limits: Shift to cheaper handling as budget tightens, so service continues.

Capture actionable feedback: Collect specific signals on what went wrong, so feedback is usable.

Categorize feedback: Group issues by type, so patterns emerge.

Feed into evals: Convert feedback into test cases, so fixes are validated and regressions prevented.

Prioritize by frequency: Address common complaints first, so effort maximizes impact.

Close the loop with users: Show that feedback led to change, so users keep providing it.

Minimize metadata capture: Log only what's necessary, so sensitive metadata isn't accumulated.

Redact in logs and traces: Mask sensitive request details, so metadata doesn't leak through observability.

Encrypt metadata: Protect it at rest and in transit, so it's not exposed.

Control access: Restrict who can see request metadata, so exposure is limited.

Set retention limits: Expire metadata on schedule, so it doesn't persist unnecessarily.

Track retrieval frequency: Measure what gets retrieved, so you know what's used.

Prune dead content: Remove never-retrieved documents, so the index stays lean.

Tier storage: Keep hot content fast and cold content cheap, so cost matches usage.

Prioritize valuable content: Ensure high-value documents are well-indexed, so coverage serves real needs.

Monitor coverage gaps: Watch for retrieval failures, so pruning doesn't remove needed content.

Decompose the request: Break it into distinct parts, so each is tracked.

Address each part: Ensure every component gets answered, so none is neglected.

Verify completeness: Check all parts are covered before responding, so gaps are caught.

Structure the response: Organize by part, so coverage is clear to the user.

Flag what's unanswerable: Note parts you can't address, so silence isn't mistaken for an answer.

Distinguish correlation from causation: Prompt the model to separate them, so it doesn't conflate the two.

Ground in evidence: Base causal claims on actual support, so conclusions aren't speculative.

Surface assumptions: Make causal reasoning explicit, so flawed logic is visible.

Express uncertainty: Flag when causation is inferred, not established, so users don't over-rely.

Verify causal claims: Check reasoning against known facts, so wrong conclusions are caught.

Enforce the exact format: Constrain output to the legacy spec, so deviations don't occur.

Validate strictly: Check output against the format before sending, so bad input is caught.

Use templates: Generate within fixed scaffolding, so structure is guaranteed.

Transform post-generation: Convert model output into the required format in code, so the model doesn't need perfect formatting.

Handle rejections: Retry with correction when the legacy system rejects, so failures are recovered.

Estimate real confidence: Derive a genuine reliability signal, so expressed confidence has a basis.

Match tone to certainty: Express uncertainty when confidence is low, so tone doesn't oversell.

Flag double-check-worthy answers: Signal when verification is warranted, so users don't over-trust.

Ground confidence in evidence: Tie certainty to support, so it reflects reality, not fluency.

Validate calibration: Check that stated confidence matches accuracy, so calibration stays honest.

Learn user preferences: Capture how each user weighs trade-offs, so decisions reflect their priorities.

Ask when it matters: Clarify preferences on significant trade-offs, so you don't assume.

Apply stored preferences: Use known preferences where relevant, so past input shapes decisions.

Explain trade-offs made: Surface the choices, so users can correct misaligned ones.

Update from feedback: Refine preferences as users react, so alignment improves.

Detect missing references: Recognize when a request assumes context you lack, so gaps are identified.

Ask for what's needed: Request the missing file or information, so you can actually help.

Avoid guessing: Don't fabricate the missing context, so answers aren't built on invention.

Search available sources: Check if the reference exists in accessible data, so you find it if possible.

Communicate clearly: Tell the user what you're missing, so they can provide it.

Validate before writing: Check data quality on write, so bad data doesn't enter the shared store.

Control write access: Restrict which agents can write what, so corruption sources are limited.

Version writes: Track changes with history, so bad writes can be reverted.

Isolate write paths: Separate write concerns, so one agent's errors don't cascade.

Detect corruption: Monitor data integrity, so bad writes are caught early.

Enable rollback: Restore prior good state, so corruption is recoverable.