A Jules run ends before the delivery clock stops
Define the task, validate its environment, set approval behaviour, and measure through acceptance. A completed background run is only one part of delivery.

A background coding agent can finish its run while a pull request waits untouched. The task moved out of the editor, but the delivery time still includes setup, clarification, review, fixes, and release. Measuring only the agent's coding phase misses that handoff.
Google Jules is useful to examine through this boundary. Its current documentation describes repository tasks running in a short-lived virtual machine, with dependencies installed and tests executed. That supplies an environment for doing work. It does not define which work the team should accept.
Give the task an acceptance boundary
"Improve tests" leaves the agent to choose a goal. "Add coverage for an empty query parameter without changing the parser's public return shape" supplies a behaviour and a constraint. A reviewer can inspect the resulting change against both.
Include a failing example when one exists, the command that exercises it, and the files or interfaces that should remain compatible. Keep those instructions close to the task. If repository guidance is relevant, update it so that the next run does not have to rediscover the same convention.
Jules' getting-started documentation says it reads a root AGENTS.md file and lets users choose a repository and branch. Pinning the intended branch avoids evaluating a fix against code that differs from the task's starting point.
The acceptance boundary also defines when to return for clarification. An agent asked to repair a dependency conflict should not silently replace the application's framework. A larger change may be justified, but it requires a new decision and a reviewable explanation.
Validate the environment before blaming the patch
The environment documentation describes a short-lived Ubuntu VM and setup scripts for more complex projects. Its published tool inventory is a starting point; the task should still verify the versions and services it actually needs.
A failed test may reflect a missing service, an absent credential, or an existing failure on the base branch. Run the relevant check before the change when possible. Preserve the distinction between an unchanged baseline failure and a regression introduced by the patch.
Avoid putting production secrets into repository instructions or test fixtures. A task that needs external access should receive the minimum appropriate test access through the supported configuration. A temporary VM does not make every credential safe to copy into it.
Set approval behaviour explicitly
A displayed plan is useful only if the team's process understands what happens next. The current Jules session API documents a requirePlanApproval option; when it is not set, plans are auto-approved. It separately offers automatic pull-request creation.
Those are workflow choices, not equivalent safety guarantees. Opening a pull request creates material for review. It does not mean the team approved the implementation, merged it, or released it. An unattended process needs explicit boundaries for each action it can take.
The plan should name the intended files, tests, and compatibility assumptions. Review changes to that scope as the run progresses. If the environment prevents a required check, the result should state the missing evidence plainly instead of treating the run as complete because files changed.
Measure the whole handoff
For a small trial, record when the request was ready, when the agent produced a reviewable patch, how much reviewer time it used, and when the change was accepted. Include abandoned runs and corrections in the sample. Excluding them would make the workflow appear faster than the team's experience.
Historical productivity studies cannot supply a current Jules speedup. METR's February 2026 experiment update describes selection and measurement problems in its later developer study, including difficulty measuring concurrent agent use. That is a reason to define the team's own timing carefully, not evidence for a particular product's performance.
Compare tasks with similar scope and acceptance standards. A documentation edit and a database migration should not share an unqualified average. Watch whether background runs create a growing review queue that cancels the time saved during implementation.
The useful outcome is an accepted change with evidence another developer can inspect. If a Jules task reaches that outcome with less total work, the team has a reason to repeat it. A fast run that shifts more unexplained work into review has not yet established the same result.