Have you ever used vibe coding to write code? Taking a sip of your coffee while AI is coding for you? I’m sure you have done it. Now, think what if tasks like writing test cases, upgrading packages took care of themselves, while you focus on logic? Seems astonishing, right? Now this is possible with the help of Jules. Jules, the latest offering by Google, allows you to asynchronously vibe code while you tend to other aspects of your project. In this article, we will take a look at the working of Jules and try to understand its working and how it is changing the vibe coding benchmarks. We will also be doing some practical tasks to test Jules. Let’s get started.

Table of contents

• What is Jules?
• How does Jules work?
• How to access Jules?
• Practical Tasks with Jules
• Limitations & Considerations
• Conclusion
• Frequently Asked Questions

What is Jules?

Jules is an asynchronous AI agent that works in the background, plans your tasks in detail then executes them. Jules is not a live autocomplete agent. It works asynchronously, which means Jules lets you assign a task and then lets you “sleep on it.” No blocking of your coding flow occurs in this process. Jules is powered by Gemini 2.5 Pro, which excels in coding tasks. It operates in a secure cloud virtual machine environment. Jules integrates with your GitHub to understand your full codebase.

How does Jules work?

Jules goes through a series of events while working. Let’s look at the series of actions that Jules takes while working:

• Triggering Jules: Jules works with your GitHub repositories; you can provide Jules with a GitHub issue or label, or even run a prompt in Jules UI.
• Repository Cloning: Before doing any action, Jules clones the provided repository in its own virtual machine environment. Also, It resolves all the dependency issues to run the program.
• Planning Stage: Jules understands the codebase and the query, derives a plan on how it is going to perform the tasks, and makes a detailed plan out of it. It includes the affected files list and the next steps.
• Code Execution: After planning, Jules applies all the changes to the repository, runs test cases, and captures the differences before and after the execution.
• Review & Merge: Jules reviews all the changes, merges the changes, and sees if there are any user review differences or pull requests.

How to access Jules?

Jules can be accessed easily, just follow the following steps:

1. Head over to jules.google.com and click on Try Jules.
2. Authenticate with your Google account and accept the privacy notice.

3. Click on Connect to GitHub Account and select the repositories you want Jules to access.

4. On success, you’ll see a repository selector in the Jules dashboard.

Practical Tasks with Jules

Let’s evaluate Jule’s performance on different practical tasks. We have a GitHub repository named test_git, and we will be testing Jules on it.

Task 1: Generating Unit Tests for Existing Functions
Our repo contains a calculator.py file, which contains simple calculator functions:

# calculator.py
def add(a, b):
return a   b

def subtract(a, b):
return a - b

def multiply(a, b):
return a * b

The task for Jules is to analyze calculator.py and generate corresponding unit tests for all the functions within it, placing them in a new file (e.g., test_calculator.py).

Prompt: “Create comprehensive unit tests for all functions in the calculator.py file. Ensure the tests cover basic and edge cases. Place the new tests in a file named test_calculator.py”

Planning Phase:

After approving the plan, Jules started the code execution.

We can see that Jules successfully created the test cases and also ran them in its VM environment. This depicts the self-executing capabilities of Jules. It can create test cases and also run them independently without any human intervention.

Task 2: Upgrading a Dependency and Resolving Potential Conflicts

We have a requirements.txt file in our repository, which contains an outdated version of the requests library. We also have an issue #1, which states that we’ll try and resolve using Jules.

Prompt: “Resolve the issue #1 Upgrade ‘requests’ library to the latest version and ensure tests pass.”

Jules successfully detected the outdated version and then ran pip install requests in its own VM. In the end, it successfully updated the dependencies version.

All the changes are then committed to the branch after clicking on Publish Branch.

Task 3: Adding a README.md file to the repository

One of the most important tasks for a GitHub repository is to add a README file, which explains everything about the project. Developers often skip this part, but let’s see how Jules can help us in this situation.

Prompt: “Add a README file for this project, which will include all CLI options.”

Jules planned how to add a README file and documentation, which also included how it would handle CLI commands.

We can see that Jules added a well-defined README file and also modified the calculator.py to use the argparse library, which is used to define the CLI commands with the Python scripts.

Now, we have tested Jules on 3 tasks that required GitHub. It completed every task and also committed the changes to its branch. You can find the GitHub repository that’s used for demonstration here.

Limitations & Considerations

Here are some limitations and considerations that we should keep in mind while working with Jules:

• Not for large features: Jules is better at small tasks, but it often struggles with architectural overhauls and changes that require a lot of changes.
• Request Limit: There is a Daily task cap in Jules, which makes it inaccessible after a certain requests. As of now, Jules offers 60 requests per day.
• Public Beta: Jules is still in public beta, Google is working on the final version, and it may be released soon.
• Human review required: We saw Jules’ capabilities, but always validated diffs and ran additional tests after using Jules to avoid any mistakes.

Conclusion

Jules automates the tedious parts like dependency bumps, writing or running test cases, and updating the documentation. This makes developers’ lives easy now; they can focus more on creative tasks rather than writing docs and test cases all day. We have tested 3 tasks here, but there is almost no limit to what it can do. You can be as creative as you can be. Try different prompts and feel the “vibe coding effect”. In the future, Jules and its successors will evolve agentic development and reshape software workflows.

Frequently Asked Questions

A. Yes, it’s free in public beta with usage limits, though future pricing isn’t finalized

A. Works best with JavaScript/TypeScript, Python, Go, Java, Rust—but is designed to be language-agnostic.

A. Jules handles well-specified bug descriptions; obscure or architectural issues still need human guidance.

A. All tasks run in isolated cloud VMs; Jules does not persist your private code or expose secrets.

A. No! It automates routine work so developers can focus on creative and strategic coding. Human review remains essential.

The above is the detailed content of Jules - Google's FREE AI Coding Agent is UNREAL. For more information, please follow other related articles on the PHP Chinese website!