Designing AI To Scale Human Thought — Jun Yu Tan, Tusk

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.

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.

Now, it's often said that 2025 is the year of the agents, andrightfully so. 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.

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. 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. It's also easier to benchmark the completion of these tasks and quickly compare one system against another.

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. 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 as skills?

Are you sure you know what you're actually building? Many high-judgment domains like coding and design still require tight human supervision, relying on human experience and taste for approval. A lot of these are also like high-context tasks, where it's often difficult to just upload perfect contexts and encapsulate them in prompts for accurate judgment, since a lot of them, a lot of these like, live in the minds of experienced professionals anyway.

So the main thesis of this talk is this: instead of getting humans to accommodate to AI systems attempting to automate complex tasks and doing so suboptimally, why not spend that compute just helping humans produce high-quality work in the first place?

So in this talk, I'd like to introduce some ideas for augmentation-based UX. We'll look at interaction patterns for how AI can help users reveal blind spots, spark creativity, and amplify thoughtful decision-making. Some principles for designing AI products that emphasize and grow human capabilities, and trustworthy human-AI partnerships.

Let me make this concrete with a simple comparison. The automation approach to AI emails might look like this,right? The AI writes the entire email for you and sends it on your behalf. You're out of the loop, basically. The augmentation approach is a little bit different.

AI could help you brainstorm key points, for example, suggest alternative phrasings, check your tone. Maybe it says, "Hey, this might come across as a bit harsh. Do you want to soften it? Based on your past emails with this person, or your 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 to sign to it. 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 and a high load." 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.

And this table captures the fundamental shift in this mindset. In a nutshell, many differences 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.

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.

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.

The question for AI isn't "What did you do wrong," but "What didn't you consider as you're working on this task?" This could be temporal blind spots, like noticing you always make poor decisions when tired on a Friday afternoon, or social blind spots, flagging when your technical feedback might come across as personal criticism.

The key challenge is managing that signal-to-noise ratio, and nudging someone or challenging their thinking without making them feel defensive. Ideally, the AI should be designed in a way that reveals something at theright time when a unit of work can be assumed to be ready.

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 code-based test environment, and surface to you verified issues that 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 extra coverage against future regressions. One thing we try to help make reviewing these tests easier is also to surface any assumptions that a task is making, be it from a business or engineering standpoint, and also outline potential fixes.

Users can provide feedback by clicking thumbs up or thumbs down, or explain why it's something worth considering or not, so that a task learns from your review of its assumptions. I also like to call this "systematic pessimism." We're using AI to systematically look through every symbol that has been changed, finding what could go wrong, consider second-order effects in the call stack.

Even though this is something very tedious for humans to manually perform effectively, especially in larger, more complex code changes. With this pattern, we've helped enterprise and growth-stage companies like Deep Learning AI and TeamVPay catch verified bugs in 43% of pull requests and add almost 1,000 new tests in 2 months.

In the blind spot detection pattern, not all suggestions are created equal. I've been thinking about how we can manage noise with thoughtful UX. 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.

Things like race conditions that you have never encountered before, accidentally exposing customer data. These deserve to interrupt you. High novelty, low criticality, these are learning moments. Suggestions like alternative approaches, new language features, recognizing ineffective patterns. We might want to present this gently, as maybe as explainable suggestions.

Low novelty, high criticality, these are more of essential reminders. Things like common bugs, standard security checks, performance issues. We might help to give clear warnings and have a little bit more flexibility when it comes to interruption, but we don't have to over-explain 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 the nature. If you want to batch these, make them optional. The magic is in the prioritization, because people tend to only process 3 or more meaningful suggestions per review session.

This framework helps to spend the attention budget wisely. 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.

Do they learn through analogies? Do they prefer visual explanations? Do they prefer to slip on it, or prefer, like, rapid iteration? Imagine a code editor that learns your refactoring patterns and proactively suggests similar improvements in new contexts. Or a research assistant that understands whether you synthesize information chronologically or thematically.

The challenge here is building this personalization without being creepy. Users need to feel understood but not surveyed.

And the third pattern, proactive guidance, is probably the hardest to getright. The challenge isn't knowing what to suggest, but when. And great proactive guidance feels like serendipity, not interruption. 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're stuck and suggests taking a break rather than pushing through. And the key is finding that goldilocks zone. Right, we don't want to be too reactive. We also don't want to be too overwhelming.

Justright. Now let's shift gears into principles for designing augmentative AI, because without trust, none of this matters. So how do we build that trust in these augmentation systems? Trust becomes particularly crucial in augmentation interfaces because the relationship between human and AI is more collaborative than transactional.

Right, 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. I believe trust needs to be progressive, contextual, and bidirectional.

Progressive in the sense that it's easier to build trust with low-stakes suggestions before moving to high-impact decisions. Let a system prove itself on small things first. Trust is also contextual, 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 theright or sufficient context to make certain decisions. So let's make that transparent. 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. For AI to augment us, it implies facilitating some sort of skill growth. Like automation interfaces that stay static, augmentative AI that helps you learn should also evolve with you.

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. The goal is genuine skill enhancement, not just the illusion of it.

Users should feel themselves getting better 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.

And a little note about 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. 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?

It's hard to say. So why does this matter? Beyond a normative argument that AI should serve to make people better, there are three main reasons. First, building an emotional connection. 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. Second, long-term value. Buyers increasingly care not just about productivity but capability building. "Can this tool make my team not just faster, but better?" Thirdly, as consumers, we should be more intentional about how we learn alongside these AI tools.

We're investing our precious time using them, so let's make sure we're growing, not just grinding. And as we come to the end of this talk, I'd just like to summarize what we have walked through so far. Technological revolutions have seemed to always have been focused on efficiency.

For AI, though, I'm particularly excited because we've never had humanity advance a piece of technology to a point where it can help us think better, amplify our intuition, taste, and creativity. 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. 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.

What's transformative isn't just making us more productive. It's about 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. And no doubt, 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. And the future belongs to interfaces that help us become more truly human, not less. With that, thank you for listening, and let's stay connected to continue the conversation.