How to Use Google Jules in 2026: A Practical Guide Before It Winds Down

Google Jules was an interesting step forward for AI-assisted software development. Instead of suggesting code while you work, it could take an assigned task, inspect a GitHub repository, create a plan, modify files, run tests, and prepare changes for review.

That asynchronous approach made it useful for developers who wanted to delegate work without constantly supervising an AI coding assistant.

However, there is an important update developers need to know before getting started.

Google announced on October 29, 2026, that Jules will wind down on December 31, 2026. Starting November 11, 2026, the service will become read-only. Existing code, branches, and pull requests will remain in GitHub, but users should export their Jules data before the service closes.

So, if you have been meaning to try Jules, this guide explains how it works, how to use it while it remains available, and what to consider next.

What is Google Jules?

Jules is Google's asynchronous AI coding agent. It connects to GitHub repositories and performs software development tasks in an isolated cloud environment.

Unlike a traditional code-completion assistant, Jules is designed to handle a task from beginning to end.

For example, you could ask it to:

• Fix a bug in an existing application.
• Add unit tests for a particular function.
• Update outdated dependencies.
• Implement a small feature.
• Refactor a section of code.
• Improve project documentation.

Jules uses Google's Gemini models to understand the task and work with the repository. It creates a development environment in a cloud virtual machine, examines the project, and produces changes that you can review.

The general workflow looks like this:

1. Connect a GitHub repository.
2. Describe the development task.
3. Review the plan generated by Jules.
4. Allow it to execute the task.
5. Inspect the changes and test results.
6. Create a branch and open a pull request.

The important part is that Jules works asynchronously. You can submit a task and continue working on something else while it handles the implementation.

What you need before using Jules

Before starting, make sure you have:

• A Google account.
• A GitHub account.
• A repository containing the project you want Jules to work on.
• Permission to authorize Jules to access that repository.

You should also make sure your repository is in a reasonably healthy state. A project with missing dependencies, unclear instructions, or failing tests can make it harder to evaluate the quality of an agent's changes.

Google's documentation also recommends using an AGENTS.md file to provide repository-specific instructions to coding agents.

For example, you can use this file to explain:

• The project's architecture.
• Which frameworks and libraries it uses.
• How to install dependencies.
• How to run tests.
• Coding conventions.
• Important restrictions when modifying the application.

This gives Jules additional context about how the project is expected to work.

Step 1: Open Google Jules and connect GitHub

Start by visiting jules.google.

Sign in with your Google account and follow the initial setup instructions.

Next, connect your GitHub account.

Jules needs repository access because it works directly with your existing code rather than requiring you to manually upload individual files.

During the authorization process, you can choose which repositories Jules is allowed to access.

I recommend starting with a specific repository instead of immediately granting access to everything. This gives you better control over which projects the agent can work with.

Once GitHub is connected, return to Jules.

You should now be able to select an authorized repository and choose the branch you want to use.

Step 2: Choose a repository and branch

Select the repository containing the code you want Jules to modify.

Then choose the branch you want it to use as the starting point.

For example:

• Repository: my-project
• Branch: main

Jules uses the selected branch as the starting point for its work.

For an actual production project, I would avoid treating the main branch as a place for unreviewed changes. Use a development branch or another appropriate starting point, then review the resulting changes before merging anything.

This makes it easier to compare the agent's work with the existing implementation and roll back changes if necessary.

Step 3: Give Jules a specific coding task

This is where the quality of your instructions becomes important.

A vague prompt such as:

"Improve my application"

does not give Jules enough direction.

It may understand the general intention, but it has to make assumptions about which parts of the application need attention and what a successful result should look like.

Instead, describe the problem, the expected behavior, and any relevant restrictions.

For example, consider this task:

Example prompt:

Add unit tests for the parseQueryString function in utils.js.

Requirements:
- Cover empty query strings.
- Test multiple query parameters.
- Test URL-encoded values.
- Test parameters without values.
- Follow the existing testing conventions in the repository.
- Do not modify the function's implementation unless a bug prevents the tests from passing.

Run the relevant test suite and report the results.

This is a much more useful instruction because it gives Jules a defined scope and measurable expectations.

Another example would be:

Investigate the login form validation in the application.

The form currently accepts an invalid email address.

