Predicting the AI Interface 30 Years Ago: I Was 71% Right

Summary: In 1993 and 1996, I predicted that user interfaces would abandon commands: computers would infer and execute user intent instead of obeying point-and-click orders. Modern AI delivered that paradigm, 30 years later. Scoring the papers’ 23 specific predictions against 2026 reality produces a decent grade: 71% correct. The biggest hit: language as the primary interface. The biggest miss: I predicted expert users, and AI instead became the great equalizer.

Let’s see how my predictions from 1993 and 1996 turned out. (Muse Image)

Tech punditry has a strange asymmetry: predictions get published loudly and graded never. I want to correct that, starting with myself. In 1993, my paper Noncommand User Interfaces (Communications of the ACM 36, 4, 83–99) argued that future computers would stop obeying explicit commands and start inferring user intent. In 1996, Don Gentner and I followed with The Anti-Mac Interface (CACM 39, 8, 70–82), which systematically reversed every principle in Apple’s Macintosh Human Interface Guidelines to derive a future built on language, rich object representations, and shared control.

30 years later, conversational AI has changed the dominant interaction paradigm from command-based to intent-based, the shift I analyzed in AI Is First New UI Paradigm in 60 Years. And the second AI wave, agentic AI, is now delivering the delegation half of the old vision: systems that don’t just answer but act. So the obvious question: how much did those two old papers get right? My answer is to grade the homework, prediction by prediction, on a 0–100% scale.

Most pundits publish predictions and never revisit them to see what happened. I’ll grade the homework on two of my main predictions from the 1990s. (Muse Image)

A sad note before grading begins: my co-author and close friend, Don Gentner, passed away. A careful thinker (and my colleague at Sun Microsystems on many projects), Don would have haggled over these scores and likely won half the arguments. The 1996 vision was ours together; the re-analysis and any grading errors are mine alone.

Two Papers, One Future

The two papers attack the same future from different layers. Noncommand (1993) predicted the interaction mechanics: 12 dimensions along which future interfaces would abandon the explicit command loop, covering everything from syntax to turn-taking to who controls the interface. Anti-Mac (1996) predicted the interface substance: what replaces metaphors, direct manipulation, and WYSIWYG once the command loop goes away. Its answer, condensed into 5 principles, was the central role of language, a richer internal representation of objects, a more expressive interface, expert users, and shared control.

4 of those 5 principles read today like the specification sheet for a large language model product. The fifth is wrong, and wrong in an instructive way. More on that below.

Both papers acknowledged that the vision exceeded contemporary capabilities. Anti-Mac put it most plainly: any realistic reader, we wrote in 1996, would see that the interface was “mostly impractical with the current state of computers and software.” True then. The interesting question is why it remained impractical for another quarter-century and what finally changed. (Spoiler: not what we expected.)

Scoring Rules: No Partial Credit for Good Intentions

Rather than cherry-picking flattering predictions, I graded the papers’ own tables: the 12-dimension comparison table from Noncommand, the 10 Mac-versus-Anti-Mac reversals from Anti-Mac’s Table 1, and the user-population prediction from its Table 2. That makes 23 scored predictions in total, each rated on this scale:

Two clarifications. First, timing gets no separate penalty because the delay affects nearly every row. Neither paper promised a full system within a decade; Noncommand explicitly said such a system was unlikely “within the next ten years, which is about as far as one can predict in the computer field with a minimum of credibility.” The vision nonetheless took 30 years to become a widely shipped product pattern, a delay I return to in the lessons.

Second, I’m grading my own homework, which is an obvious conflict of interest. I’ve tried to score against what shipped and stuck, not against what demos well, and I show every score so you can regrade me.

Scorecard 1: Noncommand User Interfaces (1993) = 71%

The 1993 paper’s core claim was that the defining property of next-generation interfaces would be “the abandonment of the principle underlying all earlier interaction paradigms: that a dialogue has to be controlled by specific and precise commands issued by the user.” Instead, the computer would observe users and infer their intent. My examples were what 1993 could offer: eye-tracking games, music-accompaniment systems, agents that sort email, and a talking car navigator. Quaint exhibits, correct thesis.

Add it up: 855 points across 12 dimensions, for an average of 71%.

Four rows deserve commentary.

