How to Use Google Jules: The Beginner's Guide (First Task to First Pull Request)

CodexFuse Team · 2026-10-28T16:41:24.999Z · 15 min read

Learning how to use Google Jules is the fastest way to clear the coding backlog you keep putting off. Jules is Google's asynchronous AI coding agent: you describe a task in plain English, it clones your GitHub repository into a secure cloud virtual machine, writes a plan, makes the changes, and opens a pull request for you to review. You never watch it type, and nothing merges without your approval. This guide walks you through the whole first-task flow — signing in, connecting a repository, writing a task Jules can actually execute, reviewing the plan, and merging the pull request — plus the free and paid limits, the terminal route, and the honest limits.

What is Google Jules?

Google Jules is an asynchronous AI coding agent from Google that turns a plain-English task into a GitHub pull request. You assign the work, Jules clones your repository into an isolated Google Cloud VM, writes a step-by-step plan, executes it, runs the tests, and opens a PR. You review the diff and merge — or ask for changes — exactly as you would with a teammate's code. In short, the Jules AI coding agent is a background teammate that works in pull requests instead of chat windows.

Jules started as a Google Labs experiment in December 2024, opened to public beta at Google I/O on May 20, 2025, and exited beta on August 6, 2025. That history matters because Jules is not new anymore — it is a generally available product, and the freshness is in its I/O 2026 refresh, not the launch.

What Jules is not matters just as much. It is not an autocomplete tool, not a chat assistant, and not an editor plugin. It does not run inside VS Code or JetBrains, and there is no live back-and-forth while it works. If you want an agent that sits in your editor and collaborates in real time, that is a different tool — this guide is about the async one. You will need a GitHub repository to point it at; if you have never set one up, our GitHub beginner guide covers the first repository, first push, and first pull request.

How does Google Jules work?

Jules follows a plan-execute-review loop, and every step is visible to you. First you assign a task through the web app, the CLI, or a labeled GitHub issue. Jules clones the entire repository into a fresh Google Cloud VM, reads the folder structure, checks dependencies, and understands your naming conventions before writing a single line.

Then it writes a step-by-step plan. This is the part that makes Jules different from a fire-and-forget tool: you can review, edit, or reject the plan before any code is written, and you can keep editing it during and after execution. Only after you approve does Jules execute — making multi-file changes, running the existing tests, and fixing errors it finds. The VM has network access, so it can install dependencies and run build tooling.

When the work is done, Jules pushes to a branch and opens a pull request against your branch, with a description, a diff, and a change summary. The Jules GitHub integration is what makes this whole flow work: it reads issues, creates branches, authors commits, and opens PRs as a first-class GitHub citizen, not a wrapper. Your existing CI pipeline runs against it. A 2026 update closed the loop further: if CI fails on a Jules-authored PR, Jules receives the error, analyzes it, applies a fix, and re-pushes — often without any human intervention. As of the I/O 2026 refresh, Jules works with a 2M-token context window, so it can reason across large codebases without truncation. Planning and hard reasoning run on Gemini Pro, with lighter subtasks handed to Gemini Flash.

What do you need before your first task?

You need three things: a Google account, a GitHub repository, and to be 18 or older. Jules requires users to be 18+, which is stricter than some Google plans — a shared family plan does not grant access to under-18 members.

• A Google account. Sign in at jules.google.com. No new account to create and no software to install — Jules runs entirely in the browser and works the same on Windows, Mac, and Linux.
• A GitHub repository. Connect it by installing the Jules GitHub App and authorizing repository access. You can grant access to all repositories or only specific ones — selective access is the right choice for a first task.
• A small, well-scoped first task. Pick something with a clear finish line: a bug with a reproduction, missing tests for one module, or a dependency bump. Save the open-ended redesign for later.

One setup step pays for itself on every later task: add an AGENTS.md file to the root of your repository describing the project, key folders, and coding conventions. Jules reads it as a reference every single time, so its changes follow your existing style instead of inventing a new one. If your repository already has an Environment Snapshot — a saved bundle of dependencies, install scripts, and environment variables — Jules reuses it for faster and more consistent setup.

How do I use Google Jules for the first time?

Follow these seven steps, in order, and your first task will take under ten minutes to set up.