Please:
1. Locate the existing validation logic.
2. Explain the cause of the problem.
3. Propose a minimal fix.
4. Add tests covering valid and invalid email addresses.
5. Avoid changing unrelated authentication functionality.

The second example also asks Jules to investigate before making changes, which is useful when you are not completely sure where the problem originates.

Step 4: Review the plan before execution

After submitting your prompt, Jules generates a plan describing how it intends to approach the task.

Do not automatically approve every plan.

Take a moment to check whether it understands the requirements and whether the proposed changes are within scope.

For example, if you ask it to add tests but its plan involves restructuring your authentication system, that is a reason to stop and clarify the task.

A useful plan should explain:

• Which files it expects to modify.
• What changes it intends to make.
• How it will verify the implementation.
• Whether additional dependencies or configuration changes are required.

If something is unclear, provide feedback before approving the plan.

This is one of the useful parts of Jules' workflow: you can review the proposed approach rather than immediately accepting a large set of code changes.

Step 5: Let Jules execute the task

Once you approve the plan, Jules starts working in its cloud environment.

It clones the repository, prepares the development environment, and makes the required changes.

Depending on the task, it can also run commands, install dependencies, and execute tests.

You do not need to keep the Jules interface open throughout the entire process. You can enable notifications to receive updates when a task completes or needs your attention.

You can also provide feedback while the task is running.

For example, you might tell Jules:

The current implementation changes more files than necessary.

Please keep the solution focused on the login validation issue
and avoid modifying the shared authentication service.

The ability to redirect an agent is important. Autonomous execution does not mean you should give up control over the development process.

Step 6: Review the changes and create a pull request

When Jules finishes, it provides a summary of the work.

You can inspect the modified files, review the differences, and examine the results of its execution.

Pay particular attention to:

• Whether the changes actually solve the original problem.
• Whether unrelated functionality was modified.
• Whether tests passed.
• Whether new dependencies were introduced.
• Whether the implementation follows the project's conventions.

If the changes look acceptable, you can create a branch and use it to open a pull request on GitHub.

The pull request gives you a familiar place to review the code, request further changes, and decide whether the implementation is ready to merge.

Do not treat a completed Jules task as an automatic approval to merge. Tests can pass while an implementation still contains logic errors, security problems, or unexpected behavior.

Human review remains essential.

Step 7: Try starting tasks from GitHub Issues

One useful Jules feature is its connection with GitHub Issues.

Instead of opening Jules and manually describing every task, you can assign work through a GitHub issue.

For supported repositories, add the jules label to an issue. Jules can then pick up the task, work on it, and provide a link to the resulting pull request.

For example, a GitHub issue might look like this:

Title: Add pagination to the product API

Description:

The product endpoint currently returns every product
in a single response.

Implement pagination using the existing API conventions.

Requirements:
- Support page and limit parameters.
- Return pagination metadata.
- Preserve existing response compatibility.
- Add tests for pagination behavior.

After adding the jules label, the agent can begin working on the issue, provided it has the required repository authorization.

This is particularly useful for teams that already manage their development backlog through GitHub Issues.

What are Jules' limitations?

Even before the shutdown announcement, Jules had limitations that developers needed to understand.

1. It still requires good instructions

An autonomous coding agent cannot reliably infer every architectural decision or business requirement. Poorly defined tasks can produce changes that technically work but do not match the intended solution.

2. Generated code still needs review

Passing tests is useful, but it does not prove that a change is correct, secure, or ready for production.

3. Repository access needs to be managed carefully

Jules works with the code and files available in the repository. Avoid committing secrets, credentials, or sensitive information to repositories connected to external coding agents.

4. Usage limits apply

Jules has offered different access levels, including a free tier and higher limits through Google AI subscriptions. Limits and eligibility can change, so consult the official usage limits documentation rather than relying on older pricing articles.

5. The service is being discontinued

This is now the biggest limitation. Google has announced that Jules will become read-only on November 11, 2026, before winding down on December 31, 2026.

That means developers should avoid building long-term workflows that depend exclusively on Jules.

Important: How to export your Jules data before shutdown

Google's October 29 announcement explains that users can export their Jules data into a local folder.

The export includes:

• Account settings.
• Environment variables.
• Scheduled tasks.
• Connected repositories.
• Memories.
• Setup scripts.
• Session prompts and plans.
• Activity logs.
• Code patches.

