Lead with intent, not instruction lists

An Information Age meal app asks: how many servings, which cuisine filters, max prep time, dietary tags, repeat avoidance window. The household must translate "plan dinners for four this week, Tuesday and Thursday busy, use the spinach before Wednesday" into the product's vocabulary before any planning begins.

An Intelligence Age product inverts the order. It captures the originating sentence as an intent bundle, compiles constraints and preferences into working state, returns a plan, and keeps the compiled structure visible enough to correct when inference is wrong. The household speaks domain language. The product owns procedure inference until the person disagrees.

Helpful context: Consumers direct intelligence names the user expectation. Language and conversation over configuration are neighbouring interaction disciplines.

Same task, two UX models

Instruction-first UX treats the household as a translator. Twelve form fields appear before value. The user learns a feature map. Correction means navigate settings. Hard constraints hide in toggles. Intent-first UX captures one sentence to a provisional plan. The user stays in domain language. Correction means utterance plus point and fix. Hard constraints stay exact and inspectable.

Instruction-first UX	Intent-first UX
Twelve form fields before value	One sentence to provisional plan
User learns feature map	User stays in domain language
Correction means navigate settings	Correction means utterance plus point and fix
Hard constraints buried in toggles	Hard constraints exact and inspectable

The distinction matters because Information Age products exported internal org charts into navigation. AI features added as side panes preserve that cognitive tax while claiming transformation. Intent-first design removes the tax for the primary outcome path while secondary capabilities may still use navigation for discovery. The Meal Companion does not ask the household to learn GenerateCandidates as a menu item. It returns candidates composed into a plan. Feature names stay internal. Domain outcomes stay external.

What the originating sentence compiles to

"Plan dinners for four this week. Tuesday and Thursday are busy. Use the spinach before Wednesday and avoid meals we ate last week." Behind one utterance sits context for household count, calendar busy days, ingredient deadline, and repeat avoidance this run. Hard constraints include endorsed allergies enforced in code. Soft preferences cover variety and practicality, revisable through conversation. Working state holds goal, interpreted week, and provisional plan version.

In the Meal Companion, InterpretWeek reads the originating sentence and produces an interpreted week object. Household size, busy evenings, ingredient deadlines, and repeat avoidance become typed fields the rest of the chain consumes. The household never saw those fields. They stated intent once. The product compiled it. That compilation is the architectural heart of intent-over-instructions. UX that skips the object and jumps straight to generated prose loses editability. UX that forces the household to confirm twelve fields loses the Intelligence Age opening move. The balance is a compiled object that exists for inspection and correction but does not demand confirmation before the first plan appears. Households discover the compiled fields when they need to contest an inference, not as a gate before they see value.

The user remains responsible for defining the destination. Intelligence increasingly takes responsibility for navigating the path.

Thoughtware: Designing in the Intelligence Age · Ch. 7

The UI may show a plan, not twelve empty fields. The architecture must still expose enough compiled structure for disagreement. When the product cannot compile intent, the gap is shown honestly: missing guest count, ambiguous spinach deadline, unsettled medical diet. Targeted questions are compiler errors presented in household language. Silent guess is the failure mode intent-first design avoids.

Intent without structure is dangerous

Fluent completion that hides assumptions is abdication dressed as convenience. The product shows the inferred plan, material assumptions, and alternatives where the Collaboration Contract requires decision, not approval alone. People directing intelligence still own the destination, the grants, and contested values. The product may infer more of the path, but it cannot invent authority or bury the plan so thoroughly that disagreement becomes impractical.

Structured conversation becomes state is the neighbouring discipline. Utterances become inspectable objects with schema, visibility, and editability. When inference is wrong, intent-first products correct in domain language: "swap Tuesday for something faster." Instruction-first products force return to form fields the household already abandoned. That reset is why intent-over-instructions pairs with point and fix and conversation becomes state. The three patterns form a tight loop: intent captures the opening sentence, conversation turns correction into state updates, and point and fix applies targeted repairs without forcing the household back to instruction entry.

Medical diets, purchases, and consent still belong to people even when planning is delegated. Intent capture separates what the household wants from what the system may do. Escalation paths appear when terrain is unsettled or authority is missing. Targeted questions beat silent invention.

When instruction panels still belong

Exact constraints with audit requirements stay in configuration. Allergy lists endorsed by a clinician. Purchase approval limits. Org policy on data retention. Intent captures direction. Configuration holds law.

The mistake is forcing every preference through forms because forms feel safe. The complementary mistake is hiding law inside chat because chat feels modern. Both failures show up as "it forgot" and "it bought without asking." Hard allergy stays in the endorsed panel. Soft preference revision flows through utterance without a settings dive. Intent-first design distinguishes soft from hard explicitly in UX and architecture.

The enterprise parallel follows the same split. A clerk states "resolve the disputed invoice with vendor context," not "open form section four." Intent compiles to working state on an exception queue. Hard policy stays in code. Soft routing preferences stay revisable until approved. The pattern repeats wherever domain experts already speak in outcomes and procedures were always implicit. Legal teams draft motions by stating the outcome they want, not by filling case management fields one at a time. The compiled objects differ across domains, but the interaction grammar of intent capture followed by structured correction stays constant.

Measuring intent capture

Tracking how often users navigate settings to fix something that belongs as an utterance reveals intent-capture maturity. Contest rate on compiled fields shows whether compiled structure is visible enough for disagreement. High contest with invisible compilation signals abdication dressed as convenience.

Product reviews benefit from opening with the originating sentence before discussing widgets. When the team cannot write that sentence in domain language, the feature is still instruction-shaped. Engineering tickets that list compiled state fields and their types prevent intent skin on instruction bones. QA scenarios that verify contest paths on each compiled field without navigating settings guard against regression.

Intent capture regressions often arrive through new settings panels that reintroduce feature vocabulary. Each new panel that forces navigation for a task households already phrase as outcomes is a silent reversion. Voice input, text input, and any other modality feed the same compiler. The compiled output stays identical regardless of the channel.

The common mistakes follow a pattern: twelve hidden fields populated silently behind one chat line, outcome capture without authority boundaries, instruction manuals disguised as natural language wizards that still demand feature map literacy. Each produces the same failure: the household must learn the product's vocabulary before it can correct the product's inference, and the opening move that promised freedom becomes a trap dressed in conversational copy.

What to do next

The originating sentence for any flagship flow reveals the gap between intent capture and instruction capture. Listing the fields that sentence compiles to, with hard versus soft classification, shows where architecture supports domain language and where it forces feature vocabulary. The connection to conversation is immediate: conversation over configuration describes how dialogue replaces dense settings for everyday intent, and conversation becomes state shows how utterances update structured objects rather than appending transcript lines.

See point and fix and consumers direct intelligence.

Read next: Conversation over configuration.