How to Integrate Bolt.new with IntelliJ IDEA

Before you can open your Bolt project in IntelliJ IDEA, you need to push it to a GitHub repository. Bolt.new has a built-in GitHub integration that makes this a one-time setup. Open your Bolt project and look for the Git icon in the left sidebar — it looks like a branching diagram. Click it to open the Git panel. If you have not connected GitHub yet, click 'Connect GitHub' and authorize Bolt.new to access your GitHub account through the OAuth flow. Once connected, click 'Create repository' and give it a meaningful name. Bolt will push all your project files to a new repository on your GitHub account. After the initial push, every significant change you make in Bolt can be committed and pushed from this same Git panel. You can type a commit message and click 'Commit & Push' to update the GitHub repository. IntelliJ will pull these changes in turn. This bidirectional sync means you can switch between Bolt for AI-assisted UI work and IntelliJ for backend development without manually copying files. Important: keep the repository name and structure stable — renaming or moving the repository after connecting it can break Bolt's sync. If you prefer not to use GitHub, you can also download the project as a ZIP file. Look for the download or export option in Bolt's Settings menu. The ZIP contains a complete project with package.json, all source files, and configuration. This approach is simpler for one-time exports but does not give you the bidirectional sync that GitHub provides.

Open IntelliJ IDEA on your local machine. On the Welcome screen, click 'Get from VCS' (Version Control System). If you have IntelliJ IDEA already open with a project, go to File → New → Project from Version Control. In the dialog that appears, select 'GitHub' from the left menu and sign in to your GitHub account if prompted — IntelliJ can authenticate via browser OAuth. Once authenticated, you will see a list of your repositories. Find the one you created from Bolt and click 'Clone.' IntelliJ will clone the repository to your local machine and attempt to detect the project type. For a Vite + React project (the most common Bolt output), IntelliJ will recognize the package.json and offer to configure the Node.js module. If you have IntelliJ IDEA Ultimate, it will also offer to set up the built-in web server and run configuration. Accept these suggestions. For IntelliJ IDEA Community Edition, you will need to open a terminal within IntelliJ (View → Tool Windows → Terminal) and run npm install to restore dependencies, then npm run dev to start the development server. At this point you have a full local development environment. The project runs identically to how it ran inside Bolt's WebContainer, but now you have access to IntelliJ's full suite of tools: the powerful find-and-replace across files (Ctrl+Shift+R), structural search, rename refactoring that updates all imports, the built-in Git log and blame view, and the debugger. If you have IntelliJ IDEA Ultimate, you also get the JavaScript/TypeScript debugger with breakpoints directly in your React components.

Bolt.new generates TypeScript projects using Vite or Next.js, and IntelliJ IDEA needs to know which Node.js runtime to use and how to interpret the TypeScript configuration. Navigate to File → Settings (Windows/Linux) or IntelliJ IDEA → Preferences (macOS). In the settings tree, expand Languages and Frameworks → JavaScript → Node.js. Use the Node Interpreter field to point IntelliJ to your local Node.js installation. If you have multiple Node.js versions, select the one matching your project's .nvmrc or the version specified in package.json's engines field. Next, verify that TypeScript support is configured. IntelliJ IDEA has built-in TypeScript support that reads your tsconfig.json automatically. Open the TypeScript service settings under Languages and Frameworks → TypeScript. Make sure 'Use TypeScript service' is enabled and the TypeScript package points to your project's node_modules/typescript (after running npm install). This ensures IntelliJ's type checking matches exactly what Vite or Next.js uses during build. For environment variables, Bolt projects use a .env file in the project root. In IntelliJ, you can view and edit this file directly in the Project panel. Create a .env.local file for your personal local overrides — this file should be listed in .gitignore so it is not committed to GitHub or visible to Bolt. Vite reads both .env and .env.local automatically. Add any API keys or local development values here. Remember: variables prefixed with VITE_ are exposed to client-side code; anything sensitive should only be accessed through server-side API routes. If you plan to add a Java or Kotlin backend to the project, create a new directory at the project root (e.g., backend/ or server/) and use File → New Module or File → New Project in Existing Directory to set up a Gradle or Maven project there. IntelliJ IDEA Ultimate includes Spring Initializr integration — go to File → New → Module → Spring Initializr to scaffold a new Spring Boot backend alongside your Bolt-generated frontend.

