The plugin theatre
The side-bar button to have fast acces to the plugin
Tool settings screen!

ADHDeveloper - Hackathon Project Profile

Inspiration

Developers, especially those with ADHD, often struggle with the "infinite canvas" problem of modern AI tools. Current assistants are either too verbose, losing the user in walls of text, or too passive, failing to provide the structure needed for deep work. We were inspired to build a tool that doesn't just write code, but manages the developer's cognitive load, acting as a specialized task force that respects focus and mood.

What it does

ADHDeveloper is a comprehensive Agent Stage powered by the Model Context Protocol (MCP). It features:

Specialized Agent Workforce: 15+ dedicated agents (Debugger, Security Auditor, Mood Manager, etc.) that handle specific domains without cluttering the main conversation.
Mood-Aware Guidance: A unique mood agent that monitors developer focus and adjusts the interaction style (concise vs. detailed) to prevent burnout.
Cognitive Guardrails: Integrated focus-timer and planner tools that force tasks into small, achievable milestones.
Visual Orchestration: An IntelliJ plugin that provides a "Stage" UI, making background agent actions transparent and reducing the mental effort of tracking AI progress.
Instant Setup: A docker-first approach and an npx helper to bootstrap the entire ecosystem into VS Code, Cursor, or IntelliJ in seconds.

How we built it

Core: Node.js 22+ with the Model Context Protocol (SDK) for seamless tool/resource integration.
Backend: TypeScript-based architecture with a custom Agent Registry and Orchestrator pattern.
Frontend: An IntelliJ Platform plugin built with Kotlin, featuring a custom UI for the "Agent Stage" visualization.
Deployment: Dockerized server (imaandrw/mcp-app) for zero-dependency local execution.
Interoperability: Standardized JSON schemas via Zod for cross-client compatibility (Claude Code, Gemini CLI, Cursor).

Challenges we ran into

State Management: Maintaining a coherent "Mood" and "Focus" state across multiple stateless MCP tool calls required a creative use of session-based context caching.
Cross-IDE UX: Designing a UI that feels native to IntelliJ while the underlying logic is driven by a generic MCP server forced us to think deeply about abstraction layers.
Agent Noise: Early versions had agents "talking" over each other. We had to implement a strict Orchestrator pattern to ensure only high-signal information reaches the developer.

Accomplishments that we're proud of

1.1.0 Release: Successfully shipping a stable, Dockerized server with over 15 functional tools during the hackathon.
The "Stage" Concept: Moving away from the "chat bubble" paradigm into a visual performance where you see your agents working.
Integration Speed: Our npx adhdeveloper enable command makes what usually takes 20 minutes of config happen in 2 seconds.

What we learned

MCP is the Future: The protocol makes it incredibly easy to build "headless" capabilities that immediately work across every major AI editor.
Constraint is a Feature: For ADHD-friendly workflows, limiting the AI’s output is actually more technically challenging than letting it generate 1000 lines of code.
Developer Experience (DX) matters: Even the best AI tool fails if the setup is a hurdle. Docker + npx is the "Gold Standard" for hackathon delivery.

What's next for ADHDeveloper

Collaborative Stages: Allowing multiple developers to see the same "Agent Stage" in a shared session.
Voice Integration: Utilizing the ElevenLabs service (scaffolded) for audible "Focus Alerts" and mood check-ins.
Advanced Telemetry: Using local LLM logs to automatically predict when a developer is entering a "rabbit hole" and proactively suggesting a break.

Built With

api
bash
bash.-protocol:-model-context-protocol-(mcp-sdk).-server:-node.js-(v22+)
claude
codex
css-(vanilla)
cursor
docker
docker-hub
elevenlab
express.js
gemini
gemini-cli
gradle
gradle-(kotlin-dsl).-infrastructure:-docker
ide
intellij-idea
kotlin
mcp
mcp-standardized-tools.-compatibility:-claude-code
npx
npx-(for-global-bootstrapping).-apis:-elevenlabs-(ai-voice-synthesis)
openai
typescript
vs-code
zod
zod-(validation).-ide-integration:-intellij-platform-sdk

Submitted to

HackUPC 2026

Created by

ADHDeveloper was a hackathon project I worked on over approximately 48 hours with the Stardust Crusaders Hackers team. The idea was to build an AI-powered assistant for developers with ADHD. A TypeScript MCP server paired with an IntelliJ IDEA plugin where AI agents would literally "walk on stage" to present their work in a theatrical, gamified way.

This was one of my first times building a service based on the Model Context Protocol (MCP), a relatively new standard for connecting AI tools to external systems. A significant part of my work involved understanding how the SDK worked and figuring out how to structure a server around it.