1. Sign in at jules.google.com with your Google account. You land on the Jules dashboard, where all your tasks and their statuses appear.
2. Connect a repository. Click Connect Repository and authorize the Jules GitHub App. Limit access to the one repository you want to test with.
3. Save an Environment Snapshot if Jules offers one for your repo, so it does not reinstall dependencies from scratch on every task.
4. Write your first task in plain English. Name the file, describe the problem, and state what done looks like. A good first task is "write unit tests for the auth module" or "fix the flaky test in the payments folder."
5. Read the plan Jules writes before any code changes. If something looks off, type your feedback inline — Jules revises the plan before starting. Approve only when you are genuinely satisfied.
6. Wait for the pull request. Jules clones the repo, executes the plan, and runs the tests in its cloud VM. You get a notification when it is done, so you can close the tab and come back later.
7. Review the pull request like a teammate's. Open it, read the diff, run your tests locally, leave comments on specific lines, and merge when you are satisfied — or request changes. Jules never pushes directly to your main branch.

That last point is the whole safety model. The plan review is your first line of defense, and the pull request review is your second. Nothing lands in your codebase without passing both.

How do I write a task Jules actually gets right?

Write it like a good ticket, not like a chat message. The quality of Jules output depends directly on the quality of your prompt, and a strong prompt has four ingredients: the file name, the error description, the expected outcome, and the scenario context.

Compare the two. A weak prompt: "fix the login bug." A strong prompt: "The login function in auth.js throws a TypeError when the email field is left empty. Fix the validation to handle empty strings and null values before the API call, and show an error message for both cases." The strong version tells Jules where to look, what is broken, and what done means — and it still fits in two sentences.

The same rule applies at the task level. Jules excels when the unit of work maps to a ticket, and the honest rule of thumb is: if you could write a solid Jira ticket for it, Jules can probably do it.

Scope the task tightly and name what Jules must not touch. "Fix the race condition in payment/processor.go — two concurrent requests can double-charge. Add regression tests covering the concurrent case" gives Jules a target, a constraint, and a test. "Make the app better" gives it none of those.

How do I review a Jules pull request?

Review it exactly as you would review a human teammate's pull request, because the failure modes are the same. Start with the change summary Jules wrote — it tells you what changed and why, so the review is fast — then read the diff line by line. Check that the changes stay inside the scope you assigned, and look for anything that touches security, data migrations, or user-visible behavior.

Then verify independently. Pull the branch locally, run the repository's test suite, and run the app yourself. Jules validates its work against your tests, which means a codebase with thin test coverage leaves you exposed to unknown unknowns — the agent cannot catch what no test checks. If CI fails on the PR, Jules will usually pick up the failure and push a fix on its own; still read the fix before merging.

Leave feedback as comments on specific lines, just like any code review, and Jules will revise. Merge only the reviewed changes you intend to keep, and only after your own checks pass. The merge button is always yours — Jules cannot merge its own pull requests.

How much does Google Jules cost?

Jules pricing is simple because there is no standalone subscription to buy: paid access is bundled into Google's AI subscriptions. The Jules free tier is genuinely usable on its own — it gives you 15 tasks per rolling 24 hours and 3 concurrent tasks, powered by Gemini 2.5 Pro. Paid tiers raise the limits and give priority access to Gemini 3 Pro.

Two caveats before you budget on these numbers. First, the limits have moved during 2026 — a March 2026 comparison listed the Pro tier at roughly 75 tasks a day, while the July and August 2026 checks both list 100 — so confirm the numbers shown for your own account before upgrading. Second, paid Jules upgrades are currently tied to eligible personal Google Accounts ending in @gmail.com; Google says Workspace and enterprise upgrade paths are coming, and Google localizes the Google AI subscription price by country, so the amount you see may differ from the US figures above. The CLI costs nothing extra: usage follows the Jules plan attached to your Google account.

Jules vs Claude Code vs Copilot vs Codex: which one fits?

The real split is async versus interactive. Jules and Codex work asynchronously and deliver pull requests; Claude Code and Copilot work with you in real time, in your editor or terminal. The two comparisons readers ask about most are Jules vs Claude Code and Jules vs Copilot, so the table below covers both, plus Codex. Neither pattern is better in general — the right one depends on whether you want to delegate a ticket or collaborate on a change.

Jules is the right pick for batch work: a backlog of small bug fixes, test writing, and dependency bumps that you assign in a batch and review when you have time. For complex multi-file changes where you need to collaborate in real time, an interactive agent fits better — our Claude Code beginner guide covers that workflow. If you prefer to stay inside the editor, the Cursor beginner guide and the Windsurf beginner guide cover the in-editor lane. One number to treat with care: a third-party writeup cited 51.8% on SWE-bench Verified for a Gemini Flash configuration of Jules, but Google has not published an official Jules benchmark, so do not treat that figure as Google's own score.

Can I use Google Jules from the terminal?

Yes. Google released Jules Tools, a command-line interface that lets you assign and manage Jules tasks directly from your terminal, against the same backend as the browser app. Install it with npm and sign in through the browser:

