
A few weeks ago, I was talking to Claude on my phone, trying to update a page and upload an image on a test site open on my laptop. On my first try, I opened the image right in my conversation with Claude.
Technically, it worked. Practically though, sending the picture across character-encoded it into text and immediately blew out our shared context.
So Claude suggested pulling up a card instead, a small upload form from my site brought right into the conversation. My voice directed what I wanted changed, Claude's voice responded, and the card handled the file without derailing us, and next to it all my laptop showed the updated page.
Nothing about my goal changed, yet the exchange adapted mid-task instead of forcing speech, a file, and my review through a single interface.
Designing software so one exchange can adapt across whatever combination of channels and interfaces the work needs is what I mean by responsive interaction design.
Answering in the moment, and answering for what happened
Both responsive and responsible come from the Latin respondēre, to answer or promise in return. Responsive (fifteenth century) means answering in the moment. Responsible (seventeenth century) means answering for what was done.
Software now has to do both, and this is a hard problem. So, before wiring more chat widgets, forms, and tools together, it would serve us well to untangle the words we use to describe it.
Are your eyes an interface?
Look at what was going on in my image upload goal from a minute ago. Halfway through, I realized four or five "interfaces" were sitting inside that one update:
- My voice conversation and the phone screen in Claude.
- Claude calling my website over Model Context Protocol (MCP).
- An embedded HTML upload form (a card) sent into the chat by my site so I could attach the image.
- WebMCP inside that card, exposing structured form actions to help an agent work with it.
- The live page open on my laptop.
That's a lot happening for what felt like a "simple" task.
And even now I say it's "four or five interfaces" because we speak about what's on the screen, what's communicated, and where it all ends up and everything else in between under a few overloaded words.
One exercise I like to do is step out of technology and watch how people behave.
Picture yourself standing in a kitchen talking through a dinner plan with your family: where is "the interface" in that room?
Is it your eyes? Is it their faces, one interface per person? Say those options out loud and you hear right away that flattening human exchange into "interfaces" misses the mark on reality.
A responsive person takes in your words alongside your tone, what you're pointing at, and whether you keep checking the clock.
Your expressions are in the conversation as well.
Someone can say "sure" while nodding enthusiastically, or say the same while scrolling on their phone and walking away. It's the same word said, but nowhere near the same meaning.
So what are your eyes here, if not an interface? Calling them an "input device" misses half their job too, because our eyes sense and express at once.
Sight is incoming perception, yet your eyes are physical apparatus working in both directions simultaneously. They take in the surroundings and faces, all while a squint can show skepticism, or a glance at a clock can signal hurry, and looking across the counter at someone else hands them the next turn.
Are your eyes a modality or a channel, then? Neither. Sight, speech, hearing, gesture, touch, and written text are modalities, the modes we use to perceive and express meaning, in line with the W3C's Multimodal Interaction Requirements glossary.
Those modalities travel together or in quick turns over active channels, the live signal paths open during the exchange. Air carries an audio stream of words, tone, and quiet "mm-hmms," the shared visual field carries a recipe on the counter, pointing hands, and raised eyebrows at once, and a buzzing pocket phone opens a tactile channel. We don't consciously run a "voice app" and "face app" in our heads to stitch them together.
Notice what still hasn't appeared between the people in that kitchen: an interface. There is no engineered boundary hanging in the air halfway between my face and yours.
NIST defines an interface as a common boundary where independent systems or modules interact. Once software enters the room, engineers construct those boundaries explicitly, both where people meet software (a phone screen, an HTML card, a web page) and where software meets software (MCP or an API).
Cross those boundaries and two more words need separating: user and client. A user is any actor pursuing a goal through the system, person or agent (agents are users, not features). A client is software in the connection role of requesting a service, with or without a goal: my browser fetching a page and the Claude app connecting to my site's MCP server are clients, whereas Claude and I are the users pursuing the goal.
And then one last trio, fittingly rooted in a kitchen: activity, task, and interaction. In "Human-Centered Design Considered Harmful" (2005), Don Norman quoted Christine Frederick's 1919 observation from The Labor-Saving Kitchen that "work in the kitchen does not consist of independent, separate acts, but of a series of inter-related processes," defining an activity as a coordinated, integrated set of tasks.
Renovating a room or going on a hike is an activity, while hanging one frame, checking trail conditions, or updating an event page is a bounded task with a clear finish line inside it. Real activities rarely sit in neat boxes, either: that hike might also be a date, layered inside a week-long vacation, with people shifting across overlapping activities and tasks at the same time. They form an ecosystem rather than a clean sequential chain.
You operate a traditional tool like a hammer or a static form to do a task yourself: a framing hammer and a rubber mallet send different feedback into your hand and ears, yet neither adapts to the wall because you chose which one to pick up. Operating a tool like that doesn't turn it into a "collaborating teammate."
That is also the fundamental difference between a traditional tool and an AI agent. A traditional tool doesn't work toward a goal or adapt to the situation on its own, whereas an agent does both, which is why you operate a tool and delegate to an agent.
Activity and task describe the scope of the work, while the interaction is the stateful two-way exchange across channels and interfaces that moves it forward. A scheduled script can finish a task with zero interaction, one continuous interaction can knock out several tasks in a row, and a single task can span five interfaces at once.
Put those pieces next to each other as a working vocabulary and the muddle clears up:
- Apparatus: the organs or hardware that sense and send signals, such as eyes, vocal cords, hands, microphones, phones, and laptops.
- Modality: the mode of perceiving or expressing meaning, such as speech, sight, pointing, touch, or written text.
- Channel: an active path carrying signals during an exchange, like a room's audio stream, a live voice call, a chat thread, or a rendered page preview.
- Interface: a defined boundary where independent participants or software components meet, from a web page or embedded card to WebMCP or an MCP server.
- Users and clients: a user is an actor pursuing a goal (person or agent), while a client is software requesting a service across an interface.
- Activity, task, and interaction: activities are coordinated, often overlapping sets of tasks, a task is a bounded job you operate a tool to finish or delegate to another user, and the interaction is the stateful two-way exchange moving that work forward.
Now recount my phone task with these labels. Two users (me and Claude) worked together on one task, while browser and app clients connected to my site, using our apparatus (vocal cords, eyes, phone, laptop) across speech and visual modalities over live audio and screen channels. Inside that one interaction, we crossed five distinct interfaces: three human-facing (phone screen, upload card, laptop page) and two machine-facing (my site's MCP server and WebMCP).
Even that single task sat inside an ecosystem of overlapping activities, not a neat sequential chain. Updating the page was part of building a demo, sharing advances in content management systems with a developer community, and preparing a walkthrough for others to present on stage, each pulling in different people, interfaces, and exchanges.
Confusing the interface with the product
Spend a few minutes in a product meeting today and you'll hear teams design the 2026 version of mobile.site.com, defining how the product behaves inside each interface separately:
- Our website will function like this.
- Our API will function like this.
- Our MCP server will function like this.
- Our ChatGPT app will connect via MCP like this.
The mistake isn't building an MCP server or a ChatGPT app. The mistake is tying business logic directly into each interface, which defines the interaction up front and forces users, human or agent, to adapt to it.
That coupling locks you in two ways. First, users have to bend their work to whatever rigid steps or formats a single interface accepts. Second, because the tool and the interface are coupled together, like workflow logic buried in a web form, you can't switch "hammers" on the fly when the task shifts without dropping what you're doing and starting over elsewhere.
Decoupling the tool and its logic from the interface is what makes interactions fluid.
Sixteen years ago, Ethan Marcotte watched companies ask for "an iPhone website" exiled to its own mobile subdomain.
In his May 2010 essay Responsive Web Design, he asked what would come next: "An iPad website? An N90 website? Can we really continue to commit to supporting each new user agent with its own bespoke experience?"
In 2010, teams were commingling the viewport with the product. Today, we're doing the same with the interface and the product.
Teams make an even worse version of that mistake when they apply it to users themselves and over-prescribe how an agent or a person has to work. You see it whenever someone wraps an agent in a rigid if-then tree, scripts its personality, and expects every task to march through one pre-written sequence.
Fixed scripts are fine when the steps never change, and you can hand an agent a task list, just as you do with a person, without scripting every move in advance. Enforce what must be true in the product, and leave users, human or agent, room to adapt how they get the work done.
How "responsive" shrank to a screen
Say "responsive design" in a room full of web developers and someone will visualize images stacking as you change your browser size. Our problem though is that by shortening "responsive web design" to "responsive design," we trained an entire industry to treat the "web" as if it owned the word "responsive."
It doesn't. Responsive design predates things like CSS breakpoints by decades, starting with architecture's question long before chat windows: what happens when physical spaces answer us back?
In his 1967 essay on "soft architecture", Warren Brodey objected to environments that forced people to narrow their behavior to what machinery accepted, arguing for spaces that evolve with their inhabitants. Three years later, Nicholas Negroponte opened The Architecture Machine with a dedication that feels extremely relevant today:
"To the first machine that can appreciate the gesture."
And I've always wondered here: does appreciate mean "recognize" or "feel grateful," and does gesture mean a "physical action" or a "symbolic action"? My hope is it was intended as all of the above.
By 1977, Myron Krueger was building responsive environments where visual and audio responses shaped what people did next. Two years later, Negroponte's Architecture Machine Group at MIT demonstrated "Put-That-There," published in Richard Bolt's 1980 SIGGRAPH paper, where someone could point at a wall screen, say "Put that there" or "Make that smaller," and have speech and gesture understood together.
In 2009, Michael Fox and Miles Kemp's Interactive Architecture described physical spaces that reconfigure around their inhabitants. People change the space, and the changed space shapes what happens next.
Marcotte borrowed directly from "responsive architecture" and Fox and Kemp's "continual and constructive information exchange" to treat devices as "facets of the same experience." His recipe combined fluid grids, flexible images, and media queries to decouple the page from any fixed viewport so it adjusted on the fly.
Building five websites for five devices felt ridiculous as soon as you said it out loud.
Three siblings under responsive design
Marcotte named "input modes" like T9 keypads, game controllers, and touch up front, and noted near the end that responsive design "isn't limited to layout changes" such as larger touch targets and responsive typesetting. Still, his toolkit was HTML and CSS, and as we shortened the phrase, many of us, myself included, lost track of the underlying point. Dropping his middle word flattened "responsive" to viewports, so saying "responsive design" about a website really means responsive web design, no different from responsive architectural design.
Once you put that middle word back in, the pattern is straightforward. Each phrase places responsive in front of an established discipline: architecture, web design, and interaction design, the field Bill Moggridge and Bill Verplank named in the mid-1980s after Moggridge floated "Soft-face" and a friend warned him it sounded like a Cabbage Patch Doll. Responsive interaction design names the practice, and responsive interactions are what you get when it works.
Treat responsive design as the parent principle, with three siblings sharing a family resemblance underneath it rather than bolting extensions onto 2010 CSS:
- Responsive architectural design: physical spaces that answer the people inhabiting them.
- Responsive web design: layouts that answer viewing conditions.
- Responsive interaction design: exchanges that adapt reciprocally across activities, tasks, tools, and participants.
We don't need to go grappling for a new word.
Take "responsive user design." Even the grammar trips you up: are we trying to design a responsive user, or just shortening "user interface" back down to screens? Worse, everyday speech hears "user" as a solitary human, so a label like architecture's common "user-responsive" or profile-driven accessibility work such as Yang and Mei's 2014 Responsive Universal Design sounds like one-way accommodation instead of a reciprocal exchange across people, interfaces, and agents.
Aaron Gustafson's 2011 book used "adaptive" well for progressive enhancement, before later web parlance tangled the word into snapped fixed-width layouts, personalized UIs, and accessibility. "Universal interface" narrows things to one interface when an exchange spans several and goes beyond interfaces anyway, and "multimodal" sounds like a grant proposal.
Putting "AI" or "agentic" in front ages fast and misses the practical payoff: making direct operation and agent delegation composable across web UIs, APIs, cards, CLIs, and voice helps every workflow, even when no agent is involved.
There's another practical point to this: you cannot confidently know who your user is. Is it a human, an agent, a human using an agent, or an agent using a human? In reality, you probably won't know with any level of certainty.
For many of us, even "responsive web design" didn't click from the words alone in A List Apart or Smashing Magazine until we saw a browser resize and the images stack.
How "interaction" outgrew one screen
Merriam-Webster defines interaction as “mutual or reciprocal action or influence” and dates its first known use to 1832. Opening his 1990 CHI plenary with that dictionary line, Terry Winograd noted that humans clearly act on computers and computers influence humans, then asked the harder builder's question: "But how? In what dimensions?"
Fourteen years later, Michel Beaudouin-Lafon answered with a blunt paper title, "Designing Interaction, Not Interfaces", urging designers and engineers to design the quality of the exchange rather than treating the widget tree on one screen as the end goal.
Norman diagnosed part of that trap in 2005 (and in a follow-up clarification), arguing that screen-by-screen design ignores connected sequences and interruptions, while warning that blindly building whatever users ask for produces "incoherent designs." Turning raw user wish-lists straight into features is a bad spec, and Norman himself added, "listen to customers, but don't always do what they say." Even so, pitching a "design dictator" goes too far when you still have to ask, listen, and understand what people are trying to accomplish.
Where I part ways with Norman is his perspective that the idea that "tools adapt to the people" is "nonsense" and that people simply adapt to the tool. In a violin, a clock, or a hammer, the tool and its physical interface are one indivisible object, so human muscle has to do all the bending. Once software decouples capabilities from any single interface, the work becomes a reciprocal adaptation back and forth: people learn the domain and its rules while the exchange adjusts how it listens and answers mid-task and mid-activity across every boundary involved, which is why we're designing the interaction, not a specific interface.
Long before chat windows, Hutchins, Hollan, and Norman (1985) contrasted two ways of working with a computer: a conversation metaphor, where you type sequential commands about an unseen world, and a model-world metaphor, where you act directly on visible objects on screen. Command entry and direct manipulation have long coexisted in some products. Combining them fluidly across separate applications, devices, and multiple users has remained much harder. Even worse, metaphors are lossy stand-ins: when every interface wraps the work in its own metaphor, each one quietly alters the underlying properties and effects of what you think is the same thing.
We're on the precipice of not having to fold software work into competing interface metaphors. In physical life, channels shape how we sense and act, yet there is still one underlying reality of what exists and what happens next. Decoupled software can finally work the same way: I can speak a change to an agent while directly editing the live preview on screen, with each channel and interface shaping my angle on one shared reality instead of forcing the whole job into a command-line "conversation" or a single visual workspace.
Then generative AI showed up, and early prompt boxes barely looked interactive at all. In "AI: First New UI Paradigm in 60 Years" (2023), Jakob Nielsen called AI prompting intent-based outcome specification and wrote: "I doubt we should even describe this user experience as an 'interaction' because there is no turn-taking or gradual progress."
Typing a wish into a text box and hoping for the best isn't much of a back-and-forth.
Nielsen was right about one-shot prompt boxes, even as he expected hybrid UIs next, and elicitation closes part of that gap once agents touch real workflows. Eric Horvitz argued in his 1999 mixed-initiative principles that when clarification is worth the interruption, uncertain systems should engage in dialogue rather than guessing blindly. Model Context Protocol built that move into software plumbing with MCP elicitation: mid-task, a server can pause to ask the person for missing input through a supporting client, getting back accept, decline, or cancel.
Extensions like MCP Apps bring the sibling move for richer UI, letting a server hand an embedded interactive HTML card into a compatible host. That's what rescued my opening image upload: instead of pushing a character-encoded file through chat or starting over on my laptop, the interaction composed an upload card I could operate directly right inside the task I had delegated to Claude.
Multimodal research filled in another piece of this years ago. Sharon Oviatt's Ten Myths of Multimodal Interaction (1999) showed that speak-and-point was only one slice of how people actually work, and that we combine modes or use a single mode whenever it fits the task or the room better. The words themselves have even surfaced in different contexts, from Material Design's responsive interaction feedback to Jana Pejoska's 2025 contextually responsive interaction design dissertation.
Yet when Kasper Hornbæk and Antti Oulasvirta surveyed the field in "What Is Interaction?" at CHI 2017, most HCI concepts still treated human intentions as fixed inputs inside a single user-computer loop, overlooking how goals shift mid-exchange and leaving "no good models for multi-party interaction (e.g., among multiple users and computer agents)."
What changed in the last few years isn't just theory. Agents sauntered out of the lab and started changing production software alongside people.
Responsive interaction design defines a fluid interaction layer where users and systems adapt reciprocally across channels and interfaces as one or more coherent exchanges.
To do that, though, you need a common truth: an application underneath supplying shared operations, live state, and consistently enforced rules, all independent of any single interface.
And at any sort of scale, you can't have the first half without the second.
Updating an event page
Putting on or attending an event is an activity made up of a bunch of tasks, one of which might be building a site to highlight the event, with making a change to a page within that site as one of the tasks.
Suppose I sit down to update the event page to add the registration date: that's one specific, bounded task.
With the page editor open on my laptop and an agent connected to the workspace, one interaction can move that work forward.
I say to my agent, "Update the introduction to mention registration closes Friday." The agent updates the draft, responds "Updated the intro," and shows me a preview of what it looks like. I get the confirmation said to me, but not the page, which wouldn't help me understand what the change "looks like."
Next, I click the hero image and try to make it smaller. Let's say in this current application, I do not have the ability to resize the image from the UI, so I send a screenshot to Claude and say, "Can we make this smaller so it doesn't take up as much vertical space?"
Claude takes a look, and maybe I have the ability to modify the CSS on the site, so it makes the change for me, or maybe it helps me draft a note to our site administrator asking for the functionality.
Then, spotting a phrase that reads like AI slop in the headline, I click in and rewrite four words myself.
Finally, I ask Claude to verify any changes it was making are done, view the draft page, and attempt to publish it, but our system requires legal review, so the application sets the draft to "waiting for approval." I tell my agent we're in a hurry and to publish it anyway, but since the agent is only delegated my permissions, it can't jump the approval queue any more than I can directly.
I then tell my agent to keep an eye on it and notify me once legal has approved and it is published.
What makes responsive interaction design work
This all really starts to matter when someone brings an outside agent like Claude instead of staying inside your built-in UI. None of the interaction will hold up if the way it works is defined by something like a form that only some of the pathways use.
Just as Marcotte relied on fluid grids, flexible images, and media queries, three design requirements emerge underneath these interfaces: shared operations, shared live state, and application-enforced rules.
1. Shared operations
Shared operations are your fluid grid. Just as a fluid grid lets one page rearrange across screen sizes, shared operations keep a website, a chat card, and an MCP server from drifting apart the way desktop IE6 and an iPhone subdomain used to.
Or take your kitchen oven controls. Say you set a smart oven to 350 on the built-in panel to bake a cake, and a few minutes later you ask Siri to turn on the broiler. For the sake of your cake, the system needs to know one oven is being operated and catch the conflict between your asks.
If a task is the job a person or agent sets out to finish, operations are the concrete actions your product knows how to run: update a draft, resize an image, ask for approval, publish a page. Each one states what it needs, checks preconditions, pauses when details are missing, and returns an honest outcome that tells a saved change apart from no change or a blocked action. Different ecosystems call these MCP tools, capabilities, abilities, or intents, though the job underneath is the same.
You don't have to route every existing HTML form through a brand-new endpoint to get there, so long as web forms, upload cards, CLIs, and MCP tools share the same underlying business logic, validation, and access checks.
2. Shared live state
In responsive web design, flexible media lets images and video adapt to whatever container holds them, scaling or serving the right size for the screen without breaking the layout. Shared live state does the same job for work in progress: one underlying draft or record shown in whatever way fits each channel and interface, whether a highlighted change on your laptop, a quick spoken confirmation on your phone, or a status badge on a card.
So back to our smart oven: imagine setting it to bake on the built-in controls, then switching it to broil by voice while the display still shows it baking at 350.
Participants need current persisted state, version checks so an older turn doesn't overwrite newer edits, and shared approval status across sessions so you can pause on a laptop and finish from your phone tomorrow. Connecting live unsaved edits and pointer focus across separate apps, like clicking an image in an editor and telling an outside agent "make that smaller," takes deeper workspace state and event communication.
3. Application-enforced rules and real delegation
Where CSS media queries check screen width before rearranging a layout, application-enforced rules check who is acting and what state the work is in before allowing a change. Permissions, validation, workflow steps, and approval gates have to hold inside the application whichever interface a request arrives through.
On our smart oven, that's the child lock. You set the lock and the setting is respected and enforced consistently whether someone presses the stove panel, taps an app, or asks Siri to turn on the broiler.
Interface code, prompt text, and client responses cannot hold those rules alone, no more than any client-side code can. Putting a publish button in the UI doesn't stop an MCP call, system prompts are advice you hope is followed, and the server still has to recheck state and permissions even after a client returns accept on a prompt. As I wrote in Vibes on Rails, block invalid transitions in the system instead of asking actors nicely to behave.
Here respondēre pays off its second meaning, being responsible. Nobody thinks of it as "The oven cooked on behalf of Scott" because a traditional oven doesn't pursue the broader goal on its own, whereas delegating to an agent puts a second actor in motion.
Because an interface alone can't tell you who is driving, access follows the authenticated user and credential scope, like signing in with OAuth to let a connection draft a page without permission to publish it, and audit logs record what those credentials actually verify. Where separate client or agent credentials establish a distinct identity alongside the authorizing person, enforce both limits and log both: "Agent X executed this action on behalf of Person Y."
A publishing platform doesn't have to work toward its own goals like an agent does, but it does have to tell a saved draft from a published page, so that teams can move fast across the interfaces and agents without causing chaos for their organization.
The new "Resize the browser" test
In 2010, responsive web design clicked for me once I dragged a browser corner up and as I resized the page, the stuff on it moved around. Sometimes it helps to step back into the physical world to see the interaction equivalent just as clearly, even knowing that rewiring physical controls inside a wall is hard while software gives us the liberty to decouple interfaces from what runs underneath.
Go back to our kitchen from earlier, where your activity is hosting friends for dinner and one small task inside it is turning on the kitchen light. Start with two ordinary three-way switches by the hallway and the back door: each switch is an interface you flip by touch while your eyes check the room across the shared visual channel, and that quick exchange is the interaction.
Flip one switch up below to turn the light on, then flip the other to turn it off while the first stays pointing up. Even with zero software in the wall, a single switch's position isn't live state, which is why you look at the light in the kitchen rather than trusting one plastic toggle.
Now screw a smart bulb into that same fixture and add Siri, handy when you come through the back door with your hands full. Instead of hands and touch, you switch apparatus and modalities to your voice, a microphone, and speech over the room's audio channel, then watch what happens below when someone flips a wall switch off. Both controls look like "turn the light on or off," yet they run different operations underneath, so "off" means two different things and Siri tells you the light isn't responding.
Finally, suppose you want a rule so nobody turns the kitchen light off mid-dinner, and you enforce it by putting a password on Siri (demo password: light). Without the password Siri refuses to turn the light off, yet anyone can still flip the hallway or back-door switch and plunge the room into the dark, and even with Siri unlocked it can't turn on a bulb whose wall switch cut the power. Locking Siri alone works no better than gating a publish button in one UI while leaving another pathway wide open.
Fixing that kitchen light in a real house means replacing switches or rewiring the circuit so the bulb stays powered and every control talks to one shared controller. Depending on your perspective, software is either easier or much harder to change than drywall and a switch. But with software, the types of responsive changes we’re discussing are much more practical to build.
That gives you the equivalent test for any software product, much like resizing a page: switch how you interact mid-task, and see whether it is the same thing adapted to the new reality, or a different thing altogether.
If you're a developer, you'll know whether all the auth, data, and logic are the same. And if you're a user, well, you really shouldn't have to worry about it, and if it is apparent to you that it is different, well, that's the problem.
You'll still ship web UIs, APIs, MCP servers, ChatGPT apps, embedded cards, CLIs, and voice modes. The shift is pulling workflow logic, live state, and rules out of individual interfaces so they hold together underneath, especially when software can change live data at machine speed.
Answering in the moment makes software responsive. Enforcing the rules and accounting for who acted and under what authority makes it responsible.
References
- Ethan Marcotte, "Responsive Web Design", A List Apart, May 25, 2010; Kayla Knight, "Responsive Web Design: What It Is and How To Use It", Smashing Magazine, Jan. 12, 2011 (updated version credited to Vitaly Friedman, Aug. 11, 2018).
- Merriam-Webster, "Responsive", "Responsible", and "Interaction".
- NIST Computer Security Resource Center (CSRC), "Interface".
- W3C, Multimodal Interaction Requirements, W3C Note, Jan. 8, 2003, and Multimodal Interaction Framework, W3C Note, May 6, 2003.
- Warren M. Brodey, "The Design of Intelligent Environments: Soft Architecture", Landscape 17(1), Autumn 1967.
- Nicholas Negroponte, The Architecture Machine, MIT Press, 1970.
- Myron W. Krueger, "Responsive Environments", AFIPS '77, 1977 (ACM DOI).
- Richard A. Bolt, "'Put-That-There': Voice and Gesture at the Graphics Interface", SIGGRAPH '80, July 1980 (ACM DOI).
- Michael Fox and Miles Kemp, Interactive Architecture, Princeton Architectural Press, 2009.
- Bill Moggridge, Designing Interactions, MIT Press, 2007.
- Hao-Wen Yang and Hsing Mei, "Responsive Universal Design with Universal User Profiles and CSS User Queries", Proceedings of BMSD 2014, 2014; Aaron Gustafson, Adaptive Web Design: Crafting Rich Experiences with Progressive Enhancement, Easy Readers, 2011.
- Terry Winograd, "What Can We Teach About Human-Computer Interaction?", Proceedings of CHI '90, April 1990; Michel Beaudouin-Lafon, "Designing Interaction, Not Interfaces", Proceedings of AVI '04, May 2004 (PDF).
- Edwin L. Hutchins, James D. Hollan, and Donald A. Norman, "Direct Manipulation Interfaces", Human-Computer Interaction 1(4), 1985; Christine Frederick, "The Labor-Saving Kitchen", in Household Engineering: Scientific Management in the Home, 1919; Donald A. Norman, "Human-Centered Design Considered Harmful", Interactions 12(4), July/Aug. 2005 (ACM DOI), and "HCD harmful? A Clarification", Sept. 2005.
- Jakob Nielsen, "AI: First New UI Paradigm in 60 Years", Nielsen Norman Group, June 18, 2023.
- Eric Horvitz, "Principles of Mixed-Initiative User Interfaces", Proceedings of CHI '99, May 1999 (ACM DOI); Model Context Protocol (MCP), "Elicitation", Specification, 2026 (June 2025 Spec); Model Context Protocol (MCP), "MCP Apps", Extension Overview, 2026; Web Machine Learning Community Group (W3C), "WebMCP", Draft Community Group Report, Nov. 2026.
- Sharon Oviatt, "Ten Myths of Multimodal Interaction", Communications of the ACM 42(11), Nov. 1999; Google, "Responsive Interaction", Material Design guidelines, 2014 (archived copy); Jana Pejoska, Contextually responsive interaction design: Design ideation for dynamic contexts, Aalto University, 2025.
- Kasper Hornbæk and Antti Oulasvirta, "What Is Interaction?", Proceedings of CHI '17, May 2017 (ACM DOI).
- Scott Falconer, "Agent Experience is more important than User Experience" and "Vibes on Rails", 2026.
Keep reading