I started by setting up the project skeleton. Dockerfile, package configuration, an initial Express server... and then refactored it to use the MCP SDK properly and introduce an agent orchestration system. The idea was to have a central flow manager that could dispatch different specialized agents (a planner, a debugger, a code reviewer, a security auditor, etc.), track their state, and emit events that the IntelliJ plugin could consume to render the visual presentation.

During the hackathon I built most of the MCP server's agents, each designed to handle a specific kind of developer task. I also built a language service to support multiple languages without having to duplicate that logic in every agent.

A big challenge was cross-platform compatibility. I had to iterate several times on how the server spawns child processes to make it work reliably on Windows, and the setup_project tool. Which generates MCP configuration files for six different AI coding tools simultaneously. This required understanding the subtle differences in how each tool (Claude Code, VS Code Copilot, Gemini CLI, JetBrains Junie, OpenAI Codex) expects its configuration.

Another significant learning curve was the transport layer. The server started on stdio transport, which meant the IntelliJ plugin had to spawn a new process for every request; and all in-memory state (agent registries, flow state) died between calls. I migrated it to HTTP/SSE so the plugin could connect to a persistent server process instead. For someone building this kind of always-on background service for the first time, understanding why that mattered and how to do it correctly took real effort.

I also paid a lot of attention to token efficiency, something that matters a lot in AI-heavy services. I introduced a keyed cache with TTL, a sliding window that summarizes older conversation steps to prevent unbounded context growth, and structured file diffs instead of sending full file contents between agents.

Toward the end I kept refining the Explainer agent, which summarizes what happened during an agent flow in a sarcastic, human-readable way. Getting the output to be genuinely varied and context-aware (rather than repetitive and generic) turned out to be more nuanced than it first appeared.

It was an intense and rewarding experience of building something I hadn't built before. A persistent AI backend service with a real protocol, multiple interacting agents, cross-platform concerns, and a live plugin consuming its output. Most of what I learned came from hitting problems I hadn't anticipated and working through them under time pressure.

Oriol Orbea
I built the IntelliJ "Agent Stage" plugin from the ground up, moving away from the traditional, text-heavy chat interface. My core contribution was designing and implementing the entire visual orchestration layer. I developed the Animation Engine and the Avatar Rendering system in Kotlin, giving each AI agent a distinct physical presence. This wasn't just an aesthetic choice; it was a strategic move to reduce cognitive load—by seeing which agent is "on stage" and active, developers can maintain focus without parsing through thousands of lines of terminal logs.

On the technical side, I engineered the MCP Bridge Service, a real-time communication layer that synchronizes the Node.js MCP server with the IntelliJ environment. This involved handling complex state management and newline-delimited JSON streams to ensure that when an agent triggers a tool in the background, the UI reacts instantly with visual feedback (like the TaskBubblePanel and status indicators I refined).

Ultimately, my work was about context and clarity. I transformed the abstract concept of "agentic workflows" into a tangible, immersive workspace. By building the stage, the seating layouts for the "audience" of agents, and the interactive UI components, I ensured that ADHDeveloper isn't just a tool that writes code, but a visual partner that respects and enhances the developer's mental flow.

Ernest Rull Turigas
Mi contribución principal se centró en el desarrollo del servidor MCP junto con Oriol, construyendo la capa de agentes especializados que forman el núcleo funcional de ADHDeveloper.
Implementé varios agentes clave del sistema, entre ellos el SmokeTester, encargado de ejecutar pruebas rápidas de validación sobre el código, y el agente de Kubernetes, que permite a los desarrolladores interactuar con sus clústeres directamente desde el entorno de trabajo. Cada agente fue diseñado para encapsular un dominio técnico específico, manteniendo la coherencia con el sistema de orquestación central.
Además de los agentes, desarrollé herramientas (tools) asociadas como Caveman, integrándolas dentro del protocolo MCP para que pudieran ser invocadas de forma coordinada por el flujo de agentes. Esto requirió entender en profundidad cómo el SDK de MCP gestiona el registro y la ejecución de herramientas, así como cómo estructurar las respuestas para que el plugin de IntelliJ pudiera consumirlas correctamente.
Por último, me encargué de dockerizar el servidor MCP, creando una imagen que permite desplegar el servicio de forma reproducible y portable en cualquier entorno. Esto fue especialmente relevante para garantizar que el backend funcionara de manera consistente independientemente de la máquina del desarrollador.

Andreea Cerchia
Kaleb Grove

Updates

Ernest Rull Turigas started this project — Apr 26, 2026 01:17 AM EDT

Leave feedback in the comments!

Log in or sign up for Devpost to join the conversation.