Gist is a JetBrains plugin that enhances efficiency by avoiding distractions and reducing switching-context cost time.
Inspiration
As developers, we have mainly inspired on our own experience, as well as on the sponsors talks and on professionals experiences. Being bothered when your are on a deep coding session or while you are thinking on a complex task, can be a great source of switching-context time costs. Another important source is having to deal with someone else's repository or even with an old repository of your own. Understanding what has been going on on a repository can be a high cost consuming task.
Based on this, we wanted to smooth out or reduce the time costs associated with context switching and increase developers productivity, allowing them to focus on what's important, on the Gist.
What it does
Gist has two main functionalities, both related with reducing time costs:
Dynamic Do Not Disturb (Slack integration)
It watches your coding activity in real time, dynamically setting your Slack status to Do Not Disturb or lifting it depending on the moment. This decision it taken by an Exponential Moving Average (EMA) that adapts de idle detection to the user based on their habits, their commits or their feedback. This allows the user to really focus and not allow messages to disturb their coding or working session.Catch Up (Git integration AI powered)
It summarizes you a period of commits on an easy and useful short text that quickly allows you to understand what has happened, when and where. Since your last commit on the repository or regarding the period of time you prefer, you will get an LLM produced summary with all the information you need to start coding.
How we built it
Starting from the IntelliJ Platform Plugin Template by JetBrains, we built the entire plugin in Kotlin, taking advantage of its interoperability with the IntelliJ Platform SDK.
The plugin is structured around a set of focused services, each owning a single responsibility, and two Swing-based tool window tabs exposed through MainToolWindowFactory.
Dynamic Do Not Disturb is powered by a small but carefully designed pipeline. ActivityService listens to editor events in real time and drives a CODING / IDLE state machine. When the state changes, it delegates to SlackService, which calls the Slack Web API to set or lift Do Not Disturb. The intelligence behind when to flip is based in an Exponential Moving Average over commit size and inter-commit interval, persisted across sessions as IntelliJ XML state by CommitProfileService. User feedback is handled by FeedbackService, which stores a correction multiplier that decays gradually so stale signals don't skew the model forever. Connecting to Slack required implementing a full OAuth 2.0 flow inside OAuthService, including spinning up a local callback server to receive the authorization code after browser redirect.
Catch Up is orchestrated by RepoSummaryService: it pulls the git log since the user's last commit using git4idea (IntelliJ's built-in Git API) via GitCommitService and LastCommitService, constructs an structured prompt from the real diff history, and sends it to an LLM through OpenAIService. The response — a grouped, thematic summary — is rendered in the LastCommitPanel tab.
Settings are exposed natively through the IDE's own settings UI via FlaskConfigurable and PluginSettings, so users can configure the plugin without leaving their IDE.
Challenges we ran into
Facing new challenges always brings different obstacles that you must work around. In this case, integrating two different APIs into the same plugin was a major setback that we worked hard to overcome. In addition, understanding how IntelliJ works and learning how to deal with its various components in order to build a functional plugin was quite tricky and messy.
Accomplishments that we're proud of
We are incredibly proud to have built a tool that speaks directly to the developer experience. We designed Gist having in mind the specific mental tax of context-switching that we face every day, ensuring it targets real pain points like notification distraction and the "fog" of returning to a repository after a break. Seeing the "Dynamic Do Not Disturb" successfully sync with a coding rhythm for the first time was a huge win; there is a unique satisfaction in building a solution to "scratch your own itch" and create something that aims to protect a developer's flow state.
What we learned
Building a plugin was a first-time experience for every team member that encouraged us to discover new tools. Expanding an IDE has been an incredible source of knowledge. As a result, the four of us have now a deeper understanding of how an integrated development environment works and expands itself. Moreover, this project was an ideal moment to try new API's such as the Slack API, Git4Idea or OpenAI.
What's next for Gist
Even though Gist is already running, everything can always be improved — and more importantly, expanded.
One of our clearest next steps is bringing Gist to more IDEs and editors. The core logic — adaptive idle detection, commit profiling, AI-powered summaries — is not inherently tied to JetBrains. Porting it to VS Code or other platforms would put these productivity gains in front of millions more developers with minimal rework, which speaks to the real leverage Gist can provide at scale.
On the feature side, we want to give users finer-grained control over their Do Not Disturb experience: for instance, allowing specific channels to always break through, so that a message from your tech lead or an on-call alert never gets silenced, or on the contrary, don't allow certain people messages to ever bother you while working. We also want to enrich the Catch Up summaries with more context so that returning to a repository feels even more effortless.
But perhaps the most exciting direction is taking Gist beyond software development altogether. The underlying idea — detecting deep focus through behavioral signals and protecting it automatically — is domain-agnostic. A musician recording a session, a student during an exam sprint, a designer in the middle of a creative flow: all of them face the same switching-context tax that Gist was built to solve. By abstracting the activity detection layer and opening it up as a more general platform, Gist could become a tool that empowers anyone doing deep, focused work — not just developers — to protect their attention without having to think about it.
The goal has always been to let people focus on what matters. We've started with code. We don't plan to stop there.
Log in or sign up for Devpost to join the conversation.