A massive divergence exists between accelerating AI technical progress, aggressive product launches, and the anemic rate of commercially durable, successful deployments. (2:06)
Generative AI excels at rough-edged problems where 80% accuracy provides immediate acceleration, but struggles on sharp-edged tasks where anything short of 100% correctness represents total failure. (6:40)
An MIT meta-analysis reveals that human-plus-AI teams frequently perform worse than solo humans on sharp decision-making tasks, contradicting common assumptions about automatic AI productivity gains. (38:10)
Wrapper applications that rely solely on superior UX face severe platform risk and the threat of getting 'Sherlocked' as foundation model providers natively integrate downstream tooling. (55:21)
Detailed notes
## Background
Published on YouTube by Stanford Online on September 30, 2026, in collaboration with Global Alumni, this webinar features Stanford Computer Science Professor Michael Bernstein. According to the video description, the session explores the practical realities of artificial intelligence adoption, presenting frameworks to help leaders distinguish between problems AI can solve reliably and those that demand enduring human judgment and oversight.
## TL;DR
Professor Michael Bernstein addresses the widening gap between rapid AI technical advances and anemic enterprise product success, attributing failures to the misalignment between rough-edged problems (which tolerate variance and partial accuracy) and sharp-edged problems (which demand exact, binary correctness). He illustrates how multi-step agentic workflows compound sharp-edged brittleness, leading users through a psychological cycle from uncritical overreliance to complete algorithmic aversion when failures inevitably occur. To achieve sustainable adoption, Bernstein advocates for Intelligence Augmentation (IA) over wholesale human replacement, urging teams to design subtle, peripheral interfaces and actively reframe brittle sharp-edged tasks into rough-edged decision-support tools.
## Atmosphere & style
The presentation carries the engaging, polished energy of an executive masterclass, blending rigorous academic research with accessible, conversational clarity. Professor Bernstein delivers an intellectually refreshing talk seasoned with wry humor and memorable analogies—comparing flawed AI prompts to the distracting marginalia of a 'bozo's' used textbook or the panic of a sudden steering wheel handoff in a self-driving simulator. The dynamic between the structured Global Alumni host and Bernstein's animated, authoritative delivery makes the webinar feel practical, grounded, and deeply clarifying amidst prevailing AI industry hype.
## Bulletin
- [02:06](https://www.youtube.com/watch?v=y4xvZnl102w&t=126s) A massive divergence exists between accelerating AI technical progress, aggressive product launches, and the anemic rate of commercially durable, successful deployments.
- [06:40](https://www.youtube.com/watch?v=y4xvZnl102w&t=400s) Generative AI excels at rough-edged problems where 80% accuracy provides immediate acceleration, but struggles on sharp-edged tasks where anything short of 100% correctness represents total failure.
- [38:10](https://www.youtube.com/watch?v=y4xvZnl102w&t=2290s) An MIT meta-analysis reveals that human-plus-AI teams frequently perform worse than solo humans on sharp decision-making tasks, contradicting common assumptions about automatic AI productivity gains.
- [55:21](https://www.youtube.com/watch?v=y4xvZnl102w&t=3321s) Wrapper applications that rely solely on superior UX face severe platform risk and the threat of getting 'Sherlocked' as foundation model providers natively integrate downstream tooling.
## Key takeaways
- [02:06](https://www.youtube.com/watch?v=y4xvZnl102w&t=126s) AI progress and commercial product launches follow steep growth trajectories, but sustained enterprise product successes remain rare due to structural misalignments between models and problem domains.
- [06:40](https://www.youtube.com/watch?v=y4xvZnl102w&t=400s) Rough-edged tasks have expansive solution spaces where multiple outputs are valid, allowing early AI drafts to deliver immediate value that humans can readily refine.
- [06:40](https://www.youtube.com/watch?v=y4xvZnl102w&t=400s) Sharp-edged problems feature strict binary definitions of correctness where near-misses remain catastrophic, precluding AI adoption until systems cross exceptionally high reliability thresholds.
- [11:45](https://www.youtube.com/watch?v=y4xvZnl102w&t=705s) Coding agents succeed on sharp-edged challenges primarily when integrated with automated verification loops such as compilers and linters that supply immediate feedback.
- [13:18](https://www.youtube.com/watch?v=y4xvZnl102w&t=798s) Adoption curves differ fundamentally by problem type: rough-edged tasks experience continuous, linear adoption gains, whereas sharp-edged tasks require crossing a strict step-function threshold.
- [18:09](https://www.youtube.com/watch?v=y4xvZnl102w&t=1089s) Multi-step agent pipelines compound sharp-edged risks, as any single hallucination or calculation error invalidates the entire operational workflow.
- [23:03](https://www.youtube.com/watch?v=y4xvZnl102w&t=1383s) AI task capabilities expand inward across concentric circles, moving from completely unsolved, to rough-edged human-in-the-loop assistance, to reliable sharp-edged automation.
- [26:32](https://www.youtube.com/watch?v=y4xvZnl102w&t=1592s) Organizations can deploy value immediately by reframing untenable sharp-edged binary predictions into rough-edged structured diagnostic reports and decision-support drafts.
- [29:02](https://www.youtube.com/watch?v=y4xvZnl102w&t=1742s) Human-machine systems frequently collapse at 'the seam,' the friction point where an AI abruptly passes operational control back to an unprepared human lacking situational context.
- [32:21](https://www.youtube.com/watch?v=y4xvZnl102w&t=1941s) Focusing on Intelligence Augmentation (IA) avoids the severe worker resistance, foot-dragging, and metric gaming triggered by explicit labor-replacement initiatives.
- [35:03](https://www.youtube.com/watch?v=y4xvZnl102w&t=2103s) Clinical and professional AI adoption often improves when interfaces are made 'unremarkable' and peripheral, thereby respecting professional autonomy rather than commanding center stage.
- [36:11](https://www.youtube.com/watch?v=y4xvZnl102w&t=2171s) Complementarity is not guaranteed; consulting studies and developer trials demonstrate that uncritical reliance on AI can reduce overall task performance by over 20%.
- [40:00](https://www.youtube.com/watch?v=y4xvZnl102w&t=2400s) Users rapidly oscillate between overreliance driven by confident model prose and algorithm aversion once a brittle system commits a catastrophic, unverified error.
- [50:37](https://www.youtube.com/watch?v=y4xvZnl102w&t=3037s) Evaluating AI success solely through cost-cutting and task-replacement metrics incentivizes narrow operational optimizations instead of breakthrough organizational capabilities.
## Detailed walkthrough
### [00:10](https://www.youtube.com/watch?v=y4xvZnl102w&t=10s) Welcome and Introduction of Professor Michael Bernstein
The session opens with an introduction from the host on behalf of Stanford Online and Global Alumni for the live presentation titled *What AI Can and Cannot Do: Intelligence Augmentation in Practice*. The audience is notified that the session is recorded and encouraged to keep cameras on while remaining muted to maintain audio quality. Questions are directed to the Q&A box at the bottom of the interface.
The host introduces the featured speaker, Professor Michael Bernstein. Bernstein is a Professor of Computer Science at Stanford University, where he serves as a Bass University Fellow and Senior Fellow at the Stanford Institute for Human-Centered Artificial Intelligence (HAI). He is a nationally bestselling author whose generative AI simulation research stands as the most highly cited in the history of the ACM Symposium on User Interface Software and Technology (UIST). His work focuses on interactive, social, and societal technologies and has been featured in outlets including *The New York Times*, *MIT Technology Review*, and *TED AI*. Recognized with the Alfred P. Sloan Fellowship and the Computer History Museum's Tech for Humanity Prize, Bernstein earned his bachelor's degree in Symbolic Systems from Stanford, followed by a master's degree and a PhD in Computer Science from MIT. His talk centers on practical frameworks for evaluating AI opportunities, deciding what to build, and generating durable organizational value.
[02:06](https://www.youtube.com/watch?v=y4xvZnl102w&t=126s) The Three Curves: Progress, Launches, and Real Success
Bernstein takes over and explains that the material draws from an online course he teaches, highlighting how strongly these ideas have resonated with corporate boards, CTOs, CEOs, and senior leadership grappling with AI strategy. To frame the core challenge, he asks the audience to consider the current landscape across three parallel trajectories over time:
1. **AI Progress:** A steeply accelerating curve where technical breakthroughs happen at breakneck speed. As Bernstein jokes, "there feels like there's a new model every week. In fact, there was a new model last week. It might be gone today, back tomorrow."
2. **Product Launches:** An equally steep, hyper-aggressive curve tracking the massive wave of AI-powered applications, tools, and services entering the market as organizations race to solve internal and customer problems.
3. **Successful Products:** In stark contrast to the first two, this third curve is markedly "anemic."
While industry observers often attribute the high failure rate to a healthy "Cambrian explosion of ideas" where failure is expected by design, Bernstein argues that structural patterns divide the few genuine successes from the vast majority of misfires, abandoned projects, and expensive corporate embarrassments.
```mermaid
flowchart LR
accTitle: Divergence of AI Progress versus Product Success
accDescr: Three curves contrasting rapid AI technological capability and product launches against lagging real-world product successes.
subgraph Momentum["Market Hype & Technology"]
A["AI Capabilities & Models"] -->|"Rapid acceleration"| B["AI Products Launched"]
end
subgraph Reality["Actual Impact"]
B -.->|"Divergence / Failure gap"| C["Sustained Successful Deployments (Anemic)"]
end
```
[05:06](https://www.youtube.com/watch?v=y4xvZnl102w&t=306s) Feasibility vs. Worth: The Need for a Durable Framework
To unpack why so many initiatives fail, Bernstein divides the strategic inquiry into two foundational questions: deciding what is *feasible*, and deciding what is *worthwhile* to build.
Addressing feasibility is complicated by the fact that AI capabilities evolve far faster than traditional enterprise execution cycles. In typical corporate workflows, making a strategic pivot takes months: leaders must devise a plan, manage organizational change, execute the technical build, prepare go-to-market strategies, and onboard customers. By the time an organization finally launches, the underlying frontier AI models have evolved, rendering the newly deployed product obsolete on arrival.
Bernstein stresses that trying to predict specific technical specs six months in advance is futile because point-in-time predictions age immediately. Leaders need a durable strategic framework independent of shifting technical roadmaps to evaluate what AI can reliably handle.
[06:40](https://www.youtube.com/watch?v=y4xvZnl102w&t=400s) Rough-Edged vs. Sharp-Edged Problems
Bernstein introduces a core distinction that governs AI deployment feasibility: the difference between **rough-edged** and **sharp-edged** problems. His primary thesis is that generative AI struggles significantly more when deployed against sharp-edged problems than rough-edged ones. This disparity is not caused by the model being inherently weaker at one domain over another; rather, it stems from the structural demands of the task and how human workflows absorb errors.
- **Rough-edged problems** encompass tasks where numerous distinct outputs can all be considered correct. For these tasks, getting 80% of the way to a solution provides immediate value. Bernstein points to writing marketing copy, summarizing a lecture, generating an illustration, playing *Super Mario*, or creating synthetic video (such as prompting a model to depict a cowboy riding a horse through the American West). Because countless variations are valid, an AI output that places the user "in the neighborhood" acts as an effective accelerant that a human can easily refine.
- **Sharp-edged problems** feature exactly one correct answer. An output that is 80% correct is functionally 100% wrong. Bernstein references the idiom that "almost only counts with horseshoes and hand grenades," noting that horseshoes and hand grenades are rough-edged, while nearly everything else in high-stakes decision-making is sharp-edged. Examples include clinical predictions (such as whether a patient will be readmitted to the hospital within 30 days) or expecting an automated software system to deploy code with zero bugs on the first pass.
| Problem Type | Definition | Acceptable Solutions | Tolerance for ~80% Accuracy | Representative Examples |
|:--- |:--- |:--- |:--- |:--- |
| **Rough-Edged** | Broad solution space | Many equally valid answers | High; serves as a valuable accelerant | Drafting marketing copy, lecture summaries, image/video generation |
| **Sharp-Edged** | Strict binary/exact solution space | Exactly one correct outcome | Zero; near-misses remain catastrophic failures | Hospital readmission prediction, automated bug fixing sent directly to production |
[10:09](https://www.youtube.com/watch?v=y4xvZnl102w&t=609s) Agentic AI and the Problem Spectrum
Bernstein applies this framework to the rise of **agentic AI**. He defines an agent as an AI system equipped with a tool library that can independently decide which actions to invoke, observe the environment's feedback, and iterate sequentially. Tools available to an agent might include reading files, executing code, searching the web, sending emails, processing orders, or manipulating applications.
Rather than executing a single prompt, an agent enters an autonomous feedback loop:
```mermaid
flowchart TD
accTitle: Agentic AI Action Loop
accDescr: The cycle of an agent evaluating goals, selecting tools, running commands, and inspecting feedback.
Goal["Task Goal"] --> AgentBrain["AI Decision: Select Next Action"]
subgraph ToolLibrary["Available Tools"]
T1["Read / Write Code"]
T2["Search Web"]
T3["Send Email"]
T4["Execute System Command"]
end
AgentBrain --> ToolLibrary
ToolLibrary --> EnvResult["Observe Output / System State"]
EnvResult --> AgentBrain
```
Bernstein observes that agents inherently compound both sharp and rough edges depending on how they are tasked. A distinctly sharp-edged deployment of an agentic coding tool is instructing it to: *"Fix this bug and ship it straight to production."* In that environment, the agent either patches the flaw perfectly or risks introducing secondary defects that crash production servers.
[11:45](https://www.youtube.com/watch?v=y4xvZnl102w&t=705s) Coding Agents, Interface Design, and Rough vs. Sharp Edges
When considering automated coding agents, their utility often hinges on whether the task has many valid solutions or just one brittle definition of correctness. An agent might be instructed to investigate a bug by adding diagnostic logging, forming a hypothesis about root causes, and opening a speculative pull request. These activities represent tasks where "there are lots of different ways to get it right"—they are not strictly binary pass-or-fail situations. Interestingly, developers can successfully wrap sharp-edged problems inside coding agents, provided the outcome is automatically verifiable. As long as the agent receives clear feedback when it fails, it can iteratively navigate a sharp-edged challenge. Conversely, if an agent is tasked with vague goals—such as generally improving "quality of life" or creating interface layouts—it lacks an automated signal to iterate against.
This dynamic becomes obvious in user interface design. Design is inherently a rough-edged problem: any given functional specification can yield dozens of plausible, aesthetically sound user interfaces. However, people frequently treat design as a rigid, sharp-edged task. A stakeholder might demand, "Make me a sign-up modal and add a way to store user accounts, and it's got to be right," expecting a perfect final product back from a single prompt. That expectation defies how design actually works; one does not approach an architect, say "I want a house with three bathrooms, go," and expect finished blueprints without ongoing conversation. Yet users repeatedly expect AI to execute open-ended interface design in a single zero-shot leap, declaring the AI broken when the subjective output fails to match an unstated preference.
[13:18](https://www.youtube.com/watch?v=y4xvZnl102w&t=798s) Error Tolerance and the Adoption Threshold
AI models do not struggle with sharp-edged problems because the underlying machine learning architectures differ between domains—the identical foundation model powers both rough and sharp tasks. Instead, the failure mode stems from human tolerance for error. In rough-edged problems, human tolerance is wide; in sharp-edged problems, it is exceptionally thin.
```mermaid
flowchart LR
accTitle: Practical Adoption Curves for Rough vs Sharp Problems
accDescr: Diagram contrasting how AI accuracy translates to adoption for rough-edged versus sharp-edged tasks.
subgraph Rough["Rough-Edged Problem"]
direction TB
R_Low["Low/Moderate Accuracy"] -->|"Usable draft"| R_Mid["Iterative Refinement"]
R_Mid -->|"Gradual increase"| R_Adopt["High Practical Adoption"]
end
When evaluating a graph of AI performance (x-axis: accuracy; y-axis: practical business adoption):
- **Rough-edged tasks** follow a continuous, upward adoption curve. A rough first draft of marketing copy or report text is still immediately useful because human reviewers can edit and improve it. As draft quality rises, usage rises steadily in lockstep.
- **Sharp-edged tasks** exhibit a step-function threshold. If the system falls even slightly below an acceptable reliability mark, it cannot be exposed to customers or built into production workflows. A caller stuck in a phone routing tree that continually misinterprets voice commands becomes frustrated and hangs up. The system is discarded entirely until it crosses a high accuracy threshold where users can rely on it inside an unattended inner loop.
For most sharp-edged business problems, human tolerance thresholds are far higher than early-stage AI systems can satisfy. Spam filtering illustrates this slow maturation: Naive Bayes spam classifiers emerged in the 1990s, yet it required roughly 25 years of algorithmic refinement before users stopped feeling compelled to check their spam folders daily out of fear that an important email from their boss had been mistakenly filtered. A modern parallel is early voice assistant technology (such as Apple's Siri or Amazon's Alexa). When instructed to "play the Beach Boys," the assistant either executes the request accurately or fails completely. Because errors were frequent, users largely abandoned complex voice commands and retreated to basic, low-stakes utilities: "I'm just going to use it to set timers."
[18:09](https://www.youtube.com/watch?v=y4xvZnl102w&t=1089s) The Compounding Risk in Multi-Step Agent Workflows
The vulnerabilities of sharp-edged requirements become acute when autonomous agents execute multi-step workflows. If an agent manages warehouse inventory replenishment, the task decomposes into a brittle chain resembling a high-stakes game of telephone:
```mermaid
flowchart TD
accTitle: Compounding Sharp-Edged Inventory Agent Workflow
accDescr: Sequential pipeline of inventory tasks where any single misfire ruins the macro workflow.
subgraph Pipeline["Warehouse Replenishment Chain"]
A["1. Find Parts at Warehouse"] --> B["2. Decide to Reorder"]
B --> C["3. Pick Reorder Volume"]
C --> D["4. Set Delivery Location"]
end
A -.->|"Lookup wrong part/site"| Fail["Workflow Borked / Waste / Shortage"]
B -.->|"Threshold error"| Fail
C -.->|"Too many / too few"| Fail
D -.->|"Shipped to CA instead of FL"| Fail
```
Because every link in this chain is sharp-edged, any single miscalculation invalidates the entire macro-operation:
- Looking up the wrong part or checking the wrong facility ruins the baseline inventory count.
- Evaluating reorder thresholds incorrectly wastes capital on surplus goods.
- Selecting an incorrect reorder volume causes stockouts or overages.
- Routing shipments to the wrong geographic hub causes active harm—such as sending critical items to California when they were needed in Florida.
This brittleness explains why coding agents handle sharp-edged tasks far better than operational business agents: coding environments provide automated verification (such as unit tests, linters, and compilers) that immediately signal when an individual link in the chain breaks.
Real-world legal hallucinations demonstrate the reputational cost of sharp-edged failures. When lawyers file briefs citing AI-generated court precedents that do not exist, judges issue sanctions and fines. A legal citation is binary: it is either authentic authority supporting the argument or a fictitious fabrication. Research from Arvind Narayanan’s group at Princeton reinforces this systemic hurdle in AI agent reliability, observing in their abstract that "recent capability gains have only yielded small improvements in reliability." Without crossing the strict threshold at every discrete step, the compound reliability of the end-to-end system remains inadequate.
[21:18](https://www.youtube.com/watch?v=y4xvZnl102w&t=1278s) Balancing Sharp and Rough Capabilities in Practice
Organizations succeed by deliberately separating sharp-edged requirements from rough-edged opportunities. Modern customer support startups like Decagon and Sierra navigate this boundary by dividing capabilities according to risk and verification:
| Problem Type | Use Cases / Capabilities | Nature of Output & Margin for Error |
|:--- |:--- |:--- |
| **Sharp-Edged** | "Where's my order?" inquiries, routing tickets to specific departments, arranging returns, known troubleshooting flows | High-fidelity; must be exactly right and directly shippable without manual intervention. |
| **Rough-Edged** | Suggesting reply drafts for human support agents, responding to open-ended inquiries, concierge-style brand interactions | Low-fidelity to medium-fidelity; offers valuable starting points with multiple valid ways to solve the customer's need. |
Even when models are not 100% optimal, deploying them on rough-edged tasks delivers clear value because low-fidelity drafts still accelerate human work. This hybrid dynamic extends to technical workflows such as digital accessibility audits. Research out of Germany shows how AI assists developers by analyzing user interfaces to flag potential violations of accessibility guidelines for blind and low-vision individuals, providing actionable feedback rather than demanding autonomous, zero-defect execution.
[23:03](https://www.youtube.com/watch?v=y4xvZnl102w&t=1383s) The Concentric Circles of AI Evolution: Rough-Edged vs. Sharp-Edged
When looking at the landscape of AI capabilities, the universe of solved sharp-edged problems will always remain strictly smaller than the universe of rough-edged problems. Any problem an AI can solve to 95% or 99% accuracy can inherently be solved to an 80% baseline, but reaching the "five nines" (99.999% accuracy) required to safely automate sharp-edged tasks is vastly harder. Consequently, AI capabilities can be visualized as nested spheres: an outer circle of unsolved problems, an intermediate circle of rough-edged problems that AI can tackle with human-in-the-loop oversight, and a smaller, inner circle of sharp-edged problems where autonomous execution succeeds reliably.
```mermaid
flowchart TD
accTitle: Evolution of AI Tasks Across Capability Tiers
accDescr: A task progresses inwards from completely unsolved to rough-edged solutions, and finally into sharp-edged automation as models improve.
subgraph Progression ["Task Evolution Pipeline"]
A["Unsolved Problem<br>(Outside current AI frontier)"]
B["Rough-Edged Solution<br>(~80% accuracy, human-in-the-loop)"]
C["Sharp-Edged Solution<br>(99.999% accuracy, reliable automation)"]
A -->|"Model capabilities advance"| B
B -->|"Reliability reaches threshold"| C
end
```
Tasks evolve by migrating inward along this gradient rather than teleporting straight into sharp-edged automation. As next-generation frontier models launch, both circles expand simultaneously: brand-new tasks are swept from "unsolved" into the rough-edged perimeter, while tasks hovering right at the boundary of rough-edged utility get pulled into the inner sharp-edged core. Product strategists do not need deep technical machine learning expertise to anticipate what comes next; they simply need to observe where a workflow currently sits. A task that barely fails today will soon become a viable rough-edged assistant, and a rough-edged workflow that is already teasing near-flawless accuracy will likely cross into sharp-edged automation with the next major model release.
- **Accuracy disparity:** Solving a problem to 80% utility is universally achievable long before reaching the 99% or 99.999% precision demanded by mission-critical autonomy.
- **Inward migration:** Tasks never become sharp-edged out of nowhere; if an AI can solve a task sharply, it already possessed the latent capability to solve it in a rough-edged, assistive capacity.
---
[26:32](https://www.youtube.com/watch?v=y4xvZnl102w&t=1592s) The Rough-to-Sharp Playbook and Reframing Problems
Instead of passively waiting for autonomous AI models to materialize, practitioners can actively convert sharp-edged problems into rough-edged counterparts to ship value immediately. Product teams frequently trap themselves by dreaming up all-or-nothing, binary classifiers—such as an automated system deciding whether a patient will face hospital readmission. Because an autonomous medical gatekeeper makes too many costly false decisions to be left unattended, the sharp-edged deployment stalls. However, reframing that system so that it compiles a structured diagnostic report highlighting risk factors for an expert human clinician transforms an untenable sharp-edged failure into a powerful rough-edged tool today.
This tactical playbook starts with evaluating the target use case and determining the exact accuracy threshold required for adoption. If the necessary reliability requires multiple "nines" that current models cannot hit, the immediate move is to redesign the interface around rough-edged workflows—turning autonomous verdicts into editable drafts or decision-support summaries. Conversely, when setting out to address an inherently rough-edged problem, the barrier to entry is virtually zero: teams can spend $20 on consumer frontier models, test immediate iterations, and establish a working baseline right away.
---
[29:02](https://www.youtube.com/watch?v=y4xvZnl102w&t=1742s) "The Seam" and the Failure of Handoffs
Great machine learning models frequently collapse in production because of poor human-centered system design. In collaborative robotics, for instance, the most efficient trajectory for a mechanical arm is rarely the most effective interface for a coworker; robots that deliberately swing their arms and make exaggerated head-and-eye gestures to signal intent foster far smoother, more efficient human-robot partnerships. When systems fail to account for how humans communicate and maintain situational awareness, catastrophic handoffs occur along what researchers call "the seam"—the critical friction point where an AI attempts to pass control back to a person.
This vulnerability is dramatically illustrated in autonomous driving simulator studies. When an autonomous vehicle encounters an edge case, declares an emergency, and abruptly injects control back to the driver, the human has little to no situational context. Drivers routinely swerve wildly, veer into oncoming traffic, nearly crash multiple times within thirty seconds, and panic. The breakdown does not stem purely from a flawed AI or an incompetent human; it occurs entirely at the handoff seam. As Professor Eytan Adar memorably phrases it: "don't let your user interface write a check that your AI can't cash." When marketing promises a sharp-edged, fully autonomous miracle but delivers an engine bolted to the outside of a product without clear problem alignment, users plummet directly into the trough of disillusionment.
---
[32:21](https://www.youtube.com/watch?v=y4xvZnl102w&t=1941s) Intelligence Augmentation (IA) and Overcoming Replacement Resistance
The antidote to autonomous failure and organizational disillusionment is Intelligence Augmentation, abbreviated as IA—which is simply "AI backward." Rather than pursuing the traditional, often shortsighted goal of completely replacing human labor, IA asks how computing can augment our intellect and grant human beings cognitive superpowers. By functioning like a "strap-on cortex," IA enhances human strategy, creativity, wit, and analytical speed. While public media fixates almost exclusively on replacement and job elimination, the operational reality is that the clear majority of enterprise large language model usage operates strictly in an augmentative, human-in-the-loop capacity.
```mermaid
flowchart LR
accTitle: AI Replacement versus Intelligence Augmentation Frameworks
accDescr: Contrasts traditional replacement AI with intelligence augmentation where AI acts as a cognitive booster to a central human worker.
subgraph TraditionalAI ["Traditional AI Paradigm"]
direction TB
T_AI["Artificial Intelligence"] -.->|"Aims to replace"| T_H["Human Professional"]
end
subgraph IntelligenceAugmentation ["Intelligence Augmentation (IA)"]
direction TB
IA_Tool["AI 'Strap-on Cortex'"] -->|"Augments & empowers"| IA_H["Human Professional"]
end
```
Intelligence Augmentation is rooted in pioneering work by Turing Award laureate Douglas Engelbart, who in the 1960s championed augmenting the human intellect to invent foundational technologies like the computer mouse, bitmapped interactive displays, and collaborative word processors. Attempting wholesale replacement often triggers severe behavioral blowback. Research by Stanford sociologist Angèle Christin highlights that when algorithmic data tools are introduced to web journalists or legal practitioners under the guise of automation or replacement, workers actively resist: they drag their feet, intentionally game the algorithm, and openly amplify every minor error the system makes to discredit its adoption.
- **Historical lineage:** Doug Engelbart demonstrated in the 1960s that computing tools should fundamentally elevate human problem-solving capabilities rather than simply automate workers out of the equation.
- **Worker resistance mechanisms:** When tools threaten displacement, knowledge workers fight back through strategic foot-dragging, subverting algorithmic metrics, and seizing on $1 million hallucinations or mistakes to justify complete product abandonment.
[35:03](https://www.youtube.com/watch?v=y4xvZnl102w&t=2103s) Designing for Adoption: Making AI "Unremarkable"
Embedding artificial intelligence into organizations requires a counterintuitive design shift: systems often succeed only when they are made *less* AI-focused. Drawing on a Carnegie Mellon research project studying clinical workflows, Professor Michael Bernstein highlights how researchers struggled to get physicians to use an AI diagnostic assistant. Doctors are "famously protective of their autonomy and expertise—well earned," Bernstein jokes, noting: "They have MDs, I don't. I'm a different kind of doctor."
```mermaid
flowchart LR
accTitle: Designing AI for Doctor Adoption
accDescr: Contrasting an intrusive front-and-center AI design with an unremarkable peripheral UI.
subgraph Failure["Intrusive Interface"]
A["AI Front & Center"] --> B["Threatens Autonomy"]
B --> C["Physician Rejection"]
end
subgraph Success["Unremarkable Interface"]
D["AI Tucked in Corner"] --> E["Subtle Peripheral Info"]
E --> F["Physician Acceptance"]
end
```
To achieve real-world clinical adoption, designers had to make the tool seem, in the researchers' words, "unremarkable." Rather than positioning the system front and center—which felt intrusive and threatened professional autonomy—they moved it into the corner of the display. By appearing as a subtle, floating widget on the periphery, the interface communicated an implicit respect for the physician: "You know what you're talking about. Just by the way, in case you're curious, here's some other information." By making the AI less visible rather than domineering, the system preserved clinician agency while remaining accessible as a supportive resource.
[36:11](https://www.youtube.com/watch?v=y4xvZnl102w&t=2171s) The Complementarity Promise and the Productivity Paradox
The foundational goal of Intelligence Augmentation (IA) is simple: "human plus AI does better than human. If human plus AI didn't do better than human, then why are we even here?" In the academic literature, this synergy is termed *complementarity*, describing tasks where human and machine working together decisively outperform either the human or the AI operating alone. Compelling evidence proves this is achievable:
* **Customer Support:** Research led by Stanford colleague Erik Brynjolfsson revealed augmentative gains in call centers, where generative assistants guide support workers through difficult interactions with challenging customers.
* **Medical Screening:** A massive randomized controlled trial (RCT) highlighted by Eric Topol demonstrated major performance improvements in detecting breast cancer from mammographies by using human-in-the-loop workflows where AI triages and prioritizes scans.
* **Consulting Ideation:** Boston Consulting Group (BCG) recorded significant productivity and quality gains among consultants employing AI for open-ended, creative ideation tasks.
Yet positive complementarity is only half the story. A closer look at the BCG findings reveals a sharp drop-off: on a separate task where consultants took AI recommendations at face value, their overall performance dropped by 23% compared to peers working without any AI assistance. Similarly, an RCT examining software engineers showed developers *felt* they were coding faster with AI tools, yet objective benchmarks revealed they were actually working slower. With widespread reports of corporate generative AI pilots stalling or failing, the augmentative benefit is far from guaranteed.
[38:10](https://www.youtube.com/watch?v=y4xvZnl102w&t=2290s) The MIT Meta-Analysis: Sharp vs. Rough Edges
```mermaid
flowchart TD
accTitle: Task Complementarity Spectrum
accDescr: How task nature impacts human plus AI performance across MIT meta-analysis findings.
subgraph Meta["MIT Meta-Analysis Spectrum"]
L["Red Zone: Negative Complementarity<br/>Human + AI performs WORSE than alone"]
Z["Zero Baseline: No Effect"]
R["Green Zone: Positive Complementarity<br/>Human + AI performs BETTER than alone"]
end
To diagnose why so many deployments falter, MIT researchers conducted a comprehensive meta-analysis across multiple published studies, plotting outcomes along a single spectrum. A zero mark represents neutrality (human plus AI performing identically to either party working alone), the right-hand green zone reflects positive complementarity, and the left-hand red zone denotes negative complementarity—where pairing a human with AI produced results *worse* than either could achieve independently.
Alarmingly, the graph skew heavily into the red: on average, human-plus-AI teams performed worse than individuals working solo. The divergence aligns with the nature of the tasks:
* **The Red Zone (Sharp-Edged Tasks):** The steepest declines clustered around complex decision-making problems with strict ground truths—such as predicting whether a patient will be readmitted to a hospital.
* **The Green Zone (Rough-Edged Tasks):** The most reliable productivity and quality wins emerged from content creation and generative work.
This split mirrors the fundamental boundary between sharp-edged and rough-edged problems. Decision-making scenarios require precise, bounded accuracy where undetected errors carry heavy penalties, whereas generative tasks benefit from broad variance, creative recombination, and low-stakes human curation.
[40:00](https://www.youtube.com/watch?v=y4xvZnl102w&t=2400s) The Psychological Swing: Overreliance to Algorithm Aversion
The underlying mechanism driving performance collapses is human psychology. When users interact with generative tools, they frequently fall victim to *overreliance*—an intoxicating sensation of "I'm flying." Seduced by smooth prose and confident phrasing, users slip into satisficing, cognitive offloading, or what Wharton researchers label "cognitive surrender," completely checking out mentally and trusting the model without verification. Paradoxically, model explanations exacerbate the issue: when an LLM writes an essay explaining its reasoning, its outputs sound persuasive, causing users to overlook severe hallucinations or erroneous citations.
```mermaid
flowchart LR
accTitle: The Trust Cycle in AI Interaction
accDescr: Cycle moving from overreliance to error exposure and swinging into algorithm aversion.
A["Overreliance<br/>('Cognitive Surrender')"] -->|"Unchecked Error / Hallucination"| B["Violation of Expectation"]
B --> C["Algorithm Aversion<br/>(Severe Undertrust)"]
C -->|"Brittle Trust Dynamics"| D["System Abandonment"]
```
Once a catastrophic mistake slips through—such as an attorney submitting a fabricated legal case citation in court—the user's psychological posture rebounds violently toward *algorithm aversion*. Human trust in algorithms is far more brittle than interpersonal trust:
* **Human Error:** If a human colleague drives you to dinner and gets into a minor fender bender with no injuries, you may hesitate briefly, but you will readily ride with them again in the near future.
* **Algorithmic Error:** If an autonomous vehicle experiences that identical minor collision, consumers often refuse to ever purchase or ride in that vehicle brand again.
Because trust in automation breaks so easily, users alternate between extreme credulity and total disengagement, either trusting the AI blindly or abandoning it altogether. Bernstein concludes that while modern generative AI creates unprecedented product possibilities, long-term success requires grounding designs in this psychological reality: systems must solve genuine user problems and survive the litmus test of true intelligence augmentation, or they will inevitably be discarded.
[43:28](https://www.youtube.com/watch?v=y4xvZnl102w&t=2608s) Global Alumni: AI-Powered Product Innovation Overview
Following Bernstein's lecture, the Global Alumni team opens the floor for participant Q&A and introduces the online course developed alongside Professor Bernstein, titled *AI-Powered Product Innovation*. The program is structured as a six-week, fully online offering designed to translate these conceptual frameworks into actionable enterprise strategies, featuring two live sessions led directly by faculty.
The curriculum covers core frameworks to help product leaders separate high-potential opportunities from brittle implementations:
- **Core Frameworks & Opportunity Assessment:** Applying structured heuristics to differentiate viable, augmentative use cases from high-risk, hallucination-prone applications, and forecasting capability shifts over coming years.
- **Human-AI Interaction & Behavioral Dynamics:** Dissecting the psychological drivers behind trust, cognitive surrender, and algorithm aversion to build sustainable product experiences.
- **Ethics, Risk, and User Simulation:** Implementing early-stage guardrails for societal, legal, and safety risks, alongside leveraging generative agent simulations to model user behavior and pressure-test product hypotheses.
- **Hands-On Capstone & AI Tutor:** Developing a practical capstone project applying course principles, supported in real time by an embedded "AI Tutor" to answer content and administrative inquiries throughout the learning journey.
[46:29](https://www.youtube.com/watch?v=y4xvZnl102w&t=2789s) Course Overview and Transition to Live Q&A
The host concludes the presentation on the *AI-Powered Product Innovation* course, outlining the key elements prospective students can expect. The curriculum emphasizes practical application through hands-on, real-world assignments and a culminating capstone project. Learners engage in guided discussion forums with industry peers to build professional networks while working directly with modern large language models to explore intelligence augmentation and generative AI agents. Those who finish the program earn an official Stanford Online Certificate of Achievement. Handing the session back to Michael Bernstein, the host invites him to address the incoming stream of audience questions from the chat and Q&A boxes.
[47:24](https://www.youtube.com/watch?v=y4xvZnl102w&t=2844s) Expertise, AI Overreliance, and the "Used Textbook" Problem
Opening the Q&A, Michael addresses a question from Vanessa regarding whether one must be a domain expert to critically evaluate AI outputs, particularly when dealing with sharp-edged problems where answers are strictly right or wrong. Michael explains that the necessity of expertise depends entirely on the required accuracy threshold. For certain well-defined programming tasks—such as writing straightforward algorithms to pass variables or count objects—modern coding agents have achieved sufficient accuracy that human oversight is no longer strictly necessary. He compares this reliability to background computer science abstractions like compilers that optimize program binaries or automatic garbage collection that prevents memory leaks: users do not inspect them continuously because they clear an established threshold of dependable execution.
However, once a task falls below that sharp threshold, human oversight becomes unavoidable, which immediately exposes users to the peril of cognitive overreliance. Michael compares this psychological trap to reading a used textbook pre-marked by a previous student: even if you recognize that "this person was a bozo" whose highlights make no sense, it remains virtually impossible to "unsee" those marks, and they inevitably distort your thinking. Even seasoned domain specialists get caught off guard because accepting AI-generated suggestions is frictionless. To counteract this, experts must either use their knowledge to build programmatic, automated verification checks for conditions of success, or steer the AI in a rough-edged design role. Michael notes that despite holding a PhD in computer science, he cannot treat coding agents as fully autonomous engines; he must actively interrogate their architectural choices, prompting sycophantic responses like "oh, good idea" from the model as they co-engineer solutions.
- **Threshold effect**: When model performance clears the necessary reliability bar, tasks can be trusted implicitly (analogous to compilers and garbage collection); below that bar, human expertise is required.
- **The "used textbook" effect**: Flawed model outputs anchor human cognition in the same way another person's marginalia or bad highlighter marks skew reading comprehension.
- **Expertise in practice**: True augmentation requires domain experts to frame architectural decisions, challenge sycophantic model responses, and define objective programmatic validation gates.
[50:37](https://www.youtube.com/watch?v=y4xvZnl102w&t=3037s) Measuring Success: Replacement Metrics vs. Intelligence Augmentation
Turning to a question from Oscar about how to measure the success of AI implementations, Michael warns against defaulting to cost-cutting or task-replacement metrics. Organizations typically reach for the easiest numbers to quantify: pointing out that an employee who used to perform a task ten times a day now only performs it once. While saving 10% on operational overhead represents a valid optimization, Michael argues that replacement-focused metrics miss the larger picture and will never yield breakthrough innovations or brand-new industries.
Executives and corporate boards naturally crave clear return-on-investment (ROI) figures, but relying exclusively on labor-displacement tallies incentivizes the wrong initiatives. When pursuing genuine intelligence augmentation, organizations should evaluate whether AI enables workers to deliver superior outcomes. Rather than simply asking if a process is faster or cheaper, leaders must determine who is being augmented, identify how that uplift manifests, and track qualitative markers of excellence—such as shipping higher-quality products, increasing market traction, or significantly reducing product crash rates.
[52:30](https://www.youtube.com/watch?v=y4xvZnl102w&t=3150s) Customer-Facing Risk Tolerance and Clustered Failures
Responding to Dara's question regarding risk tolerance and historical success rates for consumer-facing deployments, Michael reiterates the fundamental divide between sharp-edged and rough-edged applications. Human tolerance for failure drops dramatically in customer-facing sharp-edged environments due to algorithm aversion. He points to the familiar frustration of legacy interactive voice response (IVR) phone systems, where a customer attempting a straightforward flight change encounters minor friction and immediately begins screaming *"operator, operator, operator!"* into the receiver.
Because consumer trust margins are razor-thin, deploying AI requires a deliberate business strategy that weighs catastrophic risks against productivity gains. Michael emphasizes that AI failures rarely manifest as isolated, random edge cases; instead, errors cluster predictably around specific task profiles or user cohorts where the model routinely underperforms. Organizations must determine acceptable loss boundaries:
```mermaid
flowchart TD
accTitle: Strategic Risk Evaluation for AI Deployments
accDescr: Flowchart illustrating how organizations balance edge types, error clustering, and risk tolerance across industries.
subgraph ErrorBehavior ["Error Manifestation"]
S --> C["Clustered Error Profiles\n(Consistent failure on specific inputs)"]
R --> C
end
subgraph DeploymentStrategy ["Strategic Trade-Off"]
C --> D{"Domain Stakes"}
D -->|"Safety-Critical\n(Legal, Healthcare)"| P["Responsible / Controlled Deployment\nStrict guardrails, human in the loop"]
D -->|"Consumer-Oriented\n(General tools)"| T["Tolerable Experimentation\nAcceptable if user retention holds"]
end
```
In high-stakes arenas like healthcare and law, practitioners must proceed responsibly to keep potential liabilities in check. Conversely, in lower-stakes consumer products, teams can tolerate higher variance—provided the customer experience does not degrade to the point where users abandon the platform entirely.
[55:21](https://www.youtube.com/watch?v=y4xvZnl102w&t=3321s) The Wrapper Dilemma: UX Moats vs. Getting "Sherlocked"
In response to Fred's question about building software wrappers around third-party models to refine user experience, Michael introduces what he terms "Michael's hot-take corner." He observes that the vast majority of current generative AI startups are essentially product wrappers sitting on top of underlying frontier foundation models. While this strategy carries severe long-term risks, it remains a viable short-term play because superior UX and deep workflow integration genuinely differentiate products and win user adoption. In fact, Michael predicts that consumer and enterprise experience improvements will be the primary driver of AI adoption over the coming decade.
However, wrapper products remain perpetually vulnerable to what Michael calls the "gravity well of ChatGPT" and the classic platform risk of getting "Sherlocked"—referencing Apple's historical pattern of absorbing popular third-party Mac applications directly into the native operating system. Frontier model providers like OpenAI and Anthropic are actively expanding their platforms by launching built-in design, coding, and orchestration tools, directly challenging wrapper products like Figma Make and Lovable. While building a slick interface creates immediate utility, long-term defensibility requires combining a product and UX moat with proprietary data or modeling advantages.
[57:54](https://www.youtube.com/watch?v=y4xvZnl102w&t=3474s) Webinar Wrap-Up and Next Steps
The host steps back in to conclude the broadcast, thanking Michael for the practical frameworks on distinguishing reliable AI capabilities from domains requiring human judgment, and thanking the audience for participating. Attendees seeking a deeper dive into evaluating AI opportunities and designing agentic systems are directed toward the *AI-Powered Product Innovation* course via the shared chat links and on-screen QR code.
[58:49](https://www.youtube.com/watch?v=y4xvZnl102w&t=3529s) Next Steps, Program Resources, and Closing Remarks
Bringing the webinar to a close, the host highlights the available avenues for participants seeking to align these educational offerings with their broader career trajectories. For anyone looking to evaluate how the course offerings fit with their specific professional goals, the Global Alumni program advisors are on hand to talk through individual backgrounds and objectives. Direct links are provided in the chat interface, enabling attendees to easily book a one-on-one consultation call and gather additional details directly from the advisory team.
The session concludes on an appreciative and encouraging note. The host expresses excitement about welcoming prospective students into the Stanford Online learning ecosystem, re-sharing links to the program information page, the one-on-one scheduling portal, and the direct registration form for those ready to enroll immediately. With a warm word of gratitude extended to the audience for participating and to Professor Michael Bernstein for leading the discussion, the host wishes attendees a wonderful day across all time zones before officially ending the broadcast.
- **Advisory Consultations:** Global Alumni program advisors are available for scheduled one-on-one calls to discuss personal and professional alignment with the curriculum.
- **Registration & Information:** Shared links allow participants to explore comprehensive course information or proceed directly with enrollment.
- **Final Acknowledgment:** The session formally wraps up with thanks to the global audience and Professor Michael Bernstein for presenting the session.
## Notable quotes
> [02:06](https://www.youtube.com/watch?v=y4xvZnl102w&t=126s) there feels like there's a new model every week. In fact, there was a new model last week. It might be gone today, back tomorrow. — Michael Bernstein
> [06:40](https://www.youtube.com/watch?v=y4xvZnl102w&t=400s) almost only counts with horseshoes and hand grenades — Michael Bernstein
> [13:18](https://www.youtube.com/watch?v=y4xvZnl102w&t=798s) I'm just going to use it to set timers. — Michael Bernstein
> [18:09](https://www.youtube.com/watch?v=y4xvZnl102w&t=1089s) recent capability gains have only yielded small improvements in reliability. — Arvind Narayanan's research group
> [29:02](https://www.youtube.com/watch?v=y4xvZnl102w&t=1742s) don't let your user interface write a check that your AI can't cash. — Eytan Adar
> [35:03](https://www.youtube.com/watch?v=y4xvZnl102w&t=2103s) They have MDs, I don't. I'm a different kind of doctor. — Michael Bernstein
> [35:03](https://www.youtube.com/watch?v=y4xvZnl102w&t=2103s) You know what you're talking about. Just by the way, in case you're curious, here's some other information. — Michael Bernstein
> [36:11](https://www.youtube.com/watch?v=y4xvZnl102w&t=2171s) human plus AI does better than human. If human plus AI didn't do better than human, then why are we even here? — Michael Bernstein
> [47:24](https://www.youtube.com/watch?v=y4xvZnl102w&t=2844s) this person was a bozo — Michael Bernstein
> [52:30](https://www.youtube.com/watch?v=y4xvZnl102w&t=3150s) operator, operator, operator! — Michael Bernstein
> [55:21](https://www.youtube.com/watch?v=y4xvZnl102w&t=3321s) gravity well of ChatGPT — Michael Bernstein
## Mentioned
Michael Bernstein, Stanford Online, Global Alumni, Stanford University, Stanford Institute for Human-Centered Artificial Intelligence (HAI), MIT, ACM Symposium on User Interface Software and Technology (UIST), The New York Times, MIT Technology Review, TED AI, Super Mario, Apple, Siri, Amazon, Alexa, Arvind Narayanan, Princeton University, Decagon, Sierra, Eytan Adar, Douglas Engelbart, Angèle Christin, Carnegie Mellon University, Erik Brynjolfsson, Eric Topol, Boston Consulting Group (BCG), Wharton, AI-Powered Product Innovation, OpenAI, Anthropic, ChatGPT, Figma Make, Lovable
## Video description
- Explore these concepts in the AI-Powered Product Innovation course: https://bit.ly/pin-stf-webinar
- Learn how to build intelligent AI agents: https://online.stanford.edu/programs/agentic-ai
- Browse all Stanford Online AI courses: https://online.stanford.edu/artificial-intelligence/courses-and-programs
Artificial intelligence is transforming how organizations approach problem-solving, decision-making, and innovation—but knowing where AI can create reliable value is just as important as knowing where it cannot.
In this Stanford Online webinar delivered in collaboration with Global Alumni, Professor Michael Bernstein explores the practical realities of AI adoption and the role of human judgment in an increasingly AI-enabled workplace. The session examines how to distinguish between problems AI can solve reliably and those that continue to require human expertise, judgment, and oversight.
Drawing on research and practical frameworks for human-AI interaction, Professor Bernstein explores how leaders and professionals can evaluate AI opportunities more thoughtfully, assess potential risks, and determine where AI can genuinely augment human capabilities.
Stanford Professor Michael Bernstein argues that widespread enterprise AI failures stem from deploying models against brittle, 'sharp-edged' tasks rather than designing systems for 'rough-edged' intelligence augmentation. He contends that durable value requires building collaborative tools that respect human error tolerance, cognitive limits, and handoff friction rather than pursuing wholesale human replacement.
Rough-Edged Versus Sharp-Edged Problem Feasibility (6:40)
Bernstein distinguishes between rough-edged problems—where multiple valid outputs exist and an 80% accurate draft accelerates work—and sharp-edged problems, where exactly one answer is correct and an 80% result is functionally useless. Generative models excel at rough-edged tasks like drafting marketing copy or summarizing lectures because human workflows absorb variance. In contrast, sharp-edged tasks like clinical predictions or autonomous code deployments face a steep step-function adoption threshold; systems falling below near-flawless reliability are quickly discarded because human tolerance for error in binary tasks is exceptionally thin.
This vulnerability compounds within multi-step agentic workflows. In operational chains such as warehouse inventory replenishment, a single failure in part lookup, volume calculation, or delivery routing ruins the entire macro-operation. While software coding agents can navigate sharp-edged steps because linters, compilers, and unit tests provide automated verification, operational business pipelines lack programmatic feedback loops. Bernstein conceptualizes AI capabilities as expanding concentric circles: tasks migrate inward from unsolved frontiers to rough-edged assistants with human oversight, crossing into sharp-edged automation only after models attain extreme reliability.
Intelligence Augmentation and Unremarkable Interface Design (32:21)
Rather than pursuing labor replacement, Bernstein advocates for Douglas Engelbart's framework of Intelligence Augmentation (IA), treating computing as a cognitive amplifier that enhances human intellect. When technology is introduced under the guise of automation, workers often actively resist by subverting metrics, dragging their feet, or seizing on isolated mistakes to abandon the platform, as documented by sociologist Angèle Christin. Furthermore, Bernstein notes that measuring AI success solely through labor replacement and overhead reduction incentivizes narrow optimization rather than transformative product innovation.
To overcome organizational resistance, teams can actively reframe sharp-edged problems into rough-edged workflows. For instance, instead of deploying an autonomous binary gatekeeper for hospital readmissions, systems can produce structured diagnostic risk summaries to support clinical judgment. Citing Carnegie Mellon research on clinical diagnostic assistants, Bernstein notes that real-world adoption required making the AI 'unremarkable'—relocating the interface from an intrusive center-screen position to a subtle corner widget that offered non-binding information without threatening physician autonomy.
The Complementarity Paradox and Cognitive Surrender (38:10)
The primary objective of IA is complementarity, where human-machine teams outperform either party working in isolation. However, an MIT meta-analysis across multiple studies revealed that human-plus-AI teams frequently performed worse than solo individuals on sharp-edged decision-making problems with strict ground truths. Similarly, a Boston Consulting Group study found consultant performance dropped 23% when participants uncritically accepted AI recommendations for complex tasks, despite recording major quality and speed gains during open-ended ideation.
Bernstein attributes this collapse to human psychological vulnerability. Users frequently succumb to 'cognitive surrender' or overreliance, mistaking fluent prose and persuasive explanations for objective accuracy. When an inevitable hallucination breaks through, user sentiment swings violently into algorithm aversion. Because human trust in algorithms is far more brittle than interpersonal trust, isolated errors often cause organizations to abandon tools completely or retreat to low-stakes tasks, mirroring how early consumer voice assistants were eventually relegated to setting timers.
The Handoff Seam and Wrapper Defensibility (29:02)
System failures frequently occur along 'the seam'—the critical friction point where an automated system attempts to pass control back to a person. Driving simulator studies reveal that when autonomous vehicles encounter edge cases and abruptly alert drivers to take over, humans lack situational context, causing erratic swerving and near-crashes. Bernstein cautions interface designers against letting user interfaces promise autonomous reliability that underlying models cannot sustain.
Addressing commercial viability, Bernstein observes that most current applications function as product wrappers around frontier foundation models. While deep workflow integration and superior UX drive adoption in the near term, wrapper applications face constant platform risk from model providers expanding their native capabilities—a dynamic Bernstein compares to third-party Mac utilities getting 'Sherlocked' by Apple. He forecasts that while user experience will drive adoption over the coming decade, sustainable defensibility requires combining interface design with proprietary data or modeling advantages.
Bernstein concludes that successful enterprise deployment requires aligning AI capabilities with human cognitive limits and reframing all-or-nothing automation into assistive, verifiable workflows. However, balancing the commercial vulnerability of UX wrapper products against the platform expansion of foundation model providers remains an unresolved strategic challenge for software developers.
Source quotes
[2:06] Michael Bernstein: there feels like there's a new model every week. In fact, there was a new model last week. It might be gone today, back tomorrow.
[6:40] Michael Bernstein: almost only counts with horseshoes and hand grenades
[13:18] Michael Bernstein: I'm just going to use it to set timers.
[18:09] Arvind Narayanan's research group: recent capability gains have only yielded small improvements in reliability.
[29:02] Eytan Adar: don't let your user interface write a check that your AI can't cash.
[35:03] Michael Bernstein: They have MDs, I don't. I'm a different kind of doctor.
[35:03] Michael Bernstein: You know what you're talking about. Just by the way, in case you're curious, here's some other information.
[36:11] Michael Bernstein: human plus AI does better than human. If human plus AI didn't do better than human, then why are we even here?
[47:24] Michael Bernstein: this person was a bozo
[52:30] Michael Bernstein: operator, operator, operator!
[55:21] Michael Bernstein: gravity well of ChatGPT
Original transcript
[0:10] So we would like to thank
everyone for joining us for this
[0:12] live session today on
What AI Can and Cannot Do,
[0:16] Intelligence
Augmentation in Practice,
[0:18] brought to you by
Stanford Online,
[0:20] in collaboration
with Global Alumni.
[0:23] Please note that this
session is being recorded.
[0:26] And we're delighted to have
Stanford faculty, Michael
[0:28] Bernstein, with us today.
[0:30] Michael is a Professor
of Computer Science
[0:32] at Stanford University, where
he's the Bass University Fellow
[0:36] and Senior Fellow
at the Stanford
[0:37] Institute for Human-Centered
Artificial Intelligence.
[0:41] He's a nationally
best-selling author
[0:44] and a creator of success of
generative AI simulations
[0:48] that represent the highest cited
research in the history of UIST.
[0:52] Michael focuses on
designing social, societal,
[0:56] and interactive technologies.
[0:58] This research has been reported
in venues such as The New York
[1:01] Times, "TEDAI," and
MIT Technology Review.
[1:04] And Michael himself has been
recognized with the Alfred P.
[1:07] Sloan Fellowship and
Computer History Museum's
[1:10] Tech for Humanity Prize.
[1:12] Michael holds a bachelor's
degree in Symbolic Systems
[1:15] from Stanford University,
as well as a master's degree
[1:18] and a PhD in Computer
Science from MIT.
[1:22] Today, Michael will
explore how organizations
[1:24] can use AI to augment
human intelligence,
[1:27] evaluate AI opportunities, and
create lasting value in product
[1:31] decisions.
[1:32] To ensure the best
audio quality,
[1:35] please make sure to stay
muted throughout the session.
[1:37] And we encourage you
to turn on your camera
[1:39] so we can make this an engaging
and interactive session.
[1:42] If you have any
questions, please
[1:44] make sure to share
these in the Q&A box,
[1:46] and we'll address them when
we get to the Q&A segment
[1:48] at the end.
[1:49] If you are looking at
the bottom of the screen
[1:52] and you do not see
the Q&A option,
[1:54] please make sure and
select the three dots,
[1:57] and you will see
the option there.
[1:58] So with that out of the way,
I will hand it off to Michael.
[2:01] Thank you so much for
being here with us today.
[2:04] And the floor is yours.
[2:06] All right.
[2:07] It is wonderful to see you all.
[2:09] I am excited to dig in and
to talk a bit about what
[2:14] AI can and can't do for us.
[2:18] When you're thinking
through your AI strategy,
[2:21] what is it that
you want to pursue?
[2:26] And this is, as at
least I mentioned,
[2:30] these are selections from an
online course that I offer.
[2:34] And I think that
it's been resonating
[2:36] with a number of company
boards, executives,
[2:39] senior executives, CTOs, CEOs,
and so on that I've spoken with.
[2:43] And I hope it resonates
with you as well.
[2:46] So let's start from the
question we're trying to answer.
[2:49] So what does it
feel like, as time
[2:54] has gone on, in terms of
the amount of AI progress
[2:57] that's going?
[2:58] Now, you're probably tracking
that there feels like there's
[3:02] a new model every week.
[3:03] In fact, there was a
new model last week.
[3:05] It might be gone
today, back tomorrow.
[3:06] We'll find out.
[3:08] But the broad question here
is, what does it feel like?
[3:13] It really does feel like we're
on some rapidly accelerating
[3:17] curve.
[3:17] And we could debate exactly
the shape of this curve,
[3:20] but it certainly feels like
it's moving very, very quickly.
[3:24] So a second curve here,
same period of time.
[3:27] What does it feel like
in terms of the number
[3:29] of AI-based products
and services
[3:31] that are getting launched?
[3:32] And if you're feeling
as anything like mine,
[3:36] then I think it's
probably at least as steep
[3:41] at this point, that people are
really trying to figure out
[3:44] what is this useful for, and
what can we apply it to help
[3:50] solve problems at
our organizations
[3:52] or that our customers or
people in civil society
[3:56] might care about.
[3:58] So then a third question.
[4:00] Time has gone on.
[4:01] All right.
[4:02] How many successful AI-based
products and services
[4:06] are we seeing?
[4:08] And I think here, the curve
is a little bit more anemic.
[4:11] You might say, look,
there are absolutely many,
[4:16] many different ideas
being thrown around.
[4:19] It's a Cambrian
explosion of ideas in AI.
[4:23] And people are
going to experiment.
[4:24] A lot of stuff's going to fail.
[4:26] That's kind of by design.
[4:27] But from what I've seen,
there are legit differences
[4:32] that can separate out the
successes from the failures.
[4:36] And I want to spend
this time together
[4:39] piecing apart the why here.
[4:42] What is it that might be
separating these successes
[4:45] from these failures?
[4:48] And in particular, what do
they know that others don't?
[4:54] And why are so many products
misfires-- abandoned,
[5:00] embarrassing wastes of money?
[5:02] What are you supposed
to do about it?
[5:06] And I want to split this,
my answer to this question,
[5:09] into two parts.
[5:11] One is around how you
decide what's feasible,
[5:15] and the other is how you
decide what's worthwhile,
[5:19] what you should actually build.
[5:22] So let's start with
what's feasible,
[5:25] because AI is moving pretty
quickly, arguably too quickly
[5:29] for our old-school
business strategies.
[5:34] And this is because any
change you want to make
[5:38] can take months.
[5:39] You make a plan.
[5:41] You have to execute an
organizational change.
[5:44] You have to actually
do the work.
[5:46] You have to prep the launch,
actually do the launch,
[5:50] manage the change with
your customers, and so on.
[5:53] And at the same time,
as you're doing this,
[5:55] the AI capabilities change.
[5:57] So by the time you
actually launch or go
[5:59] to market with
something, the technology
[6:02] itself has now shifted, and
what you launched looks old.
[6:07] So what do you do about this?
[6:10] What I think we need is not
some answer that says, oh, hey,
[6:14] I'm going to tell you
exactly what's going
[6:16] to happen six months from now.
[6:18] And I could do that, but I think
that it would be out of date
[6:23] very quickly.
[6:24] So what I think we need is
actually a durable framework
[6:28] that's not tied to
specific technical roadmaps
[6:32] but lets you plan ahead.
[6:34] And that's going to be the
promise of the first part
[6:37] of this presentation.
[6:40] And what I'm going
to do first is
[6:42] I'm going to lean
into a distinction
[6:46] that I've found to be
quite useful for planning.
[6:50] And that is a
distinction between what
[6:51] we're going to call sharp-edged
and rough-edged problems in AI.
[6:56] So I'm going to
make a claim here.
[7:01] That is the framework.
[7:02] And then I'm going to
explain what the heck I mean.
[7:04] And then we'll walk
it through to explain
[7:06] why I think it's so powerful.
[7:09] The claim, which
you're not going
[7:10] to understand because I'm
not going to have defined any
[7:12] of my terms yet, is that
generative AI struggles
[7:17] more on something that we
will call sharp-edged problems
[7:21] than on something
else that we're
[7:22] going to call
rough-edged problems when
[7:24] you try to deploy it.
[7:26] And it's not because the AI
is better at one or the other.
[7:30] The model is
equivalently powerful.
[7:32] It has a lot more to do with how
we embed those and deploy them.
[7:37] So the claim is going to be
about harder to launch something
[7:41] sharp-edged than rough-edged.
[7:43] OK.
[7:43] So what do I mean?
[7:45] Rough-edged problems
are any problem
[7:50] that has a ton of
different solutions
[7:52] that we would all
consider to be correct.
[7:54] I'll give some
examples in a moment.
[7:55] But just to give the
rough intuition here,
[7:59] if you're having an AI, write
something, write a marketing
[8:05] copy or write a summary of
this lecture or draw an image
[8:11] or play Mario.
[8:12] Anything where getting 80%
of the way is still helpful.
[8:17] Anything that has many different
possible solutions typically
[8:21] also has the property, that if
you get me in the neighborhood,
[8:24] it's still an accelerant, and I
can take it the rest of the way.
[8:29] In contrast, a
sharp-edged problem
[8:33] is a problem that has only
one correct solution, one
[8:37] and only one.
[8:39] And what that means
is that if I haven't
[8:44] hit exactly the right solution,
then it's just dead wrong.
[8:50] So we'll talk about
agentic tool use, agents,
[8:53] and so on in a moment.
[8:55] If you expect, for example, your
agentic software development
[8:59] environment to be entirely
bug-free on the first shot,
[9:03] that's basically a
sharp-edged problem.
[9:04] Only one way to nail that.
[9:07] Traditional AI decision
or prediction problems
[9:09] like, is this
person going to get
[9:11] readmitted to a hospital
in the next month?
[9:14] That, you're either
right or you're wrong.
[9:17] Anything where
getting 80% correct
[9:20] is still actually just wrong.
[9:23] If you've ever heard the
phrase, "Almost only counts with
[9:26] horseshoes and hand grenades,"
this is someone who's discussing
[9:29] sharp-edged problems.
[9:31] Horseshoes and hand grenades,
I guess they would argue,
[9:33] are rough-edged.
[9:34] Everything else, sharp-edged.
[9:36] OK.
[9:36] So that's what rough-edged
and sharp-edged problems are.
[9:39] And you can look
around and you can
[9:40] see where AI is working in
each of these different spaces.
[9:45] So video generation is
a rough-edged problem.
[9:49] If I have some goal, like make
this video of a man riding
[9:53] a horse in the
American West, there
[9:55] are a million different videos
that I would all look at.
[9:58] And I'd say, yeah, that
seems pretty plausible.
[10:00] That seems pretty good.
[10:02] So that one's rough-edged.
[10:04] There are lots and lots of
possible correct answers.
[10:09] Now, we're talking a lot
about agents these days.
[10:12] Let me talk about what that
means, because they tend
[10:17] to compound both sharp edges,
and sometimes some rough edges
[10:20] as well.
[10:21] And agentic AI, if you
haven't come across this yet,
[10:25] is something that will
output tool commands.
[10:28] So you take your AI,
you call it an agent,
[10:30] and you give it various
tools that it can use.
[10:33] It can write code.
[10:34] It can read a file.
[10:35] It can run some code.
[10:37] It can search the web.
[10:38] It can send an email.
[10:39] It can support can
submit an order.
[10:41] It can open an application.
[10:43] Agentic tools have access
to this library of things
[10:47] that they can do.
[10:49] And then the AI decides,
at any given time
[10:51] point, which of these do I do.
[10:53] I watch what happens.
[10:55] And then I keep going.
[10:57] So if I'm trying to build
something, I'm going to say,
[10:59] hmm, what am I going to do?
[11:00] OK, I'm going to
write some code.
[11:01] All right.
[11:02] Hmm, OK.
[11:02] Now I'm going to go
read these files.
[11:03] Hmm, now I'm going to go
write those codes and so on.
[11:06] And when we empower an AI to
decide which of these commands
[11:09] it wants to run and when
we refer to it as an agent.
[11:14] Now, agents are
interesting because you
[11:16] can look at how they're deployed
in both rough and sharp-edged
[11:20] problem capacities.
[11:22] A sharp-edged version
of a coding agent
[11:24] would be, hey, fix this
bug, ship it to prod.
[11:26] Meaning, there's a problem.
[11:28] Fix it, deploy it.
[11:30] I'm either right, and I've
correctly patched the bug,
[11:35] or I'm wrong, and the bug is
still there, or it got worse,
[11:38] or it takes down my server.
[11:42] Rough-edged version
of this would
[11:45] be something where you're
having the coding agent maybe
[11:48] try to add some logs for issues,
maybe guess or hypothesize
[11:52] what might be going on, open
a pull request to investigate.
[11:55] These are things where there
are lots of different ways
[11:58] to get it right.
[12:00] It's not just a you're
right or you're wrong.
[12:03] And, in fact, what we can
see with coding agents
[12:05] is that you can actually wrap
many sharp problems inside
[12:09] of a coding agent, as long as
it's automatically verifiable
[12:12] if it got it right.
[12:13] So as long as it
knows that it's wrong,
[12:16] coding agents can,
in some cases,
[12:18] tackle sharp-edged problems.
[12:20] But if not, if you're
just having a coding agent
[12:22] go off and try to
improve quality of life
[12:25] or design the interface
or something like that,
[12:27] then it doesn't really have
a signal to iterate on.
[12:32] Speaking of design, design
is a rough-edged problem.
[12:36] There are many, many
different plausible designs
[12:39] for a given spec, but we
often treat it as sharp.
[12:42] Like we say, oh, I want
to design for this.
[12:44] Make me a sign-up modal and add
a way to store user accounts,
[12:47] and it's got to be right.
[12:49] We assume we can just
ship off a description
[12:51] and get something back.
[12:53] It's a little interesting
because it's not
[12:55] like you would go
to an architect
[12:56] and say, I want a house
with three bathrooms, go,
[12:59] like it's often
requires back and forth.
[13:02] So that's why I would describe
it as a rough-edged problem.
[13:04] There are many, many
plausible interfaces, given
[13:11] a specific input you'd give it.
[13:13] But we often treat it as
this like, do this thing,
[13:16] and you're wrong if
you get it wrong.
[13:18] So when does AI fail?
[13:23] Why do I say that AI struggles
more with sharp-edged problems
[13:26] than rough-edged ones.
[13:28] I just want to
reinforce, it's not
[13:30] that AI is inherently better or
worse for rough or sharp-edged
[13:34] problems, in the sense that
it's technically more performant
[13:37] for one versus the other.
[13:39] Again, it is the same
model underneath.
[13:44] It's actually much
more about us.
[13:47] And it's about our
tolerance for error.
[13:54] And the observation is that
our tolerance for error
[13:58] is often very, very thin, very
low, in a sharp-edged problem.
[14:04] And so think of something that
is a sharp-edged problem so
[14:08] that you're either
right or you're wrong.
[14:10] And then examine how
good does this need
[14:12] to be for you to be able
to trust it and use it
[14:14] in your everyday business life.
[14:17] Think of it this way.
[14:18] Let's say AI gets-- on the left
side, AI is not very performant,
[14:23] it's not very accurate.
[14:24] On the right side
of this graph, AI
[14:26] gets more and more
and more accurate.
[14:28] When we are looking
at the y-axis,
[14:31] we are considering
practical usage like,
[14:33] would this actually get adopted?
[14:36] And when we're talking
about a rough-edged problem,
[14:41] as the AI gets better, it
can get me closer and closer
[14:45] to the thing that
I actually wanted,
[14:47] and my adoption will rise.
[14:50] So when AI gets me a
decent draft of some copy
[14:55] that I need to write, I'll
use it, and I'll tweak it.
[14:58] If it gets me better drafts,
I'll use it even more.
[15:00] If it gives me an
even better draft,
[15:01] I'll use it more than that.
[15:03] But that's not the case
with a sharp-edged problem.
[15:06] A sharp-edged problem, you're
either right or you're wrong.
[15:08] And so the way that it often
gets treated in practice
[15:11] is this very sharp
edge, quite literally,
[15:14] where below some threshold,
it's too error-prone.
[15:19] You can't use it.
[15:20] You can't throw this thing
in front of a customer.
[15:23] Let's say that it's
trying to do customer
[15:25] routing between customer
service functions.
[15:29] If it's just too error-prone--
[15:31] I'm sure you've
experienced being
[15:33] on the phone with
some automated bot,
[15:35] and it just keeps
doing the wrong thing.
[15:38] You get frustrated,
and you hang up.
[15:40] Below some threshold of
accuracy in sharp-edged systems,
[15:44] you dump it.
[15:46] And then above
that threshold, you
[15:48] can actually build it
into some inner loop
[15:50] that you can just
trust and rely on.
[15:53] But, it's going to depend
on where that tolerance is.
[15:55] And honestly, for many
sharp-edged problems,
[15:58] I think those tolerances
are much lower.
[16:02] That is to say we make
much higher expectations
[16:05] for automated loops than
many AI systems can provide,
[16:09] especially once things
just start being accurate.
[16:13] So let's take an example.
[16:14] Spam filters.
[16:15] Spam filters have been
around since the 1990s.
[16:18] Naive Bayes algorithm has
been around for a long time.
[16:21] And it is something
where, honestly, it
[16:25] has taken something on
the order of 25 years
[16:28] before we can really
start trusting them.
[16:30] This is a classic
sharp-edged problem.
[16:33] It's either spam or it's not.
[16:35] And you either put
it in my spam folder
[16:36] when you didn't, when
you weren't supposed to,
[16:38] or you didn't put
it in my spam folder
[16:40] when I didn't want to see it.
[16:42] And if you rewind
just a couple years,
[16:45] I don't know if
you were like me,
[16:46] but many people had to keep
checking their spam filter daily
[16:49] because maybe there was
an email from their boss
[16:51] that got filed in spam.
[16:53] And it's just like,
oh god, I need
[16:55] to make sure that there's no
important email that I missed.
[17:00] And now it's much less
often, that essentially,
[17:04] that our threshold for
accuracy hasn't changed.
[17:08] But the AI has gotten good
enough that finally, you
[17:12] can rely on it more or less
and check the spam filter less
[17:17] often.
[17:18] Another old-school
example is Siri or Alexa.
[17:21] This is another sharp-edged
problem, where you say to your--
[17:26] I worry about saying
this out loud.
[17:28] Siri, play the Beach Boys
or something like this.
[17:32] And it either does
the right thing,
[17:36] it plays the Beach Boys on
your music, or it doesn't.
[17:39] And it plays something else, or
it sets a reminder or whatever.
[17:43] It's either right or it's wrong.
[17:45] And because there are so many
errors in this right now,
[17:49] we often just retreat.
[17:49] We're like, OK, I can't use
this for anything interesting.
[17:52] I'm just going to
use it to set timers.
[17:54] Again, in principle, once
it's accurate enough,
[17:56] you could rely on it to
ask all sorts of things.
[17:59] But it's a series of
sharp-edged problems.
[18:01] If it doesn't execute my
command exactly correctly,
[18:05] then it's more problematic
than had I just tried
[18:07] to do the damn thing myself.
[18:09] And the trick is, when
you're using agents,
[18:11] these sharp edges
can really compound.
[18:13] Think of a game of telephone,
where this agent is trying
[18:17] to watch the parts in your
warehouse and then order more
[18:27] so that you're-- the agent is
responsible for just making sure
[18:30] you're never out of supply.
[18:32] And so there are a bunch
of sharp-edged problems
[18:34] that are embedded there.
[18:35] Find the parts at
the warehouse, decide
[18:39] whether to order more or
not, pick how many to order,
[18:42] and ship it to the
right warehouse.
[18:46] If any of these steps misfires,
the entire workflow fails.
[18:51] But bear in mind that they
are all sharp-edged, right?
[18:56] So finding the parts
that is at the warehouse,
[19:00] what if you look
up the wrong part?
[19:01] What if you look at it
in the wrong warehouse
[19:03] and get anything wrong, and
the whole thing is borked?
[19:07] If you decide whether
to order more,
[19:08] maybe your threshold is wrong.
[19:10] Maybe you think that you need
more of these when you actually
[19:12] don't.
[19:12] You've wasted money.
[19:14] Pick reorder volume.
[19:15] You get too many, too few.
[19:16] You're not going to have
the supply you need.
[19:18] If you set delivery
location, if you send it
[19:20] to the wrong location, there's
only one correct location.
[19:22] Any other one, if you
ship it to Florida
[19:25] when it's supposed to
be going to California,
[19:28] it's actively harmful.
[19:30] And so it's like a
game of telephone.
[19:32] Sharp edge, sharp edge, sharp
edge, sharp edge, sharp edge.
[19:34] You have to be able to trust
all of them simultaneously.
[19:38] And this is why we
see, and I'll talk more
[19:41] about this in a
moment, coding agents
[19:45] that are working on
sharp-edged problems
[19:47] tend to succeed when
there are automatically
[19:49] verifiable outcomes,
because that way,
[19:51] they can know when one of the
sharp-edged links has failed.
[19:57] We see sharp-edge failures
all over the place.
[19:59] Legal hallucinations.
[20:00] You've probably heard of
this one, where a lawyer gets
[20:03] sanctioned or fined after they
submit court documents that
[20:09] include a legal citation to
a case that doesn't exist.
[20:14] This is sharp edge.
[20:15] You're either citing the right
support for your argument
[20:18] or you're not.
[20:20] And there's no in between.
[20:21] This is either a real citation
that supports the point
[20:25] or it's not.
[20:26] And so we see here someone,
who didn't catch it,
[20:30] getting really embarrassed.
[20:34] And again, when we see
sharp-edged with motion with AI
[20:39] agents-- here's a paper from
Arvind Narayanan's group
[20:44] at Princeton, where
they're studying
[20:47] reliability of AI agents.
[20:50] And again, we're seeing that
these agents are not always
[20:54] consistent and robust.
[20:58] I'm just quoting here from
the bottom of their abstract,
[21:01] "Recent capability gains have
only yielded small improvements
[21:03] in reliability."
[21:04] And that's because,
if you can't get
[21:06] each of these elements
over the threshold,
[21:09] you're really still in a
world where the whole macro
[21:14] thing is below your
sharp-edged threshold.
[21:18] Looking at customer
support bots,
[21:20] you can think about
Decagon and Sierra
[21:22] as dueling startups
in this area,
[21:25] you have really a sense of
both sharp and rough-edged
[21:32] opportunities there,
where there are
[21:33] some sharp-edged
problems you could have
[21:35] AIs work on with customers.
[21:38] Where's my order?
[21:39] Common troubleshooting-- routing
people to the right page,
[21:43] arranging returns.
[21:44] These are all things that you
can succeed within a sharp-edged
[21:47] in this--
[21:48] I think most of these things
are good enough at this point
[21:50] to rely on as sharp-edged.
[21:52] And then there's a bunch
of rough-edged stuff,
[21:54] like suggesting responses for
human support or answering
[21:58] customer questions or a
concierge-style interaction.
[22:02] These are all things that
are more rough-edged.
[22:04] They're many different
ways to get that right.
[22:07] And so we see them
deployed successfully.
[22:12] Even if the AI is not always
100% exactly the best,
[22:16] it's still typically
good enough.
[22:19] You can think of this
as producing feedback
[22:23] in different ways.
[22:24] A rough-edged problem
might be able to give you
[22:26] a low-fidelity version that is
good enough for you in your work
[22:30] to carry forward, whereas
a sharp-edged problem might
[22:34] be closer to something that's
high fidelity, where it
[22:37] has to be just shippable as is.
[22:41] And one final example
here would be something
[22:45] like accessibility feedback.
[22:47] Here's a paper from
Germany showing
[22:51] how, for blind and
low-vision people,
[22:54] AI can help you understand
where your UI might
[22:58] be missing accessibility
guidelines, right?
[23:01] So if you're a
creator of software,
[23:03] you run it through
this AI, and it will
[23:04] help you see what you might do.
[23:07] And this thing can be helpful
with rough-edged problems,
[23:12] right?
[23:16] But often I get asked,
OK, rough versus sharp,
[23:21] now help me predict the future.
[23:23] That's what you promised, right?
[23:25] Here's the thing to know.
[23:28] The set of solved
sharp-edged problems with AI
[23:32] is always going to be
smaller than the set
[23:35] of rough-edged problems
that AI has solved.
[23:39] That is to say, whatever that
ball is of problems that AI can
[23:44] solve that are sharp-edged,
that it's successful,
[23:47] there is going to be a larger
ball of rough-edged problems
[23:52] that AI can solve today.
[23:55] Why is that the case?
[23:57] Well, any problem I can
solve to 95% or 99% accuracy,
[24:02] I can also solve to 80%.
[24:05] And the set of things that
I can solve 80% of the way
[24:08] is always going to be much
larger than the set of things
[24:10] that I can solve
99.999% accuracy,
[24:14] which is what you might need
for sharp-edged problem.
[24:17] So think of it this way.
[24:20] When you're trying
to plan ahead,
[24:22] know how tasks evolve in AI.
[24:26] As AI gets better, a
task is going to start.
[24:29] It's that yellow circle there.
[24:30] It's going to start outside
both of these circles.
[24:33] It doesn't work at all.
[24:35] But as AI gets better,
it'll move from unsolved
[24:39] to solved as a
rough-edged problem,
[24:42] to eventually solved as
a sharp-edged problem.
[24:45] It's going to migrate
inwards in this graph.
[24:50] And the reason it can't
just teleport to sharp edge
[24:53] is because if you could solve
it in a sharp-edged way,
[24:56] you definitely have
a good enough model
[24:58] to solve it in a
rough-edged way.
[25:00] So then think what's
going to happen
[25:04] when the next generation
of AI models comes out.
[25:08] Well, when the models get
better, what's going to happen?
[25:13] Well, the set of things that we
can solve in a sharp-edged way
[25:16] will grow.
[25:17] That inner circle is going to
expand because the AI model has
[25:23] gotten better and more things
it can solve really, really
[25:26] accurately.
[25:28] At the same time, that
rough-edged circle
[25:32] is going to expand, too.
[25:33] So things that used to be
outside the rough-edged circle
[25:35] are now going to get
absorbed by that.
[25:38] So you don't need to have any
technical expertise in this
[25:44] to understand what the
next generation of AIs
[25:48] is likely to make
possible for you.
[25:50] You can just look and
say, is this problem
[25:54] just outside that
inner border of-- maybe
[25:59] it's just outside that
sharp-edged border?
[26:01] It's definitely rough-edged now.
[26:03] And it's barely
sometimes good enough
[26:05] to be sharp edge but not
good enough to rely on.
[26:08] Well, then the
next model version,
[26:10] it may get sucked inside
of that sharp edge,
[26:13] and you'd be well positioned
to be ready to leverage that.
[26:16] Likewise, something that
just barely works or barely
[26:19] doesn't work in a rough-edged
way right now, the next model
[26:22] release probably
going to suck it in.
[26:25] And it's going to be good enough
for rough-edged work very soon,
[26:29] and you can be ready to go.
[26:32] But you also don't
have to just wait.
[26:34] You can often turn
sharp-edged problems
[26:38] into rough-edged
problems and work today.
[26:40] People often start, when
they're envisioning AI,
[26:42] they start by
picturing something
[26:43] that's a sharp-edged problem.
[26:45] Oh, I want this predictor.
[26:47] Yes or no.
[26:47] I want it to automatically
do this or that.
[26:49] You know what?
[26:50] You can often turn that
sharp-edged problem
[26:53] into a rough-edged problem,
which will work earlier.
[26:56] You don't have to wait for
the AI to be autonomous.
[26:59] For example, maybe you're
building some AI predictor
[27:02] of hospital readmission.
[27:05] Maybe that's making too many
errors for you to just rely on.
[27:08] But instead of just having it
do it completely autonomously,
[27:12] you can have it write
a report, a report that
[27:15] lays out the risk factors
to a human decision maker.
[27:19] That now is a rough-edged
version of that same problem,
[27:22] right?
[27:23] It's like, ah, maybe it's not
good enough to do it completely
[27:27] by itself, but it is good enough
to lay out some stuff that I
[27:30] ought to pay attention
to, that I can
[27:32] use to make a better decision.
[27:35] So what's your
rough-edged/sharp-edged strategy
[27:37] playbook?
[27:39] Start by reflecting on
your expected AI use case.
[27:43] Is it a sharp-edged problem,
or is it a rough-edged problem?
[27:47] If you're envisioning
a sharp-edged use case,
[27:51] ask yourself what's
the threshold.
[27:53] What level of
accuracy would the AI
[27:54] need to have in
order to be useful?
[27:56] How many nines in that
reliability estimate
[27:59] do you really need in
order to actually use
[28:03] the spam filter, the Alexa, the
agent, whatever it would be?
[28:08] If today's AI cannot solve
the problem at that level
[28:12] of accuracy, ask yourself, can
I turn that sharp-edged problem
[28:15] into an equivalent
rough-edged problem?
[28:18] Were this good enough today?
[28:20] That's a trick.
[28:22] If you're instead envisioning
a rough-edged use case,
[28:26] then turn around,
go out, spend $20,
[28:30] and try to use
today's models and see
[28:32] if it can produce something
useful as a starting
[28:34] point for iteration.
[28:36] This allows you to say, ah,
I can make use of this today.
[28:43] And I know where
things are going
[28:45] because I can see
that trajectory
[28:46] from rough to sharp over time.
[28:52] So I set out by asking
this question like,
[28:55] what separates the
successes from the failures?
[28:57] Why are so many
products abandoned?
[28:59] And I've answered
half of that so far.
[29:02] I've said, this is what is
possible, what is impossible.
[29:08] But there's one last
piece here that I
[29:10] want to talk about, about
what you should build,
[29:13] why you should build them.
[29:16] The reason being
here is that you can
[29:19] have the best AI in the world.
[29:20] But if it doesn't
match people well,
[29:23] it's going to get abandoned.
[29:24] And I can show you these
examples from various robotics
[29:29] labs.
[29:29] It makes it super
visceral, where
[29:32] you look at something
like these robots,
[29:36] they are not the most
efficient robots in the world.
[29:39] If these robots wanted to
point at things and grab stuff,
[29:42] there are much faster and more
efficient ways they could do it.
[29:45] But instead, they're
using gesture.
[29:49] They're looking at you.
[29:50] They're swinging their arm.
[29:52] The human plus AI combination
is much more efficient
[29:57] than if it did the thing
that just the robot would
[30:01] have wanted to do.
[30:02] So something here has to embed
the human-centered element.
[30:07] And we have to think
about this carefully.
[30:09] Because in this driving
simulator, where there's
[30:12] a self-driving car
in a simulator,
[30:14] the car correctly
says emergency,
[30:16] tries to inject
control to the person,
[30:18] they barely notice in time.
[30:20] Almost drive off the road,
veer into the opposite lane,
[30:24] almost get into a car
crash, swear, and almost
[30:27] crashed twice in 30 seconds
within this simulator.
[30:32] And there's
something here that's
[30:34] going on about how even great
AIs can produce huge issues.
[30:40] This is an example
of what I would call
[30:42] and what we call in the
research literature, the seam--
[30:45] the handoff between
the AI and the person.
[30:49] Because, of course,
a more advanced AI,
[30:52] something that could have
handled this as a sharp edge,
[30:55] would have effectively
just navigated
[30:57] these traffic conditions fine.
[30:59] And likewise, had
the person been
[31:02] in driving control
the whole time,
[31:04] they also would
have navigated fine.
[31:06] The error wasn't at the AI, and
it wasn't just with the person.
[31:12] It was at that handoff, the seam
between the person and the AI.
[31:18] And I have this hunch that this
is a widespread issue, not just
[31:22] with self-driving cars but with
many AI-based products, where
[31:27] my colleague Eytan
Adar likes to say,
[31:29] don't let your user interface
write a check that your AI can't
[31:32] cash.
[31:34] Right, like that.
[31:35] We're over promising.
[31:36] We're promising a
sharp-edged experience
[31:38] when all we can execute is
like a rough-edged outcome.
[31:43] And it's almost like many
companies are putting engines
[31:47] on the outside.
[31:48] They're saying like, hey,
buy my AI-powered device.
[31:51] And it's like, what
about is AI-powered?
[31:53] What problem is it solving?
[31:55] And it's like, no, no, no,
don't pay attention to that.
[31:57] It's AI.
[31:58] It's like, well, what exactly?
[32:01] And I think this can
lead to what people
[32:05] talk about as the trough
of disillusionment,
[32:08] where you over promise.
[32:10] And then everyone gets
inevitably disappointed in what
[32:14] is actually possible,
because the push is more
[32:17] tech first than problem-driven.
[32:21] I think a much
better way to think
[32:23] of this is something
that we refer to
[32:26] as intelligence augmentation.
[32:28] And if you want to
remember this term,
[32:30] the best way is just to remember
that Intelligence Augmentation,
[32:34] IA, is just AI backward, right?
[32:39] Intelligence augmentation
is a reaction to this idea
[32:43] that AI is just
going to replace us,
[32:45] and it is a recognition
that that's often
[32:50] both shortsighted and wrong.
[32:53] Where a traditional AI
would be to say replace
[32:57] human intelligence with
artificial intelligence, what
[33:01] Intelligence Augmentation,
or IA, would say is,
[33:05] how do we augment our
intelligence with AI?
[33:08] How do we give
ourselves superpowers?
[33:10] How do we make
ourselves smarter,
[33:12] more strategic, more
clever, more funny?
[33:15] Whatever it would be.
[33:16] How do we have a
strap-on cortex that
[33:19] makes us do things that
we couldn't do before?
[33:22] Not trying to remove us,
but make us superpowered.
[33:27] And in fact, over half of
usage of large language models
[33:31] today is already happening
in augmentative capacity.
[33:35] The media loves to focus on
replacement as the narrative.
[33:40] And to be sure, there is
replacement that's happening,
[33:44] and some jobs will shift.
[33:47] However, the vast
majority of AI usage
[33:50] right now is-- or maybe not
the vast majority, excuse me.
[33:53] The majority of
AI usage right now
[33:56] is in augmentative
capacity, where
[33:59] people are using it to iterate
on things, rough-edged problems,
[34:03] like you can't pull
me out of the loop.
[34:06] And this is not a new idea.
[34:08] This actually goes all the
way back to this Turing Award
[34:11] winner, Doug Engelbart, who
came up with this notion
[34:13] of augmenting our intellect
all the way that you--
[34:15] he used this to invent things
like the computer mouse,
[34:18] the bitmap display,
interactive word processing,
[34:22] collaborative word
processing, all in the 1960s.
[34:24] This guy was a beast.
[34:26] It was really impressive.
[34:28] We augment instead replace
because often replacing
[34:33] does not go so well.
[34:35] Here's some research from my
colleague, Angele Christin
[34:38] at Stanford, finding that
as these kinds of data tools
[34:42] get deployed by web journalists,
legal professionals,
[34:46] and so on, it gets pushed back
on if people think that you're
[34:53] there to replace them.
[34:54] They'll drag their feet,
they'll game the AI,
[34:57] they'll openly critique it.
[34:58] They'd be like, oh,
it made this mistake.
[35:01] That costs us $1 million.
[35:03] You really should
not trust this AI.
[35:07] And in fact, we
have these issues
[35:10] where in order to make
these things actually
[35:13] get embedded successfully
in organizations,
[35:16] you often have to make
it less AI-focused.
[35:22] Here's a research project
out of Carnegie Mellon,
[35:25] finding that to get doctors
to actually use an AI,
[35:28] what they had to do was make
it seem, quote, "unremarkable."
[35:31] In this case, doctors, famously
protective of their autonomy
[35:34] and expertise-- well earned.
[35:36] They have MDS, I don't.
[35:37] I'm a different kind of doctor.
[35:41] Essentially, they
had to take the AI
[35:45] and move it into the corner.
[35:47] Rather than the AI being front
and center for the doctors,
[35:50] having it be a little
visible, like floating thing
[35:54] on the side--
[35:55] was saying, sort
of implicitly, you
[35:57] know what you're talking about.
[35:58] Just by the way, in
case you're curious,
[36:00] here's some other information.
[36:06] It was not taking over.
[36:07] It was more invisible or
less visible, I suppose.
[36:11] But it's even more
complicated than this.
[36:15] The goal should be human plus
AI does better than human.
[36:18] That's the entire vision of
intelligence augmentation.
[36:22] If human plus AI didn't
do better than human,
[36:24] then why are we even here?
[36:26] And we do see that
this can happen.
[36:29] We call this in the research
literature complementarity.
[36:32] It means that human
plus AI does better
[36:34] at this task than human
alone or AI alone.
[36:38] And we see a number of instances
where this does happen.
[36:41] My colleague, Erik
Brynjolfsson at Stanford,
[36:43] has run experiments
finding that, for example,
[36:45] at call centers, you actually
do see augmentative effects,
[36:48] where call center employees
who get advice from AIs
[36:53] on how to handle really
tough customers do better.
[36:58] Likewise, here's a tweet
by Eric Topol pointing out
[37:00] how a large, recent
AI randomized control
[37:04] trial in medicine
found that they
[37:06] have massive improvements in
detection of breast cancer
[37:10] from mammographies.
[37:12] And this is human-in-the-loop.
[37:14] The AI was helping decide
what to prioritize and so on.
[37:18] BCG, the consulting group, found
that large numbers of people
[37:22] of their own consultants
improve performance
[37:24] when using AI for
free creative tasks.
[37:28] This is all complementarity.
[37:30] This is all, also,
unfortunately, not
[37:33] the complete story.
[37:35] If you look at the rest
of this BCG article,
[37:37] it does say that on a different
task where people took the AI's
[37:43] feedback at face value, their
performance was 23% worse
[37:47] than not using the AI at all.
[37:49] 23% worse.
[37:51] And then they're not alone.
[37:53] Here's an RCT in
software engineers,
[37:57] finding that engineers
think they're going faster
[38:00] with coding tools at the time,
but are actually going slower.
[38:04] Another report suggesting
that many generative AI pilots
[38:06] at companies are failing.
[38:07] What's going on here?
[38:10] Well, some researchers at MIT
started to investigate this.
[38:13] They did what's called
a meta-analysis, where
[38:15] they took a bunch of
studies and then turned them
[38:17] all into one mega study,
where they were looking
[38:19] at the patterns across them.
[38:21] And they drew this graph.
[38:22] Zero in this graph means
that in a given study,
[38:27] there was no effect.
[38:29] Human plus AI did exactly as
well as human alone or AI alone.
[38:32] To the right, in the green
zone, is a positive impact.
[38:36] That's complementarity zone,
where AI plus human did better
[38:38] than AI alone or human alone.
[38:40] To the red, to the left, is
negative complementarity,
[38:46] so to speak, a lack
of complementarity
[38:48] where human plus AI did worse
than human alone or AI alone.
[38:52] And the interesting thing about
this, if you look at this graph,
[38:54] is that there is a lot of red.
[38:57] In fact, on average, people
plus AI did worse than people
[39:01] alone or AI alone.
[39:04] And I think that this
is really interesting.
[39:07] What's going on here?
[39:08] It turns out that when they
looked at what was in the red
[39:12] and what was in the
green, the biggest losses
[39:15] tended to be
decision-making tasks like,
[39:18] will this person get
readmitted to the hospital?
[39:20] And the biggest wins were
content creation generation
[39:23] tasks.
[39:25] To me, this is really
interesting because this very
[39:28] much splits along
sharp-edged/rough-edged lines.
[39:31] Many of these decision-making
tasks are sharp-edged problems,
[39:35] and many of the content
creation tasks are rough-edged.
[39:39] So we are definitely starting to
see a difference in the actual,
[39:44] on the ground success of AI,
along rough and short-edged
[39:48] axes.
[39:51] So if our goal is human plus
AI does better than human
[39:54] but the reality is that
that's not always guaranteed,
[39:57] we call that not great.
[39:59] Why?
[39:59] What's going on?
[40:00] And this will be my
last point before we
[40:02] turn to some discussion.
[40:06] It's actually about
human psychology.
[40:10] One thing we know
that happens in AI
[40:12] is what's called overreliance.
[40:14] Overreliance is
this feeling of, I'm
[40:17] flying, where someone
starts to use an AI
[40:20] and then doesn't
double check it enough.
[40:23] So at some point, the AI
inevitably makes a mistake,
[40:26] especially on a sharp-edged
problem, and you don't catch it.
[40:29] Like the lawyer who
didn't catch that,
[40:31] they submitted a
hallucinated citation.
[40:35] So this happens
because people just
[40:39] go into a mode of satisficing
or cognitive offloading,
[40:43] or what some folks at Wharton
call cognitive surrender, where
[40:47] they just totally
check out and trust
[40:49] the AI to just do the thing.
[40:51] And it turns out that
even if the AI is
[40:53] explaining its reasoning,
we don't always catch it.
[40:56] Because it turns out
that paradoxically,
[40:58] when an AI explains
its reasoning--
[40:59] have you ever asked
ChatGPT a question
[41:01] and it writes you a
whole essay in response?
[41:03] You're like, oh,
that seems plausible.
[41:05] The more it explains, the
more plausible it sounds.
[41:08] So after you overrely,
you see that it
[41:10] makes a really bad mistake.
[41:13] And then you pivot
over to what's
[41:14] called algorithm aversion.
[41:16] Algorithm aversion is
where you undertrust the AI
[41:21] because it turns out, as teams
of psychologists have found,
[41:26] that our trust in AIs is
more brittle than our trust
[41:29] in people, given the
exact same error.
[41:34] If you get into a car with me
and we drive to dinner tonight
[41:37] and I get into a minor accident,
you're not hurt, we're all fine,
[41:41] would you get back
into a car with me?
[41:44] Maybe not tomorrow,
but, OK, soon enough,
[41:48] maybe If you got into
a self-driving car
[41:53] and that self-driving car
got into the exact same minor
[41:55] accident, would you buy the
same brand of self-driving car?
[42:00] Maybe not.
[42:01] That's algorithm aversion.
[42:03] Our trust in
algorithms is brittle.
[42:06] And so people start
by overrelying.
[42:08] They see that it
makes a mistake.
[42:10] And then they swing over
to algorithm aversion,
[42:12] and they undertrust the AI.
[42:15] So if I pull this together,
modern AI developments
[42:20] are opening many
new opportunities
[42:23] for product development.
[42:24] I like to think of these
by classifying them
[42:27] into this space of
rough-edged problems
[42:29] and sharp-edged problems to help
us understand what opportunities
[42:33] are likely to open up when.
[42:37] But, even the smartest
AI-based product ultimately
[42:42] has to solve a real
problem for real people,
[42:44] or it's going to get
dropped on the floor.
[42:47] And that's ultimately the answer
to the question I laid out
[42:49] at the beginning, that you can
use intelligence augmentation
[42:54] as your litmus test to
answer the question of,
[42:57] what separates the
successes from the failures?
[43:02] And I think if you do
so, you will be much more
[43:04] likely to take strategic
moves in your plans
[43:07] around AI development
that are going to pay off.
[43:11] So with that, I
would like to pause
[43:16] and hand it over to the
Global Alumni team, who
[43:19] have a few words to say.
[43:21] And then we're going to
have some discussion, Q&A,
[43:23] until the end of the session.
[43:25] So let's hand it off
over to Global Alumni.
[43:28] Thank you.
[43:33] Thank you very much,
Michael, for sharing
[43:36] all of your expertise
with this whole group that
[43:40] was able to make it today.
[43:43] If you have any
questions, as I mentioned
[43:45] at the beginning of the session,
please do use the Q&A box
[43:50] and enter your questions there.
[43:53] While we give you a few minutes
to answer your questions,
[43:57] we wanted to just
briefly mention
[43:59] that some of the topics that we
covered today in this session
[44:03] are also covered in a course
that we are glad to offer
[44:07] with Michael Bernstein.
[44:08] This is a course on
AI-powered Product Innovation.
[44:11] It's a six-week
course, fully online,
[44:14] with two faculty
sessions as part
[44:16] of the course learning journey.
[44:19] We'll give you a quick glimpse
of what the key takeaways are
[44:22] for the course, so you can
get an idea of what that is.
[44:26] So key takeaways
are, identifying
[44:28] where AI is appropriate to apply
and distinguish viable use cases
[44:32] from high-risk applications.
[44:34] We talked a little
bit about that today,
[44:36] but you can get more in depth
on that with the course content.
[44:40] You can also evaluate how AI
can augment human capabilities
[44:43] and support better
decision making; understand
[44:46] the psychological principles
behind trust, adoption,
[44:49] and human AI interaction and how
they influence AI-enabled enable
[44:54] product decisions; address
ethical and societal risks,
[44:57] which is very, very
important early
[44:59] through structured approaches
to decision making;
[45:02] use generative AI
agents and modern AI
[45:04] systems to simulate
user behavior
[45:07] and guide product strategy; and
identify what drives AI product
[45:11] adoption and long-term user
behavior and a hands-on capstone
[45:14] project.
[45:16] So you can see here that
there is a project that
[45:18] allows you to put
everything into practice
[45:20] and think really through how you
might apply all of the concepts
[45:23] that you learned
through the course.
[45:26] We'll go to the next
slide so you can quickly
[45:28] take a look at what you'll
learn through the course.
[45:33] So when you walk
away from the course,
[45:35] there are four main things that
we hope you walk away with.
[45:38] The first is being able to
apply structured frameworks
[45:41] to guide AI product decisions.
[45:43] The second one is to assess
where AI can deliver reliable
[45:47] outcomes and where it cannot.
[45:49] And finally, anticipate
how AI capabilities may
[45:52] evolve in the coming years and
how this impacts the product
[45:55] strategy.
[45:56] And then, finally, make
more responsible decisions
[45:58] as an outcome by recognizing
ethical and societal risks.
[46:05] And then, finally, a
quick walkthrough of what
[46:07] is included in the course.
[46:09] So be on the content.
[46:11] You will also learn
with AI Tutor, which
[46:14] is a tool that allows
you to ask questions
[46:16] throughout your
learning journey,
[46:18] whether it's on the content
or logistical matters.
[46:20] It will accompany you
throughout the learning journey
[46:23] to be able to ask
questions in real time.
[46:26] You'll be able to apply
AI product frameworks
[46:29] through hands-on
real-world assignments
[46:30] and the capstone
project, as I mentioned.
[46:33] You'll engage in guided
discussion forums
[46:36] with your peers across
the industry, which
[46:39] will allow you to
network and get to know
[46:41] the other people in the course.
[46:43] You will work with
modern language models
[46:45] to explore intelligence
augmentation and generative AI
[46:48] agents.
[46:49] And you will also earn a
earned a Stanford Online
[46:51] Certificate of Achievement
upon successful completion.
[46:55] So with that, I will
hand it back over
[46:58] to Michael, who will address
the questions that are coming
[47:01] into the chat box right now.
[47:05] And if you are
interested in the course,
[47:07] we will make sure and drop the
link so that you can go and get
[47:10] more information.
[47:12] Michael, back to you.
[47:14] And I see that there are
some questions coming in.
[47:18] Is there one that you
would like to address just
[47:20] at the top of this
section of the webinar?
[47:24] Ah, let's see.
[47:26] I see a question from
Vanessa about whether you
[47:29] need to be an expert
to critically analyze
[47:31] the results of the
content, especially
[47:33] around sharp-edged problems.
[47:36] That's an interesting one.
[47:38] So I think that the question is,
what is the level of accuracy
[47:48] that you need?
[47:48] So, for example, let's
take a coding agent.
[47:52] There are some things that
these coding agents can solve
[47:56] in a sort of sharp-edged way
that you don't actually need
[47:59] to be an expert at anymore,
because it's so accurate that
[48:04] you're probably--
[48:07] your expertise
may not be needed.
[48:09] So, for example, if I were
going to be writing a relatively
[48:14] straightforward algorithm
to, I don't know,
[48:17] pass some variables around
or count things or et cetera,
[48:20] et cetera, the models are good
enough, that despite the fact
[48:25] that that's a
sharp-edged problem,
[48:26] it's either the algorithm
is right or it's wrong,
[48:29] you probably don't
need to be an expert
[48:32] to oversee it because you can
just trust it, in the same way
[48:36] that there are compilers
in my computer that
[48:40] are very complicated in how they
optimize things and my programs.
[48:45] Or, in a programming
language, they
[48:47] can do things called
garbage collection that
[48:48] makes sure I don't leak memory
and crash computers that I don't
[48:52] need to track.
[48:53] I can just trust that they work.
[48:55] And this is because they're
over some sharp-edged threshold.
[48:58] If it's not over, whatever that
sharp-edged threshold that you
[49:01] need is, you absolutely have
to be an expert in order
[49:04] to watch it.
[49:05] The problem is that if it's
not over that threshold
[49:07] and you have to
watch it, you start
[49:09] running into this AI
overreliance problems,
[49:11] where sometimes it's just
too easy to go along with it.
[49:15] It's like if you
buy a used textbook
[49:18] and it's already got
highlights in it,
[49:20] it's hard to unsee
the highlights,
[49:21] even if you know they're wrong.
[49:23] Like, this person was a bozo.
[49:24] What are they highlighting?
[49:25] But you still see it, and
it still influences you.
[49:31] And so even with expertise,
you can get caught.
[49:36] That's tough.
[49:38] The only ways
around that would be
[49:40] that if you can
use your expertise
[49:43] to create automated checks
for the conditions of success.
[49:49] That can help.
[49:50] Or, you use your expertise in
a more rough-edged capacity.
[49:54] When I'm using a coding agent--
[49:55] I have a PhD in
computer science.
[49:57] I know how to
program, allegedly.
[50:00] And yet, I am still engineering
when I use these coding engines,
[50:04] because they're not
good enough to just
[50:06] be completely autonomous.
[50:08] I need to be like, why did
you architect it that way?
[50:10] Why not that way?
[50:11] It'll say, oh, good idea,
very sycophantic, and so on.
[50:15] And so I think you do need
your expertise in the loop
[50:17] in order to succeed at
these kinds of things.
[50:22] Let's grab another one.
[50:23] I'm seeing some in the
chat and some in the QA.
[50:27] So I'll do my best to
jump back between them.
[50:33] Let's see.
[50:37] Oscar asks around
the metrics that you
[50:41] see as being important
when evaluating success.
[50:47] I think that often the metrics
that people think of first
[50:54] are metrics that are
derived from something being
[50:58] a replacement solution.
[51:01] Ah, this thing that
I do 10 times a day,
[51:06] I now need to only do once.
[51:09] And that's great.
[51:12] The issue there is that we're--
[51:18] that only allows you
to measure things that
[51:22] are transformed by replacement.
[51:24] And if you follow my
argument, that is honestly
[51:29] an optimization that will
save 10% or whatever,
[51:32] it's not going to
be the thing that
[51:34] creates whole new industries.
[51:35] And so you really have to
measure what you actually
[51:37] care about.
[51:39] If you're really
creating something
[51:41] intelligence-augmenting, you
have to track other metrics.
[51:44] Maybe instead of, is it
cheaper or saving time?
[51:48] it's more like, are we
shipping better products?
[51:54] Are our products doing
better in the market?
[51:57] Are they crashing less often?
[52:00] Whatever it would be.
[52:01] And so I think that often
what the C-suite or the board
[52:06] wants to see are
clear ROI metrics.
[52:10] And the easy metrics to make
are typically replacement ones,
[52:14] but they're often
the wrong ones.
[52:16] So I am typically
looking at, OK,
[52:18] if we're looking for
something augmentative,
[52:20] what or who are we augmenting?
[52:23] And how would we know
if that's working?
[52:25] That's the metric I push for.
[52:30] Let's see.
[52:30] There was a question that came
in about risk tolerance, which
[52:33] might tie-in well to what
you were saying from Dara.
[52:37] So when it comes
to risk tolerance,
[52:41] is there any data
on how successful
[52:43] AI solutions have been in
customer-facing situations?
[52:46] So I guess it could be a good
follow up to success metrics.
[52:50] And how much
tolerance do we have
[52:53] when it comes to
different risks when
[52:55] something is customer-facing?
[52:57] Yeah, I think this is exactly a
rough, sharp-edged distinction,
[53:01] where our risk
tolerance is often
[53:04] quite low when you're
deploying an AI
[53:06] in a sharp-edged situation.
[53:07] I mean, again, just
think back a few years
[53:09] to when you call the airline
and it's trying to talk to you.
[53:13] And you're just saying, I need
to change the following flight,
[53:16] ta, da, da.
[53:17] And eventually, you just start
yelling, operator, operator
[53:19] operator, right?
[53:25] We have very thin trust margins.
[53:29] This is what algorithm
aversion tells us.
[53:32] And so, as a result, you
have to think through,
[53:39] how often am I willing to let an
error slip through on my system?
[53:44] And even worse than
that, you have to say,
[53:47] knowing that it's not like a
random error that might happen
[53:50] occasionally, it's going to
be clustered because the AI is
[53:53] going to have consistent classes
of errors it makes all the time.
[53:58] Like, oh, whenever someone comes
in with this particular kind
[54:00] of task, it's going to do worse.
[54:03] And so this is really
a strategic decision
[54:07] at your business level where
you have to say, how much are we
[54:11] willing to risk?
[54:13] This kind of
catastrophic outcome
[54:15] that might be rare, this kind
of not catastrophic but bad
[54:18] experience outcome, in order to
get all of these other gains,
[54:23] right?
[54:24] Clearly, there are many cases
where the gains are worth it.
[54:27] There are a lot of reasons why
people use ChatGPT and Claude
[54:30] and so on to help solve problems
today where they wouldn't have
[54:33] before, but you have to be very
clear about what the risks are.
[54:38] And I think this is where
legal professionals and doctors
[54:42] and others have been
proceeding with some--
[54:47] caution is the wrong word.
[54:48] But let's call it "responsibly,"
in order to balance the risks
[54:57] against the rewards.
[54:58] I think in many
cases, with things
[55:01] that are
consumer-oriented, you can
[55:04] be a little bit more
risk-tolerant, as long
[55:08] as the person doesn't drop it.
[55:11] Whereas, there are
other cases where
[55:12] if it's really safety-critical
or you only get one shot,
[55:16] I'd be very careful.
[55:21] Thank you, Michael.
[55:22] We probably have time
for one more question.
[55:25] Is there one that you saw
that you really, really wanted
[55:29] to get to from the Q&A?
[55:32] Hmm.
[55:34] What is the most burning
question that you see there?
[55:38] Fred asked an interesting
one in the chat
[55:40] about whether there
are use cases where
[55:41] it's worth building
wrappers around AI models
[55:44] to enhance the UX.
[55:49] This is going to be
Michael's hot-take corner.
[55:55] I think there will be use cases.
[55:57] I think many of the startups
that are not frontier labs
[56:01] or neolabs right
now in this space
[56:04] are effectively wrappers
around frontier models.
[56:11] This is risky long term,
possible short term.
[56:17] And what I mean is, I really
do think that good user
[56:21] experience is a differentiator.
[56:26] And people will
go to things that
[56:27] are more integrated
with their workflows
[56:29] and easier to control
and understand.
[56:31] It does expose you to
what-- in the course,
[56:35] I refer to this as this
gravity well of ChatGPT,
[56:40] which is to say--
[56:41] There's an old term, about being
called you got "sherlocked."
[56:44] This used to be when
Apple would take
[56:47] whatever your great feature was,
your app that you built for Mac.
[56:50] And then they would just
build it into the OS.
[56:52] And you're starting to see this,
too, where the frontier modeling
[56:55] companies--
[56:56] Anthropic launches
a design tool.
[57:00] Well, Figma Make and
Lovable and others
[57:04] that build these
things themselves,
[57:06] wrapping around them.
[57:07] Yeah, it's very
easy for a company
[57:08] to then build a UX around it.
[57:11] So I think that the
short term is like, yes.
[57:14] And I actually think
that the next 10 years
[57:16] is going to be a story of
experience improvements driving
[57:22] adoption of AI.
[57:25] But, I also think that you
are exposed in doing so,
[57:29] to the risks of
getting sherlocked,
[57:32] of getting absorbed
by the company that
[57:35] built the underlying model.
[57:36] And so the best
position to be in
[57:39] is one where you
have a modeling moat,
[57:42] as well as a product in UX moat.
[57:45] It's much harder,
but that's the ideal.
[57:53] All right.
[57:54] Thank you very much for
addressing that final question,
[57:57] Michael.
[57:58] And with that, we're going to
wrap up the session for today.
[58:01] I want to take a moment and
thank all of you for joining
[58:04] the session today on What
AI Can and Cannot Do,
[58:07] Intelligence
Augmentation in Practice.
[58:10] And, Michael, of course,
our gratitude to you
[58:12] for leading this webinar.
[58:15] We hope that the discussion
provided valuable insights
[58:18] into where AI creates reliable
value, where it falls short,
[58:22] and how organizations can use
AI to augment human intelligence
[58:25] more effectively.
[58:27] If you'd like to continue
exploring these topics,
[58:30] we'd like to remind
you that there's
[58:32] a course, AI-Powered Product
Innovation, that does just that.
[58:37] We will drop the
link in the chat,
[58:40] and you can also
get more information
[58:42] by scanning the QR code.
[58:45] If you have questions
about the course
[58:47] and would like guidance
on where it aligns
[58:49] with your professional goals,
our Global Alumni Program
[58:52] advisors would be happy
to speak with you.
[58:54] And we will also
drop a link there so
[58:56] that you can schedule a call and
get more information with one
[58:59] of them.
[59:00] Thank you again for joining us.
[59:02] We look forward to welcoming
you to Stanford Online learning
[59:05] experience.
[59:07] If you'd like to know
more about the program,
[59:10] we will drop the link once more.
[59:12] And we will also drop the links
to schedule a one-on-one call,
[59:16] or register to
the program if you
[59:19] are interested in doing so now.
[59:21] Thank you all again
very much for joining.
[59:23] And thank you again,
Michael, for hosting today.
[59:26] Have a wonderful day,
wherever you are.
[59:28] And with that, our
webinar is over.
[59:31] Thank you all very much.