# Designing AI to Scale Human Thought

Jun Yu Tan

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/0tVu-V3_fFw-designing-ai-scale-human-thought) · [Video](https://www.youtube.com/watch?v=0tVu-V3_fFw)

## Designing AI to Scale Human Thought

AI can do more than complete tasks: it can expose overlooked risks, adapt to how people think, and help them develop better judgment while keeping them responsible for the work.

### What happens to judgment when we outsource the work?

[0:00](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=0s)

If an AI writes your code, but you never review it carefully or understand its inner workings, how do you know what you are building—and how do you maintain the skills to judge it? That question sits behind Jun Yu Tan’s exploration of interfaces that develop human capabilities. Some of the interaction patterns are proposals rather than established product behavior, but they address a practical gap in the prevailing approach to agents.

Discrete tasks make an attractive target for automation: the unit of work is measurable, the promise of removing tedious labor is easy to explain, and completion provides a basis for comparing systems. Yet coding and design still require experience, taste, and close supervision. Much of the context needed to make a good decision lives in the minds of experienced professionals; it cannot always be packaged into a prompt. Removing the work can therefore also remove opportunities to exercise the judgment that makes the work good.

![Limitations slide listing deskilling, amplified biases, missed improvement opportunities, human supervision, and difficulty supplying context.](https://ai.engineer/api/talk-essay-media/24397c4b5b35d035f5dece5ec0df72b0fe2e7d39f4cf459f555211268d214831)

Limitations of AI focused on automating tasks and accelerating existing workflows.

### Spend compute on better human work

[1:54](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=114s)

**Augmentation uses compute to help people produce better work while retaining responsibility for it.** Instead of requiring a person to accommodate an AI system’s imperfect attempt at a complex task, the interface can help them notice omissions, explore alternatives, and make a more thoughtful decision.

Consider email. An automated assistant writes the whole message and sends it on your behalf. An augmentative assistant helps brainstorm the key points, offers alternative phrasings, and checks the tone. It might notice that a sentence sounds harsh relative to your past correspondence with this recipient or your usual writing style. You decide whether to soften it, review the result, and hit send.

The same distinction applies to code. An automation workflow takes an assigned Slack message, writes the implementation, and opens a pull request. An augmentation workflow reviews a pull request you created and points out an overlooked edge case or a pattern that could fail under high load. The assistance changes what you can see before you approve the work.

![Automation vs Augmentation slide contrasting autonomous email and code creation with brainstorming, tone checks, and finding potential bugs in a user-created pull request.](https://ai.engineer/api/talk-essay-media/609ba593ddf6fbf3890ae602af29e82d907f0d89dfadd9cf2188c9ff698813ee)

Automation and augmentation compared through email and pull-request examples.

The distinction is therefore partly about **where responsibility remains**, and partly about the relationship that develops. A thinking partner expands your field of view while you stay in control. Tan compares the difference to working with an offshore contractor versus a new teammate whose capabilities grow alongside yours.

### Turn blind spots into reviewable evidence

[3:51](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=231s)

The first interaction pattern, **blind spot detection**, asks what you have not considered. A blind spot can be temporal, such as making poor decisions when tired on Friday afternoons, or social, such as technical feedback that reads as personal criticism. Identifying it is only part of the problem. The interface also has to control noise and avoid making the recipient defensive. A useful moment to intervene is when a unit of work appears ready for review.

In the testing workflow Tan describes at [Tusk](https://www.usetusk.ai/), a committed code change becomes the starting point for evidence rather than a stream of speculative warnings:

1. Generate unit tests targeting potential edge cases and bugs in the changed code.
2. Execute those tests in the codebase’s test environment.
3. Surface issues supported by the test results.
4. Let the developer choose whether to commit the generated tests, including passing tests, into the pull request for future regression coverage.

Execution makes the report more concrete, but the developer still decides what belongs in the repository.

A failing test also contains assumptions about what the program ought to do. Tusk exposes its business and engineering assumptions and outlines possible fixes so reviewers can evaluate those assumptions. A thumbs-up, thumbs-down, or written explanation lets the user indicate whether an issue is worth considering and helps the system learn from that review.

Tan calls this **systematic pessimism**: examine every changed symbol, ask what could go wrong, and consider second-order effects through the call stack. That search becomes tedious for a human as changes grow larger and more interconnected. AI can perform the broad search while tests and explicit assumptions give the reviewer something specific to assess.

Tan reports verified bugs in 43% of pull requests and almost 1,000 new tests in two months while discussing Tusk’s work with enterprise and growth-stage customers, including DeepLearning.AI and TeamFeePay. These are reported product results, not a general benchmark for AI testing.

### Allocate attention by novelty and criticality

[5:56](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=356s)

Not every valid suggestion deserves the same presentation. The **novelty–criticality framework** separates how unfamiliar an issue is from how consequential it is. In code review, those two dimensions suggest four different interface behaviors.

| Novelty | Criticality | Example | Presentation |
|---|---|---|---|
| High | High | Unfamiliar race condition; customer-data exposure | Interrupt for a critical discovery |
| High | Low | New language feature; alternative approach | Offer a gentle, expandable suggestion |
| Low | High | Common bug; standard security check | Warn clearly; vary interruption by context |
| Low | Low | Formatting; minor optimization | Batch and make optional |

A familiar but serious problem still needs a warning, but it does not need a long explanation of a concept the user already understands. An unfamiliar improvement can be valuable without being urgent. Formatting preferences should not compete for attention with a data leak.

The purpose is to spend a limited attention budget well. Tan’s prioritization argument does not establish a validated numerical cap on suggestions per review. The actionable design principle is to distinguish discoveries, learning opportunities, reminders, and polish before deciding what should interrupt the user.

### Adapt to how the user thinks

[7:09](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=429s)

The second pattern, **cognitive partnership**, moves beyond stateless answers toward a system that adapts to a person’s mental models. Knowing the desired output is not enough. The assistant may also need to understand whether someone learns through analogies or visual explanations, prefers time to reflect, or thinks through rapid iteration.

A proposed code editor could learn a developer’s refactoring patterns and suggest similar improvements in new contexts. A research assistant could learn whether its user synthesizes information chronologically or thematically, then organize its help accordingly. The useful continuity is in the way the person works, not just the facts remembered about them.

This creates a privacy constraint: personalization must make people feel understood without making them feel surveilled. A system’s ability to infer a preference does not by itself make acting on that inference comfortable or welcome.

![Cognitive Partnership slide describing adaptation to mental models, learning styles, and familiar analogies, with a warning about intrusive personalization.](https://ai.engineer/api/talk-essay-media/d804d290a0084757389cf18ccc3fddd49d65fe0e1a0abe9d2ffdf050873de130)

Cognitive partnership adapts to users while making them feel understood, not surveilled.

### Choose the moment to help

[7:50](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=470s)

The third pattern, **proactive guidance**, makes timing central. A suggestion can be relevant and still arrive at the wrong moment. Good guidance should feel like a fortunate discovery rather than an interruption.

A calendar application might propose meeting times based on energy patterns as well as availability. A writing tool might recognize that the writer is stuck and suggest a break instead of encouraging more effort. Both proposals use context to decide when—and in what form—to intervene. The design challenge is to find a middle ground between waiting passively for every request and overwhelming the user with unsolicited help.

### Let trust develop through collaboration

[8:26](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=506s)

These patterns depend on an ongoing relationship. When AI participates in how someone thinks and works, trust becomes more than confidence that a single transaction will succeed. Tan proposes three properties for that relationship.

- **Progressive trust:** Establish reliability through low-stakes suggestions before asking the user to rely on the system for high-impact decisions.
- **Contextual trust:** Keep competence specific to the domain and situation. Strong code review does not establish good design judgment; insufficient context should be visible.
- **Bidirectional trust:** Let both sides adapt. The AI learns preferences while the person learns its capabilities, and the system adjusts its behavior to the trust placed in it in different scenarios.

This makes trust something the interface develops and calibrates over time, rather than a blanket permission granted once.

### Evolve the interface with the person

[9:27](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=567s)

If augmentation helps someone learn, the interface should change as their competence grows. It can visualize increasing expertise, introduce more complex features gradually, and adjust explanations to reflect what the user now understands. Repeating the same introductory guidance indefinitely would ignore the development the product is meant to support.

**The target is real skill enhancement, not merely the feeling of being capable while the assistant is present.** Learning may initially be difficult, but users should experience improvement in their core work and the satisfaction that comes with it. Increasing dependence on the tool is not sufficient evidence that augmentation is working.

### Measure capability alongside engagement

[10:06](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=606s)

That goal changes product evaluation. Usage, retention, and engagement still matter, but they do not establish that users are becoming more capable. A learning application can retain people without improving their performance in real-life situations. An augmentation product needs to ask how its users are growing as well as how often they return.

There are product reasons to care about that growth. First, learning a user’s preferences and intellectual needs can create a stronger relationship. Tan points to [ChatGPT’s memory feature](https://openai.com/index/memory-and-new-controls-for-chatgpt/) as an example of continuity across conversations; the emotional value of feeling understood is his interpretation of that experience.

Second, lasting value can come from making a team better, not only faster. Capability building gives buyers another reason to invest beyond immediate productivity. Third, users have their own stake in the outcome: time spent with an AI tool is also time spent developing—or neglecting—their abilities. Choosing tools intentionally means asking whether that investment supports learning alongside the work.

![Why should we care slide with three bullets about emotional connections, productivity and capability, and intentional learning while using AI tools.](https://ai.engineer/api/talk-essay-media/16dff8ae08d75fa1bba66cdea4ecc6ea8a8a3bca3a53924a699c0a53c43e0cba)

Why capability-building AI matters: emotional connections, more capable users, and learning alongside tools.

### Interfaces that make thought more visible

[11:08](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=668s)

Efficiency is only part of the opportunity. Tan’s larger ambition is for AI to strengthen intuition, taste, and creativity. Blind spot detection, cognitive partnership, and proactive guidance provide possible ways to pursue that ambition, but they depend on interfaces that preserve agency, earn trust, and learn alongside their users.

The next-decade vision is an aspiration: tools that help people think in ways they could not before. An interface can act as a mirror for cognitive patterns, making habitual omissions visible and suggesting perspectives a person repeatedly misses. The value lies in what the person comes to notice and understand, as well as what the system produces.

How to build such systems remains an early design problem. The durable criterion is whether an interface enhances human capability as understanding of the technology evolves—whether using it helps people become more thoughtful, more creative, and more able to judge their own work.

## Resources

- [Beyond Automation — The Case for AI Augmentation](https://jytan.net/blog/2025/ai-augmentation/) — Jun Yu Tan's essay on cognitive partnership, progressive trust and evaluating growth in human capabilities.
- [How DeepLearning.AI Used Tusk To Prevent Bugs in PRs](https://blog.usetusk.ai/blog/deeplearning-case-study) — Tusk's customer case study describes backend test generation and reports edge cases identified in 42.9% of testable pull requests during the first two months.
- [Memory and new controls for ChatGPT](https://openai.com/index/memory-and-new-controls-for-chatgpt/) — OpenAI's memory announcement explains personalization across conversations, user controls and dated rollout updates.
- [Tusk Is Sunsetting](https://www.usetusk.ai/resources/tusk-is-sunsetting) — Official notice of Tusk's June 10, 2026 product sunset and transition guidance for existing customers.

## Slides

### Scaling Human Thought with Augmentative AI

Jun Yu Tan introduces a vision for AI interfaces that help people think and create, with some ideas he describes as speculative.

[0:00](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=0s) [Title slide introducing Jun Yu Tan, founding engineer at Tusk.](https://assets.ai.engineer/sites/aiecode2025/sha256/5c8b5534cc00d50122404467805d41fac72e25390fc39b709ebb0b7e79ff2b9d.webp)

Scaling Human Thought with
Augmentative AI

Jun Yu Tan
Founding Engineer,
Tusk

### Limitations

Automating existing workflows risks deskilling and reinforcing suboptimal patterns. Coding and design still need human judgment, while much of the context for those decisions is hard to put into a prompt.

[0:46](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=46s) [Lists risks of automation, including deskilling, amplified biases, missed improvements, supervision needs, and difficulty providing context.](https://assets.ai.engineer/sites/aiecode2025/sha256/a2e537d9c641485a868ed7ea46c2622df3856268636ba6704037a2dbac098eda.webp)

Limitations

A lot of AI implementations (especially agents) are focused on automating tasks or accelerating existing workflows

But...

• Deskilling / over-reliance / laziness / slop
• Amplification of existing biases (perpetuating known but suboptimal patterns)
• Missed opportunities for genuine improvement (efficiency > quality / innovation)
• High-judgment domains (e.g., coding, design, ...) still require tight human supervision anyway
• Often difficult to upload perfect context for high-context tasks

3

### This talk is about...

The talk explores AI interaction patterns that reveal blind spots and spark creativity, alongside design principles for strengthening human capabilities and building sustainable, trustworthy human-AI partnerships.

[2:06](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=126s) [Talk objectives include revealing blind spots, supporting human capabilities, and building trustworthy human-AI partnerships.](https://assets.ai.engineer/sites/aiecode2025/sha256/24c7f211a446d32d17587395d17b45ff2ba042e573b4d50ef5202384b57b1f72.webp)

This talk is about...

• Interaction patterns for how AIs can help users reveal blind spots, spark creativity, and amplify thoughtful decision-making
• Principles for designing AI products that puts human capabilities front and center
• How to build sustainable and trustworthy human-AI partnerships

4

### Automation vs Augmentation

Automation has AI send emails or create pull requests. Augmentation keeps the person in charge while AI helps refine an email or find bugs in their code.

[2:27](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=147s) [Contrasts autonomous email and coding tasks with AI assistance for brainstorming, reviewing, and finding bugs.](https://assets.ai.engineer/sites/aiecode2025/sha256/74d06bcd2d562e9657479244afb0a98a75c3e7b937d55c21a2d75bfa839e1c65.webp)

Automation vs Augmentation

Automation
• AI that autonomously writes emails and sends it on your behalf.
• AI that automatically writes code and creates a pull request based on a ticket or Slack message.

Augmentation
• AI that helps you brainstorm points for an email, suggest alternative phrasing and angles, checks for tone and content, before you send it.
• AI that finds potential bugs that you might have missed, verify with tests, for a pull request you created.

5

### Key Differentiating Principles

Automation replaces human tasks and measures efficiency; augmentation builds human capability through collaboration, shared context, and growth-oriented feedback.

[3:24](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=204s) [Table compares automation and augmentation across mental models, interaction patterns, success metrics, trust, feedback, and cognitive support.](https://assets.ai.engineer/sites/aiecode2025/sha256/eb02c626aee58dcd5c29d4b0cd9b354811378872d445f257c0aa2e3c2949f489.webp)

Key Differentiating Principles

Automation | Augmentation
Mental model: Replace a human task | Enhance human capabilities and decision making
Interaction patterns: One-shot, fire & forget | Collaborative, building shared contexts
Success metrics: Efficiency-based | Growth-based
Trust: Reliability-centric | Growth-centric
Feedback loops: Performance-oriented | Development-oriented
Cognitive support: Task offloading | Cognitive enhancement

Read further: https://jytan.net/blog/2025/ai-augmentation/

6

### Design Patterns – Blind Spot Detection

AI could act as a debate partner to flag overlooked patterns in thinking. The challenge is to offer useful feedback without making people defensive, and to review work when it is ready.

[3:50](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=230s) [Slide describing blind spot detection, possible implementations, and challenges including timing and signal-to-noise ratio.](https://assets.ai.engineer/sites/aiecode2025/sha256/d42035d4d426b06518925da7e99841dece1092e9d13c5211cddf61746b5e309c.webp)

Design Patterns – Blind Spot Detection

Understanding potential oversights in human thinking and decision-making processes

As you were working on the task, what did you miss?

Potential implementations:
• Consider temporal and social blind spots, as well as ineffective tendencies among users
• Debate partner / devil’s advocate

Challenges:
• Managing signal-to-noise ratio
• Challenging one’s thinking without making them feel defensive.
• Works-in-progress may entail meandering paths that seem suboptimal. When might [illegible] the right time for the AI system to effectively review?

7

### Verified Bugs! (Tusk)

Tusk generates and runs tests against pull-request changes. Here, 3 of 11 tests fail; the review explains a zero-seat-limit assumption and suggests a fix.

[4:35](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=275s) [Slide showing a test-generation interface and a code review summary reporting 11 generated tests, including three failures.](https://assets.ai.engineer/sites/aiecode2025/sha256/0ea44205304c3454940a8e8cde0ffbb2ea2c311b720e7e2e7b1aca7e0eab9e39.webp)

Verified Bugs! (Tusk)

Generated 11 tests - 8 passed, 3 failed
[TUS-914] Enforce seat limit

Coverage Metrics
Line Coverage
Source file: backend/src/services/UsersService.ts
Original: 0.00%
After Tusk: 18.46%
Gain: +18.46%

Deselect All  11 of 11 tests selected
backend/src/tests/services/UsersService.test.ts - isClientUnderSeatLimit
6 generated  4 passed  2 failed

High value  isClientUnderSeatLimit should return false for zero seat limit ❌

Assumption: A maximum seat limit of zero is a valid business state that should be enforced, rather than being treated as ‘no limit’ or as an error condition.
• The function currently returns true when the maximum allowed seats is set to zero, which is incorrect.
• This behavior could allow clients with a zero seat limit to activate seats, violating business rules.

Potential fix
• Update the function to explicitly check if ‘maxSeats’ is zero and return false in such cases.
• Ensure that the logic treats zero as a valid limit and not as an undefined or null value.

Test code
1  import { describe, it, beforeEach, afterEach, expect, jest } from "@jest/globals";
2  import { TestHarness } from "~/tests/utils/TestHarness";
3  import { UsersService } from "~/services/UsersService";
4  import { randomUUID } from "crypto";
5  import { Seat, Client, IClientSubscriptionPlan } from "~/models";
6
7  describe("UsersService", () => {
8    let testHarness: TestHarness = new TestHarness();
9    let usersService: UsersService;

Generated 11 tests - 8 passed, 3 failed
Test Summary
• activateSeat - 4 ✅, 1 ❌
• isClientUnderSeatLimit - 4 ✅, 2 ❌

Results
The Tusk test suite reveals some critical issues with the seat limit enforcement implementation. While most tests pass, there are three failing tests that highlight important edge cases. The activateSeat method doesn't throw an error when seat limits are exceeded, and isClientUnderSeatLimit has issues with zero seat limits and invalid client IDs. These failures could lead to clients bypassing seat restrictions, which directly impacts the business model of limiting seats based on subscription plans.

Key Points
• ❌ activateSeat silently fails when seat limits are exceeded instead of throwing an error, making it difficult for callers to understand why activation failed
• ❌ isClientUnderSeatLimit incorrectly returns true when max seats is explicitly set to zero, potentially allowing clients with zero seat limits to activate seats
• ❌ isClientUnderSeatLimit doesn’t validate client IDs, which could lead to database errors or misleading results with invalid inputs
• The seat limit enforcement is a critical business path that directly impacts subscription compliance and revenue
• Tests confirm that inactive seats are correctly excluded from seat limit calculations
• The PR correctly implements the core functionality of preventing seat activation when clients exceed their limits

Visit https://usetusk.ai to find out more!
8

Interface text:
Incorporate tests
Show excluded tests
tusk-dev bot commented 3 weeks ago
View tests
View output in GitHub
View check history

### Noise Management → Intelligent Curation

The novelty–criticality framework matches code-review findings to their UX treatment: interrupt for critical discoveries, offer learning moments gently, warn about familiar risks, and batch optional polish.

[5:55](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=355s) [Slide mapping examples by novelty and criticality alongside a table of suggested interface treatments.](https://assets.ai.engineer/sites/aiecode2025/sha256/d1291a27db2a8319028200609c132ebcf04f116fdc58b96e26dc3c5342b80828.webp)

Noise Management → Intelligent Curation

Novelty (surprise factor)
Criticality (impact factor)

High novelty, low criticality:
Observing a repeated pattern
Language feature discovery
Alternative approaches

High novelty, high criticality:
Memory leaks
Accidentally exposing user data
Timing bug under high load

Low novelty, low criticality:
Minor performance optimizations
Style inconsistencies
Readability nits

Low novelty, high criticality:
Missing error handling for boundary conditions
SQL injection vulns in user input handling
Breaking changes

Novelty | Criticality | UX treatment
Critical discoveries | High | High | Immediate, prominent alerts, warrant interruptions
Learning moments | High | Low | Gentle, expandable suggestions w/ clear explanations
Essential reminders | Low | High | Clear, standardized warnings
Polish & preference | Low | Low | Batch findings, make them optional behind “see [illegible] suggestions”

9

### Design Patterns – Cognitive Partnership

Cognitive partners could adapt explanations and analogies to how a user thinks. The challenge is to personalize the experience so users feel understood without feeling surveilled.

[7:08](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=428s) [Slide describing adaptation to users’ mental models, personalized explanations and analogies, and the challenge of avoiding intrusive personalization.](https://assets.ai.engineer/sites/aiecode2025/sha256/875696393cc04028665dd51a1ba31e3145474e7dc41fcb2c9e72e92b8590f797.webp)

Design Patterns – Cognitive Partnership

From stateless answering machines → adaptation to the user’s mental models and thought patterns

Theory-of-mind (maintaining an impression of who the user is, their preferences, etc)

Potential implementations:
• Automatically adapting to learning / explanation styles that seem to be more effective for the user
• Building a library of analogies that resonate with user’s specific background/interests

Challenge:
• Building ToM / personalization without being creepy. Users need to feel understood, not surveilled.

10

### Design Principles – Trust Framework

Build trust through low-stakes tests, communicate expertise and uncertainty in each context, and let AI and users adapt to each other as trust changes.

[8:18](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=498s) [Slide presenting progressive, contextual, and bidirectional trust as principles for human-AI partnership.](https://assets.ai.engineer/sites/aiecode2025/sha256/1bce61489d8342e7e06eaf3c81837f12971608e34b675038da057fb7dca229fe.webp)

Design Principles – Trust Framework

Progressive

Trust should be earned in increasingly complex domains.

Start with low-stakes suggestions incurring fewer assumptions before moving to high-impact decisions.

Systems should test their accuracy in low-risk scenarios before moving to higher stakes.

Contextual

We trust people differently across domains, the same should apply to AI.

The AI system may or may not have sufficient expertise given specific contexts.

Uncertainty communication is key.

Bidirectional

True partnership means both parties adapt and adjust. The AI learns your preferences while you learn its capabilities.

An AI system should adapt its output to its belief of how much the user trusts it in that scenario.

12

### Design Principles — Progressive Enhancement

Augmentation interfaces should show users their growing skills and unlock complexity as competence increases, supporting genuine skill growth.

[9:25](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=565s) [Slide describes skill visualization and graduated complexity as ways for interfaces to evolve with users.](https://assets.ai.engineer/sites/aiecode2025/sha256/9e5959c072117a22ccba058d3325b82b22b3c63ef3b3af6a490e566ec520e83c.webp)

Design Principles – Progressive Enhancement

Automation interfaces maintain static capabilities, augmentation interfaces must evolve alongside their users.

Skill/achievement visualization

Show users their growing expertise in different domains over time.

Systems should promote joy in genuine skill enhancement, not merely the illusion of it.

Graduated complexity

Start with thoughtful onboarding (meaningful tooltips, wizards, etc).

Unlock features or grant further complexity as competence increases.

13

### Why should we care?

The speaker cites ChatGPT memory as an example of AI building emotional connections, and argues that buyers and consumers should value growing capability alongside productivity.

[10:27](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=627s) [Slide lists emotional connection, greater capability, and learning alongside AI tools as reasons to care about user growth.](https://assets.ai.engineer/sites/aiecode2025/sha256/f5ad948df2c3e484ddd76d84790bc09b3e7599afe81eff6fa3e6462895d5d5f9.webp)

Why should we care?

• An AI product that makes an effort to learn from its users + fulfill intellectual needs will build better emotional connections with them (ex: ChatGPT + memory has been delightful and really sticky for some).
• In the long term, buyers care not only about making themselves/their employees more productive, but also more capable.
• As consumers, let’s be more cognizant of how we can learn alongside these AI tools as we invest precious time using them.

14

### Thank you

[12:18](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=738s) [Closing slide with three QR codes for professional and social profiles and a website.](https://assets.ai.engineer/sites/aiecode2025/sha256/4818adfa59379bf7a299399f71a3a6f3418295aab9a9f933cfae83e6be9d551b.webp)

Thank you :)

tanjy
@jyt4n
usetusk.ai

15

## Full transcript

[0:00](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=0s) Hi, everyone. I'm Jun, Founding Engineer at Tusk. I'm excited to share about a paradigm for building the next generation of AI interfaces, the ones that put humans in the center, augmenting our capabilities and helping us be more thoughtful and creative.

[0:13](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=13s) It's a collection of ideas that I've been thinking about for a while now. Though some of these concepts might be a little bit more speculative, I do hope to encourage more builders in this space to consider these patterns and principles.

[0:24](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=24s) Now, it's often said that twenty-twenty-five is the year of the agents, and rightfully so. Um, from general agents performing research and browser use for you to deeply verticalized apps across all industries, AI agents are everywhere, ready to offload your tasks from you.

[0:38](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=38s) And as agent-based tooling and protocols get more and more mature and sophisticated, it's no doubt that large chunks of knowledge work will be automated away in time to come.

[0:47](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=47s) A lot of agents are focused on automating discrete tasks and for good reason. Well, it's easier to quantify the unit of work performed and sell the promise of eradicating tedious and boring work that people don't like doing.

[0:59](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=59s) It's also easier to benchmark the completion of these tasks quick, and quickly compare one system against another.

[1:05](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=65s) But it's also not difficult to spot the potential drawbacks of such a future if it's not carefully managed. Firstly, there's a notion that, you know, over-reliance on automating work away breeds general laziness and atrophy of skills.

[1:18](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=78s) I'm sure most of you are discerning users, but when you write code in an app without thoughtful review or at least bother to sufficiently understand its inner workings, how are you maintaining these skills?

[1:28](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=88s) H-are you sure you know what you're bu- actually building? Many high-judgment domains like coding and design still require tight human supervision, relying on human experience and taste for approval.

[1:39](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=99s) A lot of these are also like high context tasks, where it's often difficult to just upload perfect context and encapsulate them in prompts or for accurate judgment, since a lot of them, a lot of these like live in the minds of experienced professionals anyway.

[1:54](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=114s) So the main thesis of this talk is this. Instead of getting humans to accommodate to AI systems, uh, attempting to automate complex tasks and doing so sub-optimally, why not spend that compute just helping humans produce high-quality work in the first place?

[2:07](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=127s) So in this talk, I'd like to introduce some ideas for augmentation-based UX. We look at interaction patterns for how AI can help users reveal blind spots, spark creativity, and amplify thoughtful decision-making.

[2:20](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=140s) Some principles for designing AI products to emphasize and grow human capabilities, um, and trustworthy human-AI partnerships. Let me make this concrete with a simple comparison. Um, the automation approach to AI emails might look like this, right?

[2:35](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=155s) The AI writes the entire email for you and, and sends it on your behalf. Um, you're out of the loop, basically. The au- the augmentation approach is a little bit different.

[2:44](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=164s) Um, AI could help you, uh, brainstorm key points, for example, suggest alternative phrasings, um, check your tone. Maybe it says, "Hey, this might come across as a bit harsh.

[2:54](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=174s) Do you want to soften it based on your past emails with this person or usual writing style?" And then you review and hit send. Same with coding, right? With automation, AI writes the code, creates a pull request based on a Slack message that you have assigned to it.

[3:07](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=187s) Augmentation could be something like AI reviewing your pull request and says, "You might have missed this edge case. This pattern you're using here could cause issues on a high load."

[3:17](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=197s) Now, the difference is that in augmentation, you're still in the driver's seat, but you have a thinking partner or co-pilot who can see things that you might miss.

[3:26](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=206s) And this cap-- And this table captures the, the fundamental shift in this mindset. In a nutshell, many differences, uh, arise based on a shift of responsibility of the task itself and the relationship-- and our relationship with the AI system that helps us with these tasks.

[3:39](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=219s) It's almost like working with an offshore contractor versus a new team member that we grow together with. And if you're interested in knowing more about this in further detail, I wrote about it in my blog post linked below.

[3:51](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=231s) Now, let's get to the meat, the three core interaction patterns. I want to start with blind spot detection because it's the most immediately compelling. Now, think about it. We all have blind spots, patterns that we can't see in our own thinking.

[4:03](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=243s) Uh, the question for AI isn't what you do wrong, but what didn't you consider as you're working on this task?

[4:09](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=249s) This could be temporal blind spots, like noticing you always make poor decisions when tired on a Friday afternoons, um, or social blind spots, flag-flagging when your technical feedback might come across as personal criticism.

[4:21](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=261s) Um, the key challenge is managing that signal-to-noise ratio and nudging someone or challenging their thinking without making them feel defensive. Um, ideally, the AI should be designed in a way that reviews something at the right time, uh, when a unit of work, um, can be assumed to be ready.

[4:36](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=276s) Here's how we implemented this at Tusk. Now, Tusk is an AI testing platform that finds edge cases and bugs based on your pull requests. When you commit your code changes, instead of just surfacing potential bugs, we create unit tests and actually validate them, execute them against your, your codebase test environment, and surface to you verified issues that

[4:52](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=292s) we can prove will cause problems in the future. You can then choose whether to commit these tests alongside other passing ones into your pull request so that, you know, there's, uh, extra coverage against future regressions.

[5:04](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=304s) One thing we try to help make reviewing these tests easier is also to surface any assumptions that Tusk is making, be it from a business or engineering standpoint, and also outline potential fixes.

[5:15](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=315s) Um, users can provide feedback by clicking thumbs up or thumbs down or explain why it's something worth considering or not. So that Tusk learns from your, from, from your review of its assumptions.

[5:26](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=326s) I also like to call this systematic pessimism. We're using AI to systematically look through, um, every symbol that has been changed, finding what could go wrong, um, consider second-order effects in the call stack, even though this is something very tedious for humans to manually perform effectively, um, especially in larger, more complex code changes.

[5:44](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=344s) With this pattern, we have helped, uh, enterprise and growth stage companies like DeepLearning.AI and TeamVpay catch verified bugs in forty-three percent of pull requests and add almost a thousand new tests in two months.

[5:56](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=356s) In the blind spot detection pattern, not all suggestions are created equal.

[6:00](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=360s) I've been thinking about how we can manage, uh, noise with thoughtful UX. Uh, one mental model is the Novelty-criticality framework. And let's again consider the code review scenario. High novelty, high criticality, these are critical discoveries.

[6:14](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=374s) Things like race conditions that you, that you have never encountered before, accidentally exposing customer data. These deserve to interrupt you. Novelty, low criticality. These are learning moments. Suggestions like alternative approaches, new language features, recognizing ineffective patterns.

[6:29](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=389s) You might wanna present this gently as maybe as expandable suggestions. Low novelty, high criticality. These are more of essential reminders. Uh, things like common bugs, standard security checks, performance issues might help to give clear warnings and have a little bit more flexibility when it comes to interruption.

[6:47](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=407s) But we don't have to overexplain since users probably already know the concept. Low novelty, low criticality. These are more matters of polish and preference. Code formatting, minor optimizations, and things of that nature.

[6:58](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=418s) We want to batch these, make them optional. The magic is in the prioritization because people tend to only process three or more meaningful suggestions per review session. This framework helps to spend the attention budget wisely.

[7:09](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=429s) The second pattern is cognitive partnership, moving from stateless answering machines to systems that adapt to your mental models, right? This means building a theory of mind about users, not just knowing what they want, but how they think.

[7:20](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=440s) Do they learn through analogies? Do they prefer visual explanations? Do they prefer to sleep on it or prefer, like, rapid iteration?

[7:29](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=449s) Um, imagine a code editor that learns your refactoring patterns and proactively suggests similar improvements in new contexts. Or, or a research assistant that understands whether you synthesize information chronologically or thematically.

[7:42](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=462s) The challenge here is building this personalization without being creepy. Um, users need to feel understood, but not surveilled.

[7:50](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=470s) And the third pattern, proactive guidance, is probably the hardest to get right. Um, the challenge isn't knowing what to suggest, but when. Um, and great proactive guidance feels like serendipity, not interruption.

[8:01](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=481s) It's like having a calendar app that suggests meeting times based on your energy patterns and not just availability, or a writing tool that notices when you are stuck and suggests taking a break rather than pushing through.

[8:13](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=493s) And the key is finding that Goldilocks zone, right? We don't wanna be too reactive. We also don't wanna be too overwhelming, just right. Now let's shift gears into principles for designing auto-- augmentative AI, because without trust, none of this matters.

[8:26](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=506s) How-- So how do we build that trust in these augmentation systems? Trust becomes, uh, particularly crucial in augmenta-- uh, augmentation interfaces because the relationship between human and AI is more collaborative than transactional, right?

[8:37](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=517s) Again, think about how two humans begin to trust each other. In augmentation paradigm, especially cognitive partnerships, it's likely that we see human and AI interact more like human-to-human interaction.

[8:45](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=525s) I believe trust needs to be progressive, contextual, and bidirectional. Progressive in a sense that it's easier to build trust with low-stake suggestions before moving to high-impact decisions. Um, let a system prove itself, um, on small things first.

[8:59](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=539s) Trust is also contextual, um, because we trust people differently across different domains and for different situations. So the same should apply to AI. AI might be brilliant at code reviews, but terrible at design feedback, or it might not have the right or sufficient context to make certain decisions, so let's make that transparent.

[9:15](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=555s) And bidirectional because true partnership means both parties adapt. The AI learns your preferences while you learn its capabilities. It should adjust its behavior based on how much you trust it in different scenarios.

[9:27](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=567s) For AI to augment us, it implies facilitating some sort of skill growth. Unlike automation interfaces that stay static, augmentative AI that helps you learn should also evolve with you.

[9:36](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=576s) This means some sort of skill visualization, showing people their growth, their growing expertise over time, and graduated complexity, right? Like unlocking or adapting features as competence increases or shifting explanation patterns based on a user's understanding over time.

[9:51](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=591s) The goal is generating skill enhancement, not just the illusion of it. Um, users should feel themselves getting better, um, at their core work and derive joy from self-improvement, even though it may be hard at first, not just more, being more dependent on AI.

[10:06](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=606s) Um, and a little note about, um, product metrics. If you truly care about your users, you should track how they're growing as they use your product beyond traditional engagement or usage metrics, even though they are important as well.

[10:18](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=618s) Um, I think a lot of learning apps, for example, focus on user retention and engagement, but are users actually improving themselves and getting more and more capable in real-life situations?

[10:27](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=627s) It's hard to say. So why does this matter? Beyond a normative argument that AI should serve to make people better, we have three main reasons. First, building an emotional connection.

[10:37](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=637s) AI products that make an effort to learn from users and fulfill intellectual needs build stickier relationships. ChatGPT's memory feature is a great example. People love feeling understood across multiple chat sessions.

[10:47](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=647s) Second, long-term value. Buyers increasingly care, uh, not just about productivity, but capability building. Um, can this tool make my team not just faster but better? Um, thirdly, as consumers, we should be more intentional about how we learn alongside these AI tools.

[11:02](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=662s) We are investing our precious time using them, so let's make sure we are growing, not just grinding.

[11:08](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=668s) As we come to the end of this talk, I'd just like to summarize what we have walked through so far. Um, technological revolutions have seemed to always been focused on efficiency.

[11:17](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=677s) For AI, though, um, I'm particularly excited because never had humanity advanced a piece of technology to a point where it can help us think better, amplify our intuition, taste, and creativity.

[11:29](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=689s) This may take the form of blind spot detection, cognitive partnerships, and proactive guidance. And to get there, we need to invest in better UX that enable high trust, thoughtful agency, and learn alongside users.

[11:40](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=700s) I think the most profound technologies don't just replace humans, they unlock what makes us uniquely human. The next decade won't be about AI doing our work, but AI helping us think in ways that we couldn't before.

[11:51](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=711s) What's transformative isn't just making us more productive, it's for making us more thoughtful and more aware of our cognitive patterns, like mirrors for our minds, showing us blind spots and suggesting perspectives that we habitually miss.

[12:03](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=723s) And no doubt, uh, we are still at the starting line of understanding how to build these systems. But the core insight that technology should enhance rather than replace human capability will remain true even as our understanding evolves.

[12:14](https://www.youtube.com/watch?v=0tVu-V3_fFw&t=734s) And the future belongs to interfaces that help us, uh, become more fully human, not less. With that, thank you for listening, and let's stay connected to continue our conversation.