The perfect score. The computer’s-role dimension predicted a shift from “obeying orders literally” to “interpreting user actions and doing what it deems appropriate.” That closely describes the defining move of generative AI. Most prompts leave important details unstated, and much of an LLM’s value lies in filling those gaps plausibly and usefully. The 1993 paper even cited the Japanese saying that captures the design goal: “know 100% by hearing 10%.” A prompt is the 10%. (The failure mode, hallucination, is simply what happens when “what it deems appropriate” and reality diverge. The paper saw the responsibility shift coming, too: with noncommand interfaces, “the computer takes on much of the responsibility to react correctly.” In 2026, that sentence describes a legal department’s nightmare.)

A 31-year echo. In 1993, I described moving an on-screen object “by selecting it by looking at it and then pressing a selection button (to prevent accidental selection).” In February 2024, Apple shipped Vision Pro with the same core selection pattern: look at a target, then pinch to commit. The prediction reappeared three decades later with its confirmation step intact. Of course, the Vision Pro remains a niche product, which is why the bandwidth and interaction-stream rows score in the middle of the scale: the high-bandwidth immersive future arrived, but as a sideshow. The main stage went to the lowest-bandwidth input device imaginable: an empty text field.

The physical channel narrowed while the semantic channel widened. Our mistake was measuring the interface by how much raw data crossed it rather than by how much work each user token could trigger. The better metric for AI is intent leverage: useful output divided by the effort required to specify the goal.

First, look to select. Then perform a gesture to confirm that you want to act. This 1993-predicted interaction technique became foundational in the Apple Vision Pro UI. (Muse Image)

The turn-taking embarrassment. I predicted that dialogues would abandon turn-taking, with user and computer both acting continuously. Then the flagship interface of the AI era arrived as a chat window: the most rigidly turn-based design since the teletype. You type; you wait; it answers. But the noncommand version is winning at the edges. Inline autocomplete drafts text while you type. Coding agents grind away for 20 minutes while you do something else, which is turn-taking measured in coffee breaks rather than keystrokes. Several full-duplex voice modes also allow interruption and overlap, although turn-taking still dominates ordinary use. Score: a humbling 60%.

I thought that turn-taking dialogues were too constraining for operating computers, but they’re still with us. (Muse Image)

Right itch, wrong scratch. The user-programming row shows a pattern that repeats throughout this audit. I predicted end-user programming through demonstration and graphical rewrite rules, illustrating the idea with my Bellcore colleague George Furnas’s BITPICT, a language where you programmed by showing pixel patterns before and after a change.

My first BITPICT program, from the 1993 paper: graphical rewrite rules that animate a steam train, one pixel pattern at a time. End-user programming arrived 30 years later, but as English prompts rather than pixel rules. (Figure from the original article.)

End-user programming did explode, in the form Andrej Karpathy dubbed vibe coding in 2025: describe the program in plain language, run what the AI writes, and iterate. Few-shot prompting echoes programming by example, but it isn’t the graphical programming-by-demonstration we predicted. That mechanism remained niche. Half credit.

My humble choo-choo was the harbinger of great things to come, even if it took 32 years for vibe coding to become big. (Muse Image)

One more exhibit. The 1993 paper included a table of computer generations, predicting that generation 5, starting in 1996, would bring noncommand interfaces to “everybody.” Here’s that table, extended with what actually happened:

Generation 5 arrived right on schedule, and it was the web plus the touchscreen: 27 more years of pointing at things, which is to say, of commands. Clicking a link is a command. Tapping an icon is a command. I named the right next paradigm and missed an entire intervening one. Too bad.

The interface-locus row deserves a final nod, because one throwaway 1993 sentence quietly described the cloud: users “will feel that all computational devices are access points to ‘their’ computer, no matter where it is physically located.” That’s your phone, your laptop, and your account in 2026. And the paper’s star example, the MIT Back Seat Driver prototype that told drivers “you just missed your turn” and replanned the route, now lives in every car and pocket on Earth. The environment-embedded computer arrived; it just arrived as a device we carry rather than 1,000 devices in the walls.

The cloud delivered my vision: phone, laptop, watch, car, earbuds, and smart speaker are all access points through that infamous cloud. I don’t like the “cloud” metaphor, but that ship has sailed, so I’m using it here. (GPT Image 2)

Scorecard 2: The Anti-Mac Interface (1996) = 71%

