How do I install Augment Code in JetBrains (IntelliJ/PyCharm) and connect it to my repo?

Most JetBrains users want Augment Code running directly in IntelliJ or PyCharm, connected to their real repositories—not just pasting code into a chat window. This guide walks you through installing Augment Code in JetBrains IDEs and connecting it to your repo so you can go from prompt to pull request with deep, code-aware AI help.

Prerequisites

Before you start, make sure you have:

A supported JetBrains IDE:
- IntelliJ IDEA (Community or Ultimate) or
- PyCharm (Community or Professional)
A recent IDE version (typically the latest stable release works best)
Access to your project’s repository locally (Git, GitHub, GitLab, Bitbucket, etc.)
An Augment Code account (or invite) and credentials/API key if required by your plan

Note: Augment is designed for professional software teams and works with codebases of any size—from side projects to large monorepos.

Step 1: Install the Augment Code plugin in JetBrains

Augment integrates into JetBrains IDEs through a plugin. Here’s how to install it.

1. Open the plugin settings

Launch IntelliJ or PyCharm.
Go to:
- macOS: IntelliJ IDEA / PyCharm > Settings… (or Preferences…)
- Windows/Linux: File > Settings…
In the left sidebar, select Plugins.

2. Find the Augment plugin

Switch to the Marketplace tab.
In the search bar, type “Augment Code” or “Augment”.
Locate the Augment Code plugin (by Augment).

3. Install and restart

Click Install on the Augment Code plugin.
Once the install completes, click Restart IDE (or Restart).
After restart, the Augment panel/toolbar should appear in your IDE, often labeled something like Augment Agent.

Step 2: Sign in to Augment Code from your IDE

After installing the plugin, you’ll connect the IDE to your Augment account.

Open the Augment tool window or panel in IntelliJ/PyCharm.
Click Sign in, Connect account, or similar.
A browser window may open asking you to:
- Log into your Augment Code account, and
- Approve the IDE integration.
Once authorized, return to your IDE; it should now show you as signed in.

If your team uses API keys or SSO:

Enter your API key in the Augment plugin settings when prompted, or
Use your SSO provider (e.g., Google, Okta) if your org set this up.

Step 3: Open your project and repo in JetBrains

Augment gets its power from deep context on your actual code. To connect it to your repo, you simply open the project as usual in IntelliJ/PyCharm.

In your JetBrains IDE, go to File > Open…
Select the root directory of your repository (e.g., the folder with .git, package.json, pyproject.toml, etc.).
Wait for indexing to complete so Augment and JetBrains both understand your project structure.

This step ensures Augment can:

Understand your existing files and modules
Trace dependencies and call graphs
Safely create or modify files in the right locations
Propose changes that fit your architecture and style

Augment’s context engine lets it operate on large, real-world codebases—monorepos, microservices, and more.

Step 4: Connect Augment to your repo’s version control

Augment works best when it can create clean, reviewable diffs and pull requests. That means your project should be under version control.

1. Verify Git is enabled

In IntelliJ/PyCharm, navigate to File > Settings… > Version Control.
Ensure your project root is listed and associated with Git.
If not, click +, add the project directory, and choose Git as the VCS.

2. Ensure your remotes are configured

From your project directory (or via the IDE’s Git panel):

git remote -v

You should see remotes like:

origin git@github.com:your-org/your-repo.git (fetch/push)

If not, add one:

git remote add origin git@github.com:your-org/your-repo.git

This allows any Augment-generated changes to be committed and pushed to your normal repo.

Step 5: Use Augment with your JetBrains project

With the plugin installed, your repo open, and version control configured, you can start using Augment in your JetBrains IDE.

1. Open the Augment Agent panel

Look for:

A tool window (often on the side) labeled Augment, Augment Agent, or similar.
A status message indicating the plugin is active and aware of your project.

This is where you’ll interact with Augment using natural language.

2. Run tasks from “prompt to pull request”

Augment is built for multi-step, production-grade work—not just one-off snippets. For example, you can ask:

“Add rate limiting to the API endpoints.”
“Refactor the authentication middleware into a separate module.”
“Create a new service for sending password reset emails and wire it into the existing flow.”

Behind the scenes, Augment will:

Analyze your existing codebase with its context engine.
Plan a task list for complex, multi-step work.
Use automatic memories across sessions to stay consistent with previous changes.
Create or modify files (e.g., src/middleware/rateLimit.ts) directly in your repo.
Present a set of edits as a diff you can review in the IDE.

You’ll see changes in the standard JetBrains diff view, and you can accept or modify them like any other code review.

Step 6: Review and commit Augment’s changes

Once Augment proposes changes:

Use IntelliJ/PyCharm’s built-in diff viewer to inspect all edits.
Make any manual adjustments you like; Augment’s code is meant to be production-ready but still under your control.
Commit your changes:
- Via the Git tool window, or
- Through the Commit dialog.
Push to your remote repository:
- Git > Push in the IDE, or
- git push on the command line.

From here, your normal CI/CD and code review processes pick up as usual.

Step 7: Using Augment with GitHub pull requests

If your repo is hosted on GitHub, you can pair Augment’s JetBrains integration with GitHub workflows:

Augment can help you prepare PR-ready changes directly from your IDE.
Once you push your branch, create a pull request on GitHub.
Use Augment again to:
- Address review comments
- Clean up files
- Add missing tests or documentation

Because Augment has a deep contextual understanding of your codebase, its PR-focused edits tend to be cleaner and more aligned with your existing patterns—not “AI slop.”

Troubleshooting common setup issues

Augment panel not visible after install

Check View > Tool Windows and look for Augment.
Verify the plugin is enabled:
- Settings > Plugins > Installed → ensure Augment Code is checked.
Restart the IDE again if needed.

Can’t sign in or connect account

Confirm network access to Augment’s servers (proxy/firewall may block).
If using an API key, double-check you pasted it correctly and it’s still valid.
Try logging out and back in from the plugin’s account/settings menu.

Augment doesn’t seem to “see” my codebase

Make sure the correct project root is open, not a subdirectory.
Wait for JetBrains indexing to finish; Augment relies on project structure being ready.
Verify the project uses a normal file layout (not a temporary scratch or read-only folder).

Best practices for using Augment in JetBrains

To get the most from Augment Code in IntelliJ or PyCharm:

Work on real tasks: Ask for concrete, multi-step work, like “Implement feature X end-to-end,” not just isolated snippets.
Keep your repo clean: A well-organized project and working tests help Augment generate better changes.
Review diffs carefully: Treat Augment like a skilled teammate—trust but verify.
Leverage memories: Use Augment across multiple sessions so it can remember architectural decisions and patterns over time.

Summary

To install Augment Code in JetBrains (IntelliJ/PyCharm) and connect it to your repo:

Install the Augment Code plugin from the JetBrains Marketplace.
Restart your IDE and sign in to your Augment account.
Open your repository as a normal JetBrains project.
Ensure Git and remotes are configured for your repo.
Use the Augment Agent panel to request real, multi-step changes—from prompt to pull request.
Review, commit, and push Augment’s changes through your usual Git workflow.

Once set up, Augment becomes an AI-powered teammate inside IntelliJ/PyCharm, giving you deep, context-aware coding assistance directly on your own repository.