Introduction

Hackathons are powerful catalysts for innovation, especially when focused on the rapidly evolving landscape of AI within Integrated Development Environments (IDEs). The first JetBrains Codex Hackathon in San Francisco demonstrated this perfectly: 39 projects built over a weekend, six finalists, and a clear signal that developers are eager to push AI beyond simple copilots into sophisticated, trustworthy workflows. If you’re inspired to organize your own IDE-native AI hackathon, this guide will walk you through the essential steps, from planning to execution, based on lessons learned from that landmark event.

What You Need

• Venue: A physical space (like a co-working space or office) with reliable Wi-Fi, power outlets, and collaboration areas. Minimum capacity for 50–100 participants.
• Hardware: Laptops or workstations for each participant (or BYOD policy). Projector/screen for demos.
• Software & APIs: Access to an IDE platform – the IntelliJ Platform SDK (for JetBrains-style plugins), VS Code extensions, or similar. AI model APIs (e.g., OpenAI, Claude, local models). Version control and collaboration tools (Git, GitHub, Slack).
• Participants: A mix of developers, designers, and AI enthusiasts. Aim for 40–100 active participants. Include experienced judges from industry.
• Time: A contiguous weekend (typically Saturday–Sunday, 24–48 hours).
• Prizes & Incentives: Awards for top projects, swag, and potential integration opportunities (e.g., with the IDE platform).
• Support Staff: Organizers, mentors (especially those familiar with the SDK), and volunteers for logistics.

Step-by-Step Guide

Step 1: Define Your Theme and Goals

Every successful hackathon starts with a clear focus. The JetBrains Codex Hackathon centered on IDE-native AI – building agents, copilots, and tools that live inside the development environment. Decide what problem you want to solve: is it improving code review, generating tests, or giving developers deeper visibility into AI reasoning? Write a concise theme statement, e.g., “Build AI-powered plugins that make development safer and faster inside the IDE.” This will attract the right participants and guide judging criteria.

Step 2: Recruit Participants and Judges

Open a call for applications. For the JetBrains event, 443 developers applied, resulting in 39 completed projects – a strong conversion suggests careful selection. Look for participants with experience in IDE plugin development (e.g., IntelliJ Platform SDK) and AI/ML skills. Encourage solo builders as well as teams (the original hackathon had two solo finalists). For judges, invite leading technologists who can evaluate technical merit, creativity, and real-world impact. Make sure judges understand that visibility and guardrails matter as much as raw speed.

Step 3: Set Up the Technical Environment

Pre-requisite for participants: have a working development environment with the chosen IDE (e.g., IntelliJ IDEA Community Edition) and the corresponding SDK (IntelliJ Platform SDK). Provide clear documentation and starter templates. For AI access, arrange API keys or local model endpoints. Set up a shared repository for projects and a communication channel (Slack). Consider providing a cloud-based IDE environment if hardware is limited. On the day of the hackathon, run a brief orientation to ensure everyone can build and test their extensions.

Step 4: Run the Hackathon – Weekend Execution

Start on Saturday morning with an opening session: reiterate the theme, introduce mentors, and explain the schedule (e.g., 24-hour building time, followed by demos). Let teams form or individuals work solo. Provide regular check-ins (e.g., at 6-hour intervals) to offer guidance and keep momentum. The JetBrains event had a “live demo” period where finalists presented. Ensure participants know they must produce a working prototype, not just a slide deck. Throughout the weekend, encourage collaboration – some of the best projects emerged from teams mixing plugin expertise with AI knowledge.

Step 5: Evaluate Projects – Criteria Beyond Speed

At the end of the building phase, hold a demo session. Each team gets 5 minutes to show their project. Judges should look for: visibility (can developers see what the AI is doing?), guardrails (how does it prevent errors?), correctness (does the output make sense?), and trust (when should a developer trust the AI?). The winning project from JetBrains, hyperreasoning, was a solo build that decided which reasoning paths to explore before generating code – it prioritized deliberation over speed. Evaluate projects on innovation, technical implementation, and potential to become a real product.

Step 6: Showcase and Follow-Up

Announce winners and finalists. Offer prizes and, importantly, a path forward – like featuring their work on your blog (as JetBrains did) or providing mentorship for integration. Two of the finalists were solo builders, so highlight that solo efforts can win. Record the demos and share them with the community. After the event, write follow-up blog posts (like the promised ‘spotlights’) to maintain momentum. Consider turning a winning project into a supported plugin or tool – this reinforces the message that hackathons are not just for fun but for building the future.

Tips for a Standout Hackathon

• Embrace solo builders – don't force teams. The best ideas often come from individuals with deep conviction.
• Prioritize platform-native tools – encourage participants to build directly against the IDE's SDK (e.g., IntelliJ Platform) rather than as external wrappers. This creates tighter integration and more lasting impact.
• Educate judges on what matters – speed makes good demos, but projects that build toward correctness, safety, context, and review have lasting value. Give judges a rubric that emphasizes these qualities.
• Plan for follow-up – a hackathon’s energy fades quickly if you don’t keep the conversation going. Publish detailed write-ups, offer integration paths, and consider a mini-grant for the most promising projects.
• Keep it focused – a narrow theme (“IDE-native AI agents”) yields deeper work than a broad one (“AI in software”).