Don Gentner and I wrote Anti-Mac while working together at Sun Microsystems, my erstwhile employer. The paper was a thought experiment in the physicists’ tradition: violate every axiom and see what universe results. Apple had published an explicit list of Macintosh interface design principles, so we reversed each one. We were careful to say then, and I’ll repeat now, that we were devoted fans of the graphical user interface; the exercise was exploration, not hostility toward Apple. The surprise was that the reversals didn’t produce chaos. They produced a coherent alternative design: an interface built on language, richer objects, expressiveness, expertise, and shared control.

The Anti-Macintosh was only a thought exercise, and we never built even a prototype. With its focus on language, this is how our prototype might have looked in 1996. (Muse Image)

The math: 780 points across 11 predictions, again averaging 71%. Two papers, written 3 years apart and graded row by row, land at exactly the same score (when rounded; otherwise 0.34% apart). Either the underlying vision was unusually coherent, or I’m a suspiciously consistent grader. (Probably some of both. It also means the horse race I hoped for ended in a dead heat: neither paper aged better, because they shared both their best bets and their blind spots.)

Language: the direct hit. The see-and-point reversal scores 95% because in 2026, the describe-and-command box is the interface. We wrote: “Language lets us refer to objects that are not immediately visible. For example, we could say something like ‘Notify me if there is a new message from Emily.’” That sentence is no longer a vision; it’s a Tuesday. And the mechanism we sketched, a negotiation modeled on a reference librarian who “talks with the user for a while to negotiate the actual query,” is a working description of a chat thread with clarifying questions.

Describing things has become core to the current AI user experience, even though I now think it should be combined with a revival of pointing as a supplement to verbal description, to lower the articulation barrier. (Muse Image)

But precision requires quoting our hedge, too: “It seems a computer that can hold a normal conversation with the user will remain in the realm of science fiction for some time yet.” We asked instead for “a pidgin language for computers,” something like a text adventure’s parser with spelling correction. We were right for 26 years and then, suddenly, wrong: the AI-complete problem we carefully routed around got solved, and natural-language interaction became practical. It’s the best kind of failed hedge.

We assumed users already knew what they wanted and just needed a better way to say it. Conversational AI revealed that human intent is rarely a pre-formed cognitive object just waiting to be translated; rather, intent is fluid and often discovers itself through the act of conversation. Current AI user interfaces do little to help users figure out their intent, but even primitive AI UX already supports some degree of iterative co-articulation.

One sentence from 1996 aged better than everything else Don and I wrote: “Real expressive power comes from the combination of language, examples, and pointing.” That’s a working definition of multimodal prompting: type your intent, paste an example of what you want, and point by uploading an image or selecting a region. If I could grade a single sentence at 100%, this is the one.

Language is best for leaping across a large solution space: “make this calmer,” “compare these contracts,” or “plan a week in Kyoto.” Pointing is best for local correction: this paragraph, that number, the face in the upper-right corner. Examples communicate qualities users can’t easily name. The winning AI interface will therefore let language propose, examples constrain, and pointing repair.

The multimodal interaction we predicted, combining language, examples, and pointing, is still a great idea and is gaining ground in AI user interfaces. (Muse Image)

Sun Microsystems went the Java route in its products, not the Anti-Mac route, so this advertisement never happened. I made it up retroactively in 2026, using Muse Image.

Delegation: from assembly line to executive suite. Our complaint about direct manipulation was that “instead of an executive who gives high-level instructions, the user is reduced to an assembly line worker who must carry out the same task over and over.” Agentic AI is the executive interface we asked for: state the goal, delegate the steps, review the result. In 2026, this pattern runs code refactoring, research reports, and browser errands. The shared-control row scores 90% for the same reason, though we underestimated one nuance: before a user hands an agent real autonomy, he or she needs calibrated trust, and current AI systems are still learning to earn it.

If Sun had productized the Anti-Mac, this is how a later version could have looked. (GPT Image 2)

Agentic AI also revives a less celebrated 1993 prediction: the disappearance of applications as the user’s organizing principle. The old paper argued that people should work on tasks while the system quietly activated whatever functionality was needed. An agent that researches in a browser, calculates in a spreadsheet, drafts in a document, and sends the result by email finally crosses the application barrier. The user specifies one goal; the agent assembles a temporary workflow from many tools. If this pattern matures, the app will become an implementation and business detail rather than the main UX architecture.