1// .env.local (never commit this file)
2// Vite project environment variables for local IntelliJ development
3VITE_API_BASE_URL=http://localhost:8080/api
4VITE_SUPABASE_URL=your_supabase_url_here
5VITE_SUPABASE_ANON_KEY=your_anon_key_here
6
7// tsconfig.json — verify this matches your Bolt project config
8// IntelliJ reads this automatically for type checking

IntelliJ IDEA offers its own AI coding assistant that can complement the work Bolt's Claude-powered agent started. To enable it, go to Settings → Plugins → Marketplace and search for 'AI Assistant' (the official JetBrains plugin). Install it and restart IntelliJ. After installation, you will see an AI chat icon in the right toolbar. Click it to open the AI Assistant panel. The IntelliJ AI Assistant understands the full codebase context — it can read all files in your project, not just the currently open file. This makes it particularly useful for tasks that benefit from whole-project understanding: 'Add error handling to all API calls in src/api/', 'Refactor this component to use React Query instead of manual fetch', or 'Explain what this Bolt-generated authentication flow does.' Unlike Bolt, IntelliJ's AI works entirely on local code and does not create new files autonomously — it suggests code changes that you review and apply. For Java/Kotlin development in the same project, the AI Assistant excels at generating Spring Boot controllers, Kotlin data classes from TypeScript interfaces, JPA entity definitions, and test cases. You can prompt it with: 'Generate a Spring Boot REST controller for the Product entity matching the TypeScript Product type in src/types/api.ts.' This creates a tight feedback loop between the Bolt-generated frontend types and the IntelliJ-developed backend. Note that IntelliJ AI Assistant requires a JetBrains AI subscription (separate from your Bolt subscription). The free tier provides limited completions monthly; the Pro plan offers unlimited completions. If you prefer a free alternative, the GitHub Copilot plugin for IntelliJ is also available and works well with Bolt-generated TypeScript code. One important workflow consideration: since Bolt uses WebContainers with JavaScript/TypeScript only, any Java or Kotlin code you write in IntelliJ cannot be run or previewed inside Bolt. The WebContainer cannot execute JVM bytecode. Keep your backend code in IntelliJ and your frontend code synchronized with Bolt via GitHub. This division of responsibility keeps each tool working within its strengths.

Once you have made improvements in IntelliJ — refactoring components, adding TypeScript types, writing utility functions, or building backend stubs — you will want those changes visible in Bolt for continued AI-assisted frontend work. The GitHub repository is the bridge for this synchronization. In IntelliJ, commit and push your changes using the Git integration: open the Commit panel (Ctrl+K on Windows/Linux, Cmd+K on macOS), review the changed files, write a descriptive commit message, and click 'Commit and Push.' IntelliJ will push the changes to your GitHub repository. Back in Bolt.new, open the Git panel and click 'Pull' to bring in the latest changes from GitHub. Bolt will update its WebContainer file system with your IntelliJ changes. You can then continue prompting Bolt's AI: 'I just added TypeScript interfaces in src/types/api.ts and API client functions in src/api/products.ts — now build the ProductList component that uses these.' Bolt's Claude agent will read the files you added in IntelliJ and build on top of them. This bidirectional workflow has one constraint to be aware of: Bolt's WebContainer has an ephemeral file system, meaning that changes you pull in from GitHub exist only for the duration of the current session. If you close the Bolt tab and return later, Bolt re-syncs from the GitHub repository automatically — so your IntelliJ changes persist as long as they are committed and pushed. Never rely on the WebContainer as a storage layer; always commit changes before closing either tool. For teams, establish a branch strategy: use main for stable code that both Bolt and IntelliJ track, and create feature branches for larger changes in IntelliJ that are not yet ready for Bolt's AI to build on. Bolt currently works best with the default branch, so merge feature work into main before switching back to Bolt-driven development.

1# .gitignore additions for a Bolt + IntelliJ project
2# IntelliJ IDEA files
3.idea/
4*.iml
5*.iws
6*.ipr
7out/
8
9# Node.js / Vite
10node_modules/
11dist/
12build/
13.env.local
14
15# Java / Kotlin backend
16backend/build/
17backend/.gradle/
18backend/target/