Your code, branches, and pull requests already stored in GitHub will remain there. However, it is still worth exporting your Jules-specific information so you can preserve the context behind your previous work.

I would prioritize this before November 11, when Jules is scheduled to become read-only.

For the latest instructions, check the official Jules changelog.

What are the alternatives to Google Jules?

The shutdown raises a practical question: where should developers go next?

There are several approaches worth considering, depending on whether you want an individual coding agent or a way to coordinate multiple agents across a development workflow.

Sharkly — For coordinating multiple AI coding agents

One option worth evaluating is Sharkly.

While Jules focuses on executing coding tasks asynchronously, Sharkly approaches the problem from a broader task-management and coordination perspective.

It brings engineering tasks, backlogs, sprints, and AI-agent execution into a shared workflow.

For example, a development team might have several issues to work through:

• Fix a bug in the authentication module.
• Add tests for the payment service.
• Update API documentation.
• Refactor a component.
• Investigate a performance issue.

Instead of managing each coding agent independently, the team can organize tasks and assign suitable work to supported agents.

Sharkly supports coding tools such as Claude Code, Codex, Gemini CLI, and OpenCode.

Some of its useful capabilities include:

• Assigning development tasks to AI agents.
• Coordinating multiple agents working on separate tasks.
• Keeping task context and execution results together.
• Using isolated worktrees for parallel coding work.
• Tracking progress through a shared task-management workflow.

This is particularly useful for teams that are moving beyond experimenting with one coding agent and want a more structured way to manage agent-driven development.

It is important to understand the distinction: Sharkly is not a direct replacement for Jules' cloud environment or its exact workflow. It provides a different approach to organizing and coordinating engineering work with supported agents.

You can explore it at Sharkly.ai.

Other options worth exploring

Tool	What it offers	Best suited for
Claude Code	Agentic coding through a terminal workflow	Developers who want an agent working directly with their codebase
OpenAI Codex	Cloud-based coding tasks and agent-assisted development	Developers who want to delegate coding tasks
Gemini CLI	Open-source AI agent in the terminal	Developers who prefer a command-line workflow
Sharkly	Task management and coordination across supported coding agents	Teams managing multiple agents and engineering tasks

The right choice depends on how you work. If you want an individual coding agent, tools such as Claude Code, Codex, and Gemini CLI are worth investigating. If you need to coordinate multiple agents and keep their work connected to a shared backlog, Sharkly offers a different layer of organization.

Final thoughts

Google Jules demonstrated an interesting direction for AI-assisted software development: developers could delegate meaningful engineering tasks, review a proposed plan, and return later to inspect the implementation.

Its asynchronous workflow was useful because it shifted the focus from generating individual code suggestions to completing larger, well-defined tasks.

However, with Google now planning to discontinue Jules by the end of 2026, developers should treat this as a transition point rather than the beginning of a long-term Jules workflow.

If you already use Jules, export your data and preserve the work that matters. If you are looking for an alternative, evaluate tools based on how you want to manage coding tasks, execute changes, and review the results.

And if your team is beginning to work with several AI coding agents, it may be time to think beyond the individual agent and consider how those agents fit into the wider engineering workflow.

Frequently asked questions

Is Google Jules free to use?

Jules has offered a free access tier, alongside higher usage limits through eligible Google AI subscriptions. The available limits and plans can change. Check the official Jules usage limits page.

Does Google Jules work with GitHub?

Yes. Jules connects to authorized GitHub repositories, works from a selected branch, and can create branches and pull requests containing its changes.

Can Google Jules write and test code?

Yes. Jules can modify code, install dependencies, run commands, and execute existing tests in its cloud environment. Developers should still review the resulting changes before merging.

Is Google Jules shutting down?

Yes. Google announced on October 29, 2026, that Jules will wind down on December 31, 2026. It is scheduled to become read-only on November 11, 2026.

What is the best alternative to Google Jules?

There is no single replacement for every Jules workflow. Claude Code, OpenAI Codex, and Gemini CLI offer agentic coding capabilities. Sharkly is worth considering when the challenge is coordinating multiple coding agents and organizing their work across engineering tasks.

Can I still access my Jules projects after the shutdown?

Google says code, branches, and pull requests already stored in GitHub will remain there. Jules-specific information can be exported before the service becomes read-only. Follow the official Jules changelog for the latest instructions.