Richer internal representation: right idea, alien implementation. We asked for documents to carry rich attributes such as author, topic, importance, and relationships to other docs. Instead, embeddings mapped documents, images, and sentences into high-dimensional spaces where semantic relatedness can be estimated as distance. This representation is richer and more flexible than the attribute scheme we imagined, and it can operate without a single universal metadata standard.

Our 1996 argument in one photo: every book on a shelf looks different, yet all are instantly recognizable as books, while computer files of the same type all looked identical. Embeddings finally gave computers an internal version of the same trick. (One more fake ad for the product that never was, made in 2026 with Muse Image.)

Metaphors, and a word about Magic Cap. Our cautionary example of metaphor maximalism was General Magic’s Magic Cap interface, where your email sat inside a drawing of a desk, and shopping required walking your cursor downtown.

Magic Cap (General Magic, 1994) committed totally to the metaphor: a desk for your messages, a hallway to other rooms, and a downtown for shopping. Navigating a drawing of a building is slower than not navigating at all. (Screenshots from our original 1996 article.)

This is not the actual Magic Cap UI (that’s the small monochrome screenshot above) because the device didn’t have color, sufficient resolution, or enough computing power to make its metaphor real. But this image represents the mental model the device tried to impose, which made it cumbersome to navigate. Lots of virtual walking around. (Muse Image)

The critique held up. Skeuomorphism peaked and died (Apple itself flattened iOS in 2013, even though that was a step in the wrong direction, not our direction), and the winning AI interface needs no desk, trash can, or village.

Fairness requires the other half of the General Magic story: the company saw the smartphone more than a decade early, and its alumni went on to build the iPod and iPhone (Tony Fadell), Android (Andy Rubin), and eBay (Pierre Omidyar). The 2018 film General Magic (documentary, 1 hr 32 min) tells the story well. They didn’t fail at vision. They failed at timing, which happens to be this article’s theme.

WYSIWYG died of success. We argued that ‘What You See Is What You Get’ was really ‘What You See Is All There Is,’ discarding meaning for appearance. Today, content is stored semantically (HTML, Markdown) and rendered dynamically per device or reader; the fixed printed page is no longer canonical. This vindicated our 1996 accessibility argument: semantic markup and AI descriptions serve blind users far better than screen readers “reading aloud from the pixels” without understanding what they’re saying the way an AI voice does.

WYSIWYG (what you see is what you get) was king of usability in the days of printing. Today, content is mostly consumed on screens and rarely printed, so the AI’s ability to act on content’s meaning is more important than one true layout to rule them all. (GPT Image 2)

Feedback, scaled by trust. We compared the ideal system to an employee: “A supervisor interacts very intensely with a new employee,” but as trust grows, “no news is good news.” That paragraph is now the central design debate of agentic AI: how much should an agent narrate? Today’s agents err on the chatty side, streaming reasoning and progress reports, because they’re new employees who haven’t earned quiet delegation yet. The forgiveness reversal made the same deeper point: instead of blanket warnings, “the computer needs to build a deeper model of our intentions and history.” Context windows and memory features are that model, 30 years on.

The consistency irony. We predicted diversity would beat consistency. The content layer proved us right: no two people see the same feed, the same recommendations, or, increasingly, the same generated answer. The chrome layer proved us wrong: design systems homogenized the web, and every AI product converged on an identical empty text box. We predicted the death of uniformity and got the most uniform interface in computing history. 50%, and I’m being kind to us. Our expressive-icons argument fared better at the content level, with rich thumbnails now everywhere.

Thumbnails are common in modern user interfaces, partly fulfilling our prediction that rich representations would beat non-specific representations. (GPT Image 2)

The Biggest Miss: We Bet on Experts, AI Bet on Everyone

Anti-Mac’s expert-users principle was our confident bet on the future user population. We argued that “it would not be unreasonable to expect a person to spend several years learning to communicate with computers, just as we now expect children to spend 20 years mastering their native language,” and we predicted a “Post-Nintendo Generation” that would demand expressive interfaces and happily pay a steep learning curve to get them.

