Jules is Google's answer to the question everyone in developer tooling is trying to solve: can an AI actually fix your GitHub issues without you babysitting it?
The short answer: yes, sometimes, and it's getting better. Here's what you need to know before spending time integrating it into your workflow.
What Jules actually is
Jules is an asynchronous AI coding agent built by Google DeepMind. Unlike Cursor or Claude Code which work in real-time as you type, Jules works in the background. You assign it a GitHub issue or task, it reads the codebase, makes changes, and opens a pull request. You review the PR when it's done.
That async model matters. Jules isn't meant to pair-program with you — it's meant to run overnight, fix a backlog of small issues, and come back with PRs to review in the morning.
It's built on Gemini and integrates directly with GitHub. The integration is native: Jules comments on issues, pushes branches, opens PRs, and responds to PR feedback.
What Jules is good at
After extended testing, Jules performs consistently well on:
Well-defined bug fixes. If an issue has a clear description, a stack trace, and a reproduction case, Jules can often fix it without further guidance. "TypeError: Cannot read property 'x' of undefined in UserProfile.tsx line 47" — Jules will trace the null path, add a guard, and handle the fix.
Documentation updates. Adding or updating docstrings, updating README files, adding inline comments. Jules is reliable here because the feedback signal is clear and the impact of errors is low.
Dependency updates. Bumping a package version and fixing the downstream breakages across the codebase. Jules handles this well because it can read the diff from the package changelog and trace the affected call sites.
Small feature additions defined by specification. "Add an email validation regex to the signup form" or "Add a loading state to the Submit button" — Jules can implement these if the spec is unambiguous.
What Jules struggles with
Ambiguous requirements. Jules doesn't ask clarifying questions (at least in current versions). If your issue says "improve the user experience on the checkout page", Jules will make a change, but it might not be what you meant. Specificity in your issue description is not optional.
Architectural decisions. Jules follows existing patterns — it won't refactor your state management or propose a better data model. If the underlying code is poorly structured, Jules's fix will be, too.
Large-scale changes. Jules works best on changes that touch fewer than ~10 files. For a major refactor spanning the whole codebase, it gets confused and produces noisy PRs that are hard to review.
Security-sensitive code. Jules doesn't have specialized security training. For auth, cryptography, or anything touching sensitive data handling, review Jules's output with extra scrutiny — or don't use it at all.
How to write GitHub issues for Jules
The difference between a good Jules issue and a bad one is the difference between a useful PR and a confusing one.
Structure your issues like this:
## Problem
[Describe the bug or missing feature precisely]
## Context
[File path, function name, line range where the change should happen]
## Expected behavior
[What should happen]
## Current behavior
[What actually happens, including error messages or stack traces]
## Constraints
[Things Jules should NOT do: don't change the public API,
don't add new dependencies, etc.]
The "Constraints" section is underused. Jules will take the shortest path to fixing something, which sometimes involves changes you don't want. Explicitly ruling out those paths upfront saves you PR review time.
Jules vs Claude Code vs Cursor
These tools are genuinely complementary:
| Tool | Mode | Best for |
|---|---|---|
| Jules | Async, unattended | Backlog of well-defined issues |
| Claude Code | Terminal, interactive | Complex reasoning, exploratory work |
| Cursor | In-editor, real-time | Feature development, active coding |
I use them in sequence: Jules for the backlog of well-defined issues, Claude Code for anything that needs back-and-forth reasoning, Cursor for feature development where I want AI alongside my typing.
Getting started
Jules is available through Google Labs. Connect it to your GitHub account, give it access to a repository, and assign it an issue. It will comment when it's working on the task and when the PR is ready.
For teams, the PR review workflow is the key integration point. Jules opens a PR, your team reviews it like any other PR. The bar for merging Jules PRs should be the same as any external contributor — read the diff, don't just approve.
The right mental model
Jules is a junior developer who works while you sleep. They're solid on well-defined tasks, struggle with ambiguity, and need clear specs. The better you write the issue, the better the output.
For more on autonomous coding agents and when to use them, see our AI agents track.
