Designing for the Intelligence Age

You have worked through intelligence-native posture, user direction, correction patterns, memory surfaces, and transparency. This page is the index, like principles of Thoughtware for the architectural track, but for product experience. Each principle below gets one line tied to the Weekly Meal Companion pattern. It does not re-teach the chapters. Follow links for depth. The value of having all twelve principles visible on one page is that relational gaps become obvious. A product that ships low-cognitive first draft and point and fix but skips memory UX and visible thinking has an experience debt that compounds with each weekly session. The index makes that debt visible before the household names it in support tickets.

Helpful context: Best read after the foundational Designing notes in this section. For category definition, see what is Thoughtware. For structural principles, see principles of Thoughtware.

Consumers direct intelligence

People state outcomes, guide, review, and remain responsible where authority requires it. The Meal Companion accepts the originating sentence, not a feature tour. See consumers direct intelligence.

Reducing cognitive load

Five principles reduce the effort required to get useful work from the system. Low-cognitive first draft returns a full provisional week from one sentence. Point and fix lets the household tap Tuesday, say "too long," and receive a local substitution patch. Intent over instructions compiles household language to working state instead of twelve fields. Conversation over configuration lets the household adjust the week in dialogue while policy stays in explicit config. Conversation becomes state means "Tuesday got harder" updates context and plan diff, not chat alone.

Principle	Meal Companion one-liner
Low-cognitive first draft	Return a full provisional week from one sentence.
Point and fix	Tap Tuesday, say too long, receive local substitution patch.
Intent over instructions	Compile household language to working state, not twelve fields.
Conversation over configuration	Adjust the week in dialogue. Policy stays in explicit config.
Conversation becomes state	Tuesday got harder updates context and plan diff.

Software that knows you

Two principles govern how the system uses what it knows about the household. Context is a feature pulls calendar, spinach deadline, and guests with labelled sources into the planning run. Memory is part of UX lets the household approve promoting mushroom dislike and see context-only items alongside endorsed preferences.

Principle	Meal Companion one-liner
Context is a feature	Pull calendar, spinach deadline, guests, with labelled sources.
Memory is part of UX	Approve promoting mushroom dislike. Show context-only items.

Intelligence as the interface

Four principles shape how the system communicates its work. Recommend, don't only respond proposes substitution after critique rather than idle chat. What a summary leaves out keeps allergy sources and busy-day reasoning in the weekly summary. Visible thinking offers expandable rationale for why Tuesday is quick rather than dumping tokens. Intelligence over aesthetics prefers a plain list with checks over a pretty calendar with silent allergy failure.

Principle	Meal Companion one-liner
Recommend, don't only respond	After critique, propose substitution, not idle chat.
What a summary leaves out	Weekly summary keeps allergy sources and busy-day reasoning.
Visible thinking	Expandable why Tuesday is quick, not token dump.
Intelligence over aesthetics	Plain list with checks beats pretty calendar with silent allergy fail.

A new interaction model

Two principles redefine how people interact with the product surface. Language over layout puts the domain sentence in and uses layout for inspection and patch. Co-pilot the decision prepares the grocery list and cost estimate without auto-buying.

Principle	Meal Companion one-liner
Language over layout	Domain sentence in. Layout for inspect and patch.
Co-pilot the decision	Co-pilot grocery list and cost. Do not auto-buy.

How this meets Thoughtware

These principles describe experience. Thoughtware describes structure. Intent needs cognitive units that interpret. Memory UX needs endorsement paths. Visible thinking needs evaluable steps. Co-piloting needs Judgment Chains, posture, and authority that can shift without disappearing into a single fluent surface. Experience principles without principles of Thoughtware produce UI patterns that contradict locality or memory discipline. The two indices work as a pair. Auditing a feature against both indices in the same sitting reveals gaps that neither list catches alone. A product may satisfy every structural principle while violating experience principles if the interface hides the endorsement path or buries the diff behind a loading state.

The future of software is human with machine, with judgment shared across time.

Thoughtware: Designing in the Intelligence Age · Ch. 17

That future shows up in weekly loops, not demo minutes. Conduct across weeks is the product. The interface is where households notice it. Products that pass demo-day tests but lose households on week three almost always violate one of these twelve principles in a way that accumulates silently. The principles name those silent violations before retention data confirms them.

Using this index

The Designing track runs from the rise of Thoughtware through beyond the interface, with this page as the capstone. Read each linked note for depth. Use this page to audit a flagship feature against all twelve principles in one sitting: mark green (shipped with eval), yellow (partial), or red (not started) per row. Pick one yellow row per sprint for depth work on its linked note. Red rows trigger architecture pairing within the same quarter because experience principle red often means a missing cognitive unit or memory form underneath. Teams that skip the architecture pairing step often produce a surface fix that satisfies the experience checklist without addressing the underlying structural gap. The red row returns yellow the next quarter because the cognitive unit was never built, or the memory form was never connected to the endorsement path. Pairing ensures the fix reaches below the interface.

Start with intelligence-native products for context. Widen with beyond the interface. Cross-reference with The Thoughtware system for end-to-end assembly, then read Thoughtware in practice for operating discipline.

What to do next

Print the principle tables and mark each row against your flagship intelligence feature. The concrete one-liner per principle makes the audit quick: does the product actually do what the principle describes, or does it approximate or skip? Yellow rows become sprint work. Red rows become architecture conversations. Green rows get maintained through eval gates. The index stays useful as long as the product ships intelligence features, because each release can drift away from principles that held on the previous version.

Designing track complete. Continue with The Thoughtware system for the whole-system map, or return to Principles of Thoughtware to align experience with architecture.