Reality inverted the bet. The interface that won requires no learning curve, because everybody already speaks it. And the measured benefits flow disproportionately to novices. Erik Brynjolfsson (Stanford) with Danielle Li and Lindsey Raymond (MIT) studied 5,172 customer-support agents given an AI assistant: productivity rose 15% on average, but the gains concentrated among the newest and least-skilled agents (roughly 30%), while the most experienced workers gained little. Agents with 2 months of tenure plus AI performed like unassisted colleagues with more than 6 months of experience. I reviewed 3 similar field studies back in 2023: the same pattern every time, with productivity gains reaching a whopping 66% and skill gaps narrowing. AI is a forklift for the mind, and forklifts help the weakest lifters most.

AI is a forklift for the mind. (GPT Image 2)

Partial credit exists. Prompt outcomes still vary with a user’s ability to articulate intent, the problem I later named the articulation barrier: about half of all adults in rich countries have low literacy and struggle to specify what they want in prose. And the deep end of agentic tooling rewards expertise the way Unix once did. But the direction of our prediction was backward. We forecast an interface for jungle natives; AI shipped an interface for tourists. 25%.

We expected advanced user interfaces to require extensive training before the user could be trusted to use them, but it turned out that almost all designs target the UI equivalent of tourists: step off the plane and get going. (GPT Image 2)

There’s a lesson in who got vindicated. The Mac was built for “the rest of us.” We proposed the opposite and lost the bet: in the 40 years since the Mac shipped, every interface generation that won, won by lowering the skill floor, and intent-based AI lowered it further than any predecessor.

The Schema Fallacy: What Neither Paper Saw

Both papers were honest about their bottleneck, and both named the same wrong one. Noncommand blamed “the lack of sufficiently high-level data interchange and system integration standards.” Anti-Mac said the full system needed object attributes “sufficiently standardized to be shared among multiple functionality modules.” In other words, we believed intelligence at the interface required structure underneath: schemas, tags, standardized attributes, and hand-built agents that consumed them.

This was a schema fallacy: the assumption that computers can only act intelligently on information that humans have first structured for them. It was the consensus belief of the era, and it later powered the Semantic Web, another right-destination, wrong-vehicle project. The actual solution inverted the premise: train a model on oceans of messy, unstructured text, and let it extract meaning from anything. No schema. No standards committee. Meaning became a learned property of the system instead of an engineered property of the data. Neither of our papers contains the phrase “machine learning,” and that absence explains most of our 30-year timing error: we specified the destination before the vehicle had been invented.

We thought that advanced user interfaces would require highly structured and labeled data. Instead, AI has proven capable of learning from a mess of unstructured data. This is lucky, because humans have never been good at structuring and labeling their content. (GPT Image 2)

(An amusing footnote: the standards instinct wasn’t entirely wrong, just premature and aimed at the wrong layer. Once learned intelligence existed, the industry immediately built a plug-and-play standard around it: the Model Context Protocol, released by Anthropic in late 2024 and adopted across the industry within a year, lets AI systems snap in tools and data sources as interchangeable modules. My 1993 software-packaging prediction earned its 50% through this back door.)

Three more blind spots deserve confession. First, trust. We wrote in 1996 that “most users know better than to trust computer-based agents with a free rein on their systems,” and we framed the distrust as a temporary condition of primitive agents. In 2026, with capable agents that occasionally hallucinate, calibrating that trust is the central design problem, not a transitional annoyance.

Second, nondeterminism. We cheerfully attacked the Mac principle of perceived stability, arguing that a changing environment beats a frozen one. Today’s users discover that the same prompt yields a different answer on each run, a form of instability beyond anything we contemplated, and one that active work on reproducibility is trying to tame.

Third, economics. Our Anti-Mac summary table promised that “information comes to you.” It does, and it arrived a decade before useful AI, as the engagement-optimized social feed: shared control with algorithms whose goals aren’t the user’s. We asked for a butler and got, for 15 years, a carnival barker.

We wanted the computer to be our butler. Instead, we got a 15-year interregnum of all-flashing, attention-grabbing social media banging the drums. (GPT Image 2)

The Mac Principles Strike Back

Here’s the twist I enjoy most. The moment the Anti-Mac interface finally shipped, the Mac principles we reversed began returning, one by one, as the requirements list for agentic AI:

• Forgiveness. Undo for a file operation was table stakes in 1984. For agents that send emails, book travel, and modify production systems, reversibility is an unsolved safety problem, and every serious agent product is scrambling to add checkpoints, dry runs, and confirmations before irreversible actions.