npm install -g @google/jules
jules login

From there the core commands mirror the web flow. List the repositories Jules can reach, create a task against one, and check what is running:

jules remote list --repo
jules remote new --repo your-org/your-repo --session "Write unit tests for the auth module"
jules remote status

Typing jules on its own opens the terminal dashboard, a minimal interface that lists live sessions and lets you create tasks step by step. Because the CLI is scriptable, you can also pipe work into it — for example, feeding GitHub issue titles or lines from a TODO file into new sessions. The Gemini CLI has a Jules extension too: install it and the /jules command submits a task from inside Gemini CLI. There is also a REST API at jules.googleapis.com, currently in alpha, with API keys generated in the Jules web app under Settings. Because the API is alpha, Google warns that its specifications and keys may change.

What is Jules not good at?

Jules is not good at anything without a clear finish line. Exploratory refactors drift, greenfield architecture has no acceptance criteria to validate against, and real-time pair debugging needs a synchronous partner — all three are the wrong job for an async agent. If the task needs a conversation, use an interactive tool instead; our VS Code beginner guide is the natural home for that kind of work.

Speed is the other honest limit. Individual tasks take minutes, not milliseconds, and community reports from mid-2026 describe up to 40 minutes for a small task. That is fine for background work and frustrating if you are waiting on it. There is also no editor integration at all — Jules connects to GitHub repositories and works through the web interface, the CLI, or the API, and nothing else.

Finally, mind the account rules: you must be 18 or older, and paid tiers are currently limited to eligible personal Gmail accounts, with Workspace paths still coming. A V2 rewrite is in development with an early-access waitlist, but Google has not published a release date or a feature set, so do not plan a workflow around it. And on privacy, Google says Jules does not train on your private code, while its post-GA privacy update states public-repository data may be used for training — read the current privacy notice directly if your repositories are sensitive.

Sources

Every price, limit, and date in this article comes from a source fetched on October 28, 2026:

• Kie.ai — What Is Jules? Google's Async Coding Agent (July 19, 2026): launch and general-availability dates, pricing tiers and task limits, the 18+ rule, Gmail-only paid plans, the REST API, the privacy note, and the unconfirmed V2 rewrite.
• The Rundown AI — Jules Tools CLI: Features, Pricing & Alternatives (pricing checked August 29, 2026): plan limits, the CLI workflow, and the no-separate-charge rule.
• Morph — Jules: Google's Coding Agent Explained (March 2026): the plan-execute-review workflow, Environment Snapshots, the comparison tables, and the earlier Pro-tier figure.
• DEV Community — Jules: Google's Async Coding Agent Is Changing How We Think About AI and Software Development (May 29, 2026): the I/O 2026 refresh, the 2M-token context window, the CI auto-fix loop, and the task-fit table.
• Guvi — Google Jules Tutorial: Real Examples and Implementation 2026 (June 18, 2026): the setup steps, the strong-prompt anatomy, the AGENTS.md tip, and the PR review flow.
• Google Developers Blog — Meet Jules Tools: A Command Line Companion for Google's Async Coding Agent: the CLI install command, login, and remote session commands.

FAQ

Is Google Jules free to use?

Yes. The free tier gives you 15 tasks per rolling 24 hours and 3 concurrent tasks, powered by Gemini 2.5 Pro, with no payment needed. Paid access is bundled into Google AI Pro at $19.99 a month (100 tasks a day, 15 concurrent) and Google AI Ultra at $124.99 a month (300 tasks a day, 60 concurrent), with priority access to Gemini 3 Pro.

Does Jules push code directly to my main branch?

No. Jules pushes its changes to a branch and opens a GitHub pull request. You review the diff, run your tests, leave comments, and merge when you are satisfied. Merge control always stays with you — Jules cannot merge its own pull requests.

What programming languages does Jules support?

Python and JavaScript/TypeScript are strongest. Go, Java, C#, and other languages work but with less reliable results, and complex projects with undocumented internal frameworks may need more iterations.

How is Jules different from GitHub Copilot?

Copilot works synchronously inside your editor — autocomplete, chat, and agent mode as you type. Jules is asynchronous: you assign a task, it works in a background cloud VM, and it returns a pull request. They complement each other — Copilot for real-time coding, Jules for background batch work.

Can Jules access my private GitHub repositories?

Yes. You connect repositories through the Jules GitHub App, and you can limit access to specific repositories instead of granting access to all of them. Google says Jules does not train on your private code, but its privacy update states public-repository data may be used for training, so read the current privacy notice before connecting sensitive work.