Traditional software taught us to think like machines, learning interfaces, mastering workflows, adapting to embedded logic. LLMs flip this relationship: we express intent, agents execute skills. The shift from clicks to cognition changes everything about how we design and use digital tools.
1) Fixed systems taught us their logic
For decades we learned the interface first, the work second. The GUI lineage, popularized after early Xerox PARC patterns and spotted as a leap in human–computer interaction, solidified a world where creators embed their mental models into the product. Users adapt. Manuals, onboarding, and courses translate the designer's cognitive architecture into steps the rest of us can follow.
SaaS amplified this logic. Workflows shipped as product. We trained users to move through fixed paths, one modal dialog and help article at a time. Even with user-generated content and richer customization, the center held: the system's design determined how capability was accessed. If the feature was not in the menu, it was not in reach.
Good design made the clunk less painful. We standardized patterns, reduced friction, and hid brittle edges. But the trade remained: power came from mastering someone else's thinking, not expressing our own.
2) The break: LLMs as real‑time cognitive extensions
LLMs change the rhythm. Instead of “learn the tool, ” we can say “describe the outcome” and let an agent execute the workflow. The ability to “download” a skill on demand. Not magic, still bounded by models, data, and context, but the shift is real. The interaction surface becomes intent, not clicks.
This reframes the relationship between user and system:
- From user training to agent instruction. You guide a capable assistant with clear goals, constraints, and examples rather than master a product.
- From feature discovery to skill invocation. Capabilities unbundle from apps. A single agent can orchestrate across tools if granted the right permissions and context.
- From interface navigation to outcome verification. The burden moves to specifying intent, supplying reference materials, and checking outputs.
Call it a cognitive extension: offloading steps, transforming inputs, drafting and executing plans. The user's mental model can lead, while the creator's architecture becomes substrate, still important, but less visible.
3) A Tetrad for LLM‑powered agents
McLuhan's Tetrad helps frame the effects.
Enhances
- Intent capture and translation into executable plans.
- Speed from idea to output; fewer handoffs across tools.
- Personalization: the same agent adapts to your language, examples, and constraints.
- Access: “on‑demand skill” makes advanced workflows reachable without months of tool training.
Obsolesces
- Heavy onboarding for routine tasks; long manuals for procedural work.
- Rigid UI paths as the primary route to capability; endless menu archeology.
- The creator's unilateral control over workflow sequence; users can recompose steps dynamically.
Retrieves
- The apprentice model: explain what you want, watch, correct, refine.
- Conversational command lines: terse, expressive instruction with immediate feedback.
- Recipe thinking: outcomes expressed as constraints, ingredients, and checks rather than UI clicks.
Reverses (when pushed to extremes)
- From clarity to confusion: ambiguous intent, hidden contexts, and silent failures.
- From empowerment to dependency: de‑skilling if we stop understanding the work we delegate.
- From flexibility to sprawl: untracked automations, inconsistent results, and compliance gaps.
- From transparency to opacity: model bias and training data constraints replace visible UI limits.
The tetrad says the promise is real, and so are the counterweights. The agent extends us, but also refracts us through a different set of constraints.
4) Designing for intent, not just interfaces
If intent is the new interface, design must move up a layer, from screens to cognition. Practical principles follow:
Intent-first architecture Start from user outcomes. Define them as contracts: inputs, constraints, success criteria, and verification steps. Build UIs that gather those elements cleanly.
Constrained delegation Grant agents scoped permissions and narrow tools. Keep boundaries clear: where they can act, what data they can touch, what they must ask before doing.
Verifiability by default Show plans before execution. Expose intermediate artifacts: diffs, citations, data sources, and test runs. Make it easy to review and roll back.
Provenance and audit trails Log prompts, contexts, actions, and outputs. Make the chain of reasoning and data lineage inspectable for users and auditors.
Teachability and memory Let users provide exemplars, style guides, and domain rules. Store them as reusable instructions. Treat these as first-class assets, not buried settings.
Skill unbundling Model workflows as composable skills with clear inputs/outputs. Agents can compose them across products, reducing the need for full-stack monoliths.
Dual-mode interactions Natural language for exploration; structured forms for precision. Offer knobs, sliders, and schema when ambiguity would be costly.
Resilience to constraints Assume thin bandwidth and variable latency. Support offline drafts, resumable plans, and tight feedback loops that require minimal heavy assets.
This is cognitive design: shaping how people express, refine, and check intent. The “application” becomes a thinking partner with execution legs.
5) Path forward: outcomes over clicks, with guardrails
A practical migration path keeps the risks in view and the wins tangible:
Map outcomes, not features List the top jobs your users hire you for. Rewrite each as an intent contract with inputs, constraints, and verification.
Inventory workflows as skills Break complex flows into named skills with clear boundaries. Decide which skills the agent can run autonomously and where it must seek confirmation.
Build the grounding library Capture exemplars, policies, domain glossaries, and style rules. Version them. Agents improve when the substrate is explicit.
Shift training from tool to instruction patterns Teach users how to express intent: provide templates, checklists, and examples. Replace hour-long product tours with short instruction patterns and review habits.
Put humans in the loop where it counts Review steps for safety, compliance, or high cost of error. Default to confirmation gates there. Automate the rote; supervise the consequential.
Measure time‑to‑verified‑outcome Move beyond “active users” and “time in app.” Track how quickly users reach correct outputs with evidence, and how often rework is needed.
Treat uncertainty as a first-class citizen Surface confidence, show alternatives, and make it simple to compare drafts. Ambiguity exists; make it discussable.
Keep skills portable Avoid hardwiring capability to one model or vendor. Define skills and contracts so they can run wherever quality, cost, and policy fit best.
Field note: the old world trained us to work like the tool. The new world asks the tool to work like us. We trade visible constraints (menus, wizards) for invisible ones (model behavior, data coverage). The payoff is speed and flexibility, if we own the intent, the checks, and the memory of how we got there.
Predesigned systems still matter, especially where reliability is non‑negotiable. But their role shifts from prescribing the path to providing safe, composable skills and rock‑solid verification. LLMs as cognitive extensions make capability fluid. Our job is to make that fluidity trustworthy, auditable, and aligned with human judgment. We move from brittle workflows to responsive, real‑time reasoning with digital output, without losing accountability for the outcomes we create.
To translate this into action, here's a prompt you can run with an AI assistant or in your own journal.
Try this…
List your top 3 work outcomes. Rewrite each as: input needed, constraints that matter, and how you would verify success. Notice where current tools force unnecessary steps.
