Applicability conditions

The Meal Companion has served twenty fast, successful weeks using Busy Week Pattern v0.2. Week twenty-one looks similar: busy evenings, leftovers OK, spinach in the fridge. The pattern activates and produces a plan that violates a new constraint someone mentioned casually: a low-FODMAP trial this week. Surface similarity triggered compression. A hidden condition failed. That is expertise without adequate guards.

Applicability conditions are the heart of reliable compression. They answer under what circumstances this strategy may run. Failing the guard returns work to full deliberation loudly, not silently.

Helpful context: How expertise forms defines the artifact. False familiarity shows misfires when guards are weak. Deliberation and automaticity describes runtime effects when guards pass.

Guards license speed

Compression saves cost and latency. It also concentrates risk. A fast path wrong on a consequential axis damages trust faster than a slow path wrong with visible uncertainty. Guards exist to concentrate benefit without concentrating unbounded risk.

Applicability conditions function as a contract between the artifact and the runtime. The artifact promises a strategy skeleton that worked under stated circumstances. The runtime promises not to invoke the artifact when those circumstances are absent. Breaking the contract on either side produces misfires.

The Busy Week guard, concretely

Before Busy Week Pattern runs, the system checks five conditions. At least two low-time evenings exist in the week. Busy evenings are clearly identified in context. No unfamiliar medical restriction is present. Leftovers are acceptable this week, or confirmed. The temporary request does not conflict with the strategy skeleton.

Each item is inspectable in working state. None is a model hunch. Failure on the medical restriction condition routes interpretation to deferral. Failure on the conflict condition triggers challenge as conduct or targeted questions, not silent override.

Conditions are readable in product copy when compression runs. Users learn what kind of week triggered the fast path. They also learn what would have blocked it. That transparency converts speed from magic into earned trust.

The guard passing is what licenses the compressed strategy. The guard failing is what returns the work to full deliberation.

Introduction to Thoughtware · Ch. 26

Checklist-forward design

When authoring expertise, conditions come before the strategy skeleton. The process starts by listing material axes that differ week to week: schedule, medical, ingredients, preferences. For each axis, the author specifies required state or explicit absence. Failure behaviour follows: defer, ask, challenge, or full replan. Regression cases cover each failure mode. When a misfire reveals a missing condition, the guard versions.

Guards are what make fast paths trustworthy across time. Hope is not a guard. Similarity is not a guard. User tone is not a guard unless translated into inspectable state.

Guards are living documents

Applicability conditions are write-once only in the sense that v0.1 must ship with v0.1 conditions. Production teaches missing axes. Each false familiarity incident is a guard update candidate. Versioning expertise artifacts when conditions change gives teams a clear history of what the pattern learned and when.

The parallel to API schemas is useful. Breaking changes get version bumps and migration notes. Callers that invoke expertise inspect guard metadata or accept runtime refusal when conditions fail. v0.2 exists because v0.1 missed a material axis. That version history is the artifact's learning record.

Conditions versus preferences

Applicability conditions are gates for licensing compression. "Household prefers variety" belongs in judgment cognitive units inside the strategy. "Unfamiliar medical restriction absent" belongs in the guard.

Mixing the two produces guards that are really hopes. Too weak to prevent false familiarity, too vague to test in regression. Preferences can vary inside a licensed pattern. Gates decide whether the pattern may run at all. The line between them is the line between adaptive behaviour and dangerous pattern-matching.

What passing and failing look like

When the guard passes, the request matches the grounding reference compression run. Three busy evenings, spinach before Wednesday, leftovers once, no medical frontier. Pattern runs, checks fire, critique once, patch if needed. Predictable, adaptive, bounded.

When the guard fails, a doctor's mention of low-FODMAP appears in context. Medical interpretation is frontier terrain. Household or professional leads. Pattern does not run. System states why: unfamiliar medical restriction present. User sees deliberation, not random slowdown.

Support macros reference guard names, not model moods. "Pattern withheld due to medical frontier" is actionable. "The AI was confused" is not. The difference in those two sentences measures whether the architecture surfaces enough information for support to be useful.

Regression design for guards

Each condition deserves at least one regression case that passes and one near-miss that fails. Near-miss cases are more valuable than happy paths for guard design. They encode the question: what could look the same while materially differing?

Medical mentions buried in long messages, expired allergy endorsements, guest count changes, broken oven constraints: each is a classic hidden axis for meal planning. Other domains have their own list. The method transfers. The habit of asking "what could look the same while materially differing?" is the single most productive question for guard authoring.

Substitution and libraries

In a library of cognition, applicability conditions travel with the artifact. Substitution rules respect guards. A newer pattern version may tighten conditions without breaking callers that inspect before invoke. Substitution rules and libraries of cognition cover placement and interchangeability.

Private prompts that bypass libraries often bypass guards too. Centralizing expertise makes conditions visible to evaluators and support alike. Visibility provides the difference between a library the team can search and a folder the original author can barely find.

Guard failure as telemetry

Tracking guard failure rate per artifact in production reveals environment shifts that regression suites miss. Rising failures may signal new user profiles, seasonal changes, or stale conditions. Flat accuracy on old suites plus rising guard failures means the world changed, not that the model forgot.

Telemetry connects to version bumps. Otherwise teams debate model quality when the artifact is outdated. The feedback loop between production telemetry and guard versioning is how expertise stays calibrated over time.

Common mistakes

Implicit guards are the most common: "usually works" encoded in prompt tone. Partial guards follow close behind: schedule checked, medical ignored. Non-binary gates create a different problem: conditions that "sort of pass" cannot license compression clearly. Guard theatre rounds out the set: conditions listed in docs but not enforced in runtime.

Each mistake is diagnosable once the question is explicit. Is the condition enforced? Is it binary? Is it complete? If any answer is no, the guard needs work before the artifact runs in production.

Authoring guards with the household in mind

Guards use language the product can surface without embarrassment. "Unfamiliar medical restriction present" is clearer to support than "embedding_vector_med_flag false." Households do not need to see internal names, but they see plain reasons when compression refuses to run.

Involving product copy early when defining conditions improves both sides. If a condition cannot be explained in one sentence to a tired user, it may be too vague to implement reliably. Clarity for users and clarity for engineers converge when conditions are well-written.

When to split artifacts instead of adding guards

Sometimes guard lists grow until the artifact covers two different strategies. If Busy Week Pattern and Guest Week Pattern require different skeletons, splitting artifacts beats bolting optional branches onto one guard set. Applicability conditions define when an artifact may run. They do not require cramming every related strategy into one artifact.

Splitting is a maintenance win. Evaluators can regression test each artifact independently. Telemetry can show which pattern misfires more often. Libraries stay searchable when names match real household shapes.

Connecting guards to abstention and deterministic checks

When a guard fails on frontier terrain, the next step may be abstention rather than immediate full replan. The guard still did its job by refusing compression. Downstream conduct chooses deferral, targeted question, or full loop. Refuse and defer covers stop behaviour after guard failure.

Some guard conditions belong in deterministic code because they are exact: allergy endorsement present and unexpired, count of busy evenings at least two. Others require judgment in working state: leftovers acceptable this week when the household has been ambiguous before. Splitting exact checks into code where possible keeps the guard crisp. Keeping judgment-backed conditions explicit in the artifact keeps them testable. Mixed guards fail when everything routes through a model hunch.

Documenting which conditions are exact versus interpretive helps evaluators choose the right test data for each class. Exact conditions get boolean fixtures. Interpretive conditions get graded trajectories. Reviewing guards quarterly when production traffic includes seasonal patterns catches drift before users do.

What to do next

The most direct test of this idea is picking one cached workflow, prompt shortcut, or smart default in the product and writing applicability conditions explicitly. Adding one regression case where the surface looks similar but a hidden axis differs reveals whether the guard is complete or hopeful.

False familiarity shows the consequence when guards miss a material axis. Deliberation and automaticity describes the runtime effect of guard pass and fail. How expertise forms defines the artifact shape guards attach to.

Read next: False familiarity.