Don't just slap on a chatbot: building AI that works before you ask

While working with Tegon on their open-source issue tracker, we dealt with the issue of useful AI implementation. The question wasn’t just how to add AI features–it was how to make AI actually useful rather than just… there. However, the standard approach, where users must explicitly ask for help through a chat interface, creates unnecessary friction and misses countless opportunities to provide value at crucial moments.

Irina Nazarova CEO at Evil Martians

Schedule call

“Too legit to clip”: channeling the spirit of Clippy

Funnily enough, the solution we’re looking for has been hiding in plain sight, right there within the annals of digital history. Remember Microsoft’s Clippy? While its implementation was ultimately flawed, its core vision was revolutionary: a virtual assistant that could understand context and offer relevant help without being asked.

Yet, instead of leaning into this vision, we’ve actually regressed: most modern AI assistants are purely reactive, waiting for explicit commands rather than proactively engaging with user context.

However, modern technologies now allow us to truly and properly realize the dream of Clippy–but we’ll need to shift our thinking back to proactive assistance.

Shifting the paradigm back to proactive AI

Although I haven’t explicitly thought of Clippy while working on Tegon, the similarity of these two concepts became quite obvious when I reflected on the project.

We designed an AI agent that predicts user needs and offers contextual help exactly when it’s needed. Instead of waiting for user prompts, our AI can proactively recognize opportunities to provide valuable guidance!

The solution I designed works in three distinct modes, each addressing different aspects of the issue creation process: suggestion mode, action mode, and question + action mode. Let’s explore them:

1. Suggestion mode: smart context detection

With Tegon, when a user starts writing an issue, the AI assistant actively monitors the content and provides contextual suggestions. Importantly, unlike generic spell-checkers, it also looks for opportunities to improve clarity and provide relevant references.

For example, the AI might detect some missing details (or even more proactively, some possible additions) to an issue, prompting the user like in the following examples:

• This issue lacks the criteria for acceptance-would you like to add that?
• You’ve mentioned the implementation details but haven’t described the user-facing impact. Should we expand on that?
• Similar issues already exist around this topic-would you like to reference them for additional context?

This is simple enough, but the key innovation here is the timing–the suggestions appear as the user writes, in a way that maintains their work flow while improving the overall quality issue. This approach starkly contrasts to the traditional approach of flagging issues after the fact!

So that’s probably conceptually clear enough, but how does it work?

The AI agent uses a hidden prompt that continuously monitors an issue’s
content. As the user types, the agent evaluates the changes while waiting for the right moment to provide valuable suggestions. Critically, by keeping track of the full context, the AI can make contextually-relevant recommendations without disrupting the user’s workflow. This is similar to how Clippy used to jump in when it detected someone writing a letter, only multiplied by several orders via today’s tech.

2. Action mode: breaking down complexity

Sometimes users know what they want to do but struggle to actually structure the issue. Imagine you want to achieve a big milestone or release a big feature: you have all the data needed, but it’s inside the one huge issue, and things are so tangled that you have no idea how to properly split it into sub-issues or deliverable milestones. And here comes our AI agent: it helps break down complex tasks into manageable sub-tasks, making the process more approachable.

Even taken alone, this is, by all accounts, a big boon for user productivity. However, the interesting thing to note is how the AI agent actually accomplishes this:

1. It analyzes the user’s description to identify potential sub-tasks
2. It suggests logical groupings and dependencies between the sub-tasks
3. It provides effort estimates for each sub-task component

Breaking down complex tasks in this way goes beyond simply splitting text-rather, the AI demonstrates an understanding of the underlying work structure and helps the user create better-organized, actionable issues. (Of course, this approach is versatile and applicable for many applications).

3. Question + action Mode: resource planning

Now comes the most sophisticated mode; it combines AI suggestions with active questioning to assist with resource allocation and timeline planning. For example:

• Based on similar tasks our team has completed, this typically takes 2-3 sprints to implement.
• Would you like me to suggest team members with relevant experience to assign to this issue?
• These dependencies on the UI design and backend API might affect your production timeline-would you like me to walk through the implications?

Now, with this kind of implementation, we’re really getting into proactive territory. Importantly on that note, these interactions happen within the natural flow of issue creation, not as a separate conversational flow. We end up with an AI that is proactively providing valuable planning support, right as users need it most.

If you’re worried that this could easily go wrong, don’t be. As with every mode, users have the final say through ‘Apply changes’ or ‘Revert’ options. This way, the AI is just an advisor, not an autonomous decision maker. We’re interested in creating a useful solution, not some Clippy-Skynet hybrid.

How startups can adopt this active approach

The multi-modal approach presented above allows the AI to guide users through the issue creation process in a seamless, context-aware manner. Further, users do not need to explicitly seek out help or waste precious time formulating requests, and ultimately, as the AI agent has their back, users are empowered to create higher-quality, better-structured issues.

This is great in the world of issue creation, but these patterns can be powerful across many professional tools. So, more specifically, let’s ask: what are the principles we can follow to foster this sort of “proactive AI”?

• AI should supplement user agency-but it should not replace it. This means it should recognize when to offer suggestions (versus waiting for user promps).
• Never force AI recommendations, rather, present them as helpful
  options users can choose to accept or reject.
• As hopefully hammered home above, focus on integrating proactive AI within the user’s natural workflow, not as a separate conversational interface

And to get even more practical, let’s note cases where applying these principles might be useful for your project:

• Code editors can be enhanced with AI that proactively watches for common pitfalls and suggests improvements. This is particularly valuable for developers just learning a new language or framework.

• In terms of design tools, imagine a system that doesn’t just wait for you to ask for help, but actively suggests UI improvements, highlights potential accessibility issues, and guides iterative refinement from the earliest stages of design.

• Documentation tools and editors could anticipate missing sections, suggest relevant examples, and help maintain consistency across large codebases.

• In the terms of communication tech, AI can go beyond transcription and provide real-time context during video calls, pull up relevant documents, and keep teams aligned.

• Project management systems perhaps hold the most immediate potential! Here, proactive AI can transform how teams handle resource allocation and timeline planning by: surfacing relevant historical data; identifying potential bottlenecks before they occur; and suggesting optimal team configurations based on past project success patterns.

We’ve already seeing early implementations for some of these ideas, and that’s cool, and we’re only scratching the surface of what’s possible when we move beyond reactive AI interfaces!

Clipping into the next dimension

At the time of writing, AI interface design is still just beginning to take shape. That means we don’t have a fully-formed playbook of best practices just yet, but simply copying and pasting AI chat interfaces isn’t the answer.

Don’t be afraid to experiment in your products, challenge the status quo, and propose unexpected UI solutions. Finally, let’s give the chat interface a bit of due respect because it really opened the door of possibility. Now it’s time to step through and explore.