• Feedback and dialog. We said trusted delegates need less feedback. True, but trust must be earned first, so 2026’s agents stream their reasoning and narrate their progress: more feedback than any GUI ever provided.

• User control. Reborn as “human in the loop,” the approval step before an agent acts on your behalf.

• Consistency. Users now demand behavioral consistency from AI: the same request should produce reliably similar quality, a harder promise than identical menu layouts ever were.

Paradigm shifts, it turns out, demote the old principles from defaults to safeguards rather than deleting them. Designers building agentic products should reread the 1984-era Macintosh Human Interface Guidelines not as history, but as a requirements backlog.

Many of the principles from the old Macintosh Human Interface Guidelines turn out to be prescriptions for better AI usability as well. (Muse Image)

6 Lessons for the Next 30 Years of Predictions

The point of grading old predictions is calibrating new ones. Here are 6 lessons from this audit, for anyone (including me) making AI-interface forecasts today:

1. Principles outlive technology bets. Our language and delegation predictions (90–95%) were claims about human needs; the VR and eye-tracking bets (50–60%) were claims about hardware. Judge today’s forecasts the same way: “people will delegate more work to computers” ages well, while “smart glasses win by 2028” is a coin flip.

2. Expect vision lag. I’ll define vision lag as the gap between a working research demonstration and paradigm dominance, and historically it runs 20–30 years. The mouse was demoed in 1968 and became ubiquitous in the mid-1990s. Conversational interfaces were prototyped throughout the 1980s and became real in 2023. Noncommand was named in 1993 and shipped in 2023. So when you see today’s laboratory demos of brain-computer interfaces, pencil them in for 2050, and be pleasantly surprised if they’re early.

3. Expect the mechanism switcheroo. A forecast’s destination can be exactly right while every assumed enabler is wrong; that’s the schema fallacy in action. The corollary cuts both ways: don’t dismiss a prediction because its mechanism failed, and don’t trust one because its mechanism demos well.

4. Bet against “experts only.” Every winning interface generation lowered the skill floor: GUI beat command line, touch beat mouse, prompts beat programming. If a prediction requires users to invest years of learning before the payoff, price it at 25%.

5. Treat violated principles as future requirements. When your new paradigm breaks an old rule (undo, feedback, user control), you haven’t escaped the rule; you’ve created a safety backlog. Write the list on day one and staff it.

6. Grade in public. One audited prediction is worth 10 fresh ones, because the audit is what calibrates the next batch. If you published a technology roadmap more than 5 years ago, dig it out and score it. It stings less than you’d expect, and your readers will trust the next roadmap more.

Conclusion: 71% Is a Strong Grade for Prophecy

Cassandra’s curse was to be right and disbelieved. Don Gentner and I suffered a milder version: we were right, politely cited for three decades, and the industry went off and built 30 more years of point-and-click anyway. Then the vehicle we never imagined, machine learning at scale, drove everyone to the destination we had mapped in detail.

In school, 71% is a C-minus. For predictions held for 30 years against a moving target, I’ll take it, especially because the misses taught more than the hits: bet on falling skill floors, budget for vision lag, and check every confident forecast for the schema fallacy, including the AI forecasts flooding your feed right now, and including this article’s own lessons.

Now it’s your turn to wield the red pen: which of my 23 scores are too generous, and which too stingy? Post your regrades in the comments. You be the judge.

On an exam, 71% is a low score. For a 30-year prediction, I think we did pretty well, even though we expected it to come true sooner than it did. (Muse Image)

My 71% grade is provisional. I scored the papers against the first widely adopted version of intent-based computing, and that version looks suspiciously primitive: one empty box, a turn-taking transcript, and models that repeatedly ask users to restate context the AI should already know. The future arrived wearing a command line’s striped pajamas.

The next 10 years may raise some scores. Persistent memory could strengthen the prediction that computers learn from interaction. Ambient agents could weaken chat’s rigid turn-taking. Multimodal systems may finally make language, examples, and pointing a single fluent act. Conversely, every autonomous mistake will strengthen the revived case for feedback, forgiveness, and user control.

This is the final irony of UX predictions: a prediction can come true before its best interface exists. Generative AI made my vision feasible without fully delivering the usability I expected. We now have the intelligence needed for the Noncommand and Anti-Mac visions, but we are still designing the controls that will make inferred intent dependable.