# Your Coding Agent Just Got Cloned And Your Brain Isn't Ready

Rustin Banks

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/X4BwOu0GWb8-your-coding-agent-just-got-cloned) · [Video](https://www.youtube.com/watch?v=X4BwOu0GWb8)

## Your Coding Agent Just Got Cloned And Your Brain Isn't Ready

Rustin Banks uses Jules to improve a conference schedule app, showing how parallel coding depends on clear tests, competing approaches, and a plan for merging the results.

Familiarity with Git branches, pull requests, and automated tests will help you follow the demonstration.

### From a closet bulletin board to background coding

[0:15](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=15s)

Rustin Banks’s first compiler was Borland C++ 3.1, ordered through AOL Classifieds. He recalls it arriving on ten five-and-a-half-inch floppy disks. He later hosted a bulletin board on salvaged computers in his parents’ closet, so the text interfaces of early AI assistants felt immediately familiar. By the time **ChatGPT 3.5** appeared, he wanted to devote his career to AI coding. Watching its slow output again, he marvels at how recently that had been state of the art.

At Google Labs, Banks became a product manager for [Jules](https://blog.google/innovation-and-ai/models-and-research/google-labs/jules/), an asynchronous coding agent that works in the background while other tasks proceed. This talk takes place shortly after its May 2025 public-beta launch at Google I/O. The beta was free with usage limits in supported Gemini regions. Banks recalls a launch interruption: Josh called while demonstrating other Google Labs products, the team temporarily shut Jules down, and then brought it back.

The intended division of labor is straightforward: let the agent handle the laundry so developers can concentrate on the art of coding. Updating Firebase SDK usage is one example; managing development from a phone is another. Banks reports 40,000 public commits in the two weeks after launch. Those examples make background coding tangible: work can continue without keeping the developer at a laptop, supervising each edit.

![Two social posts describe a Firebase library update with Jules and building, pushing, and previewing a feature from a phone.](https://ai.engineer/api/talk-essay-media/503e785277f06c68ccdca3a611bedbc94d244c856be56e477b7a45d2d7941581)

Jules user examples: updating Firebase usage and developing from a phone.

### Parallel execution needs help at both ends

[2:19](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=139s)

Most developers have a serial default: take a task from the queue, work on it, then take the next one. Running agents concurrently changes that middle step, but it can leave a person preparing tasks all morning and reviewing pull requests or resolving merges all afternoon. **More execution capacity only helps if task preparation and integration can keep up.**

At the beginning of the workflow, AI can help turn backlogs and bug reports into actionable tasks. At the end, Banks anticipates critic agents and merging agents helping assess and assemble the results. He presents that integration assistance as help on the way, rather than a finished capability demonstrated here. Its purpose is to prevent parallel coding from becoming an exhausting task-writing and review job.

Remote agents make concurrent execution practical because their work is not bounded by the developer’s laptop. Each can operate in a cloud environment, remain connected, and accept interaction from another device. Banks describes this as agents as a service, with effectively unbounded scaling as the architectural aspiration; the launched service still has the usage limits described above. Moving execution away from the IDE changes where work can happen, but does not remove the need to coordinate its results.

### Do more tasks, or try more approaches

[3:51](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=231s)

The expected use of parallel agents is multitasking: assign ten backlog items, run them together, then merge and test the changes. A second pattern emerged from users: give several agents the same goal with different approaches. Banks points to Solomon from Dagger requesting three versions of a website earlier at the conference. Instead of committing to one implementation before seeing it, the developer gets alternatives to inspect.

| Pattern | Agent assignments | What happens afterward |
| --- | --- | --- |
| Multiple tasks | Different backlog items | Merge and test the combined changes |
| Multiple variations | Different approaches to one task | Test candidates and choose |

For variations, either the user or agents can evaluate the candidates. The distinction matters because alternatives are not necessarily changes to combine: some are experiments to discard after comparison.

![Side-by-side purple diagrams show separate tasks flowing into Merge & Test, and one task branching into three variations before Test and Choose.](https://ai.engineer/api/talk-essay-media/07f0eddfc69404affb11694d3520794b9beb74e7342e6d211bdba94dfa940542)

Two forms of parallelism: multiple tasks or multiple variations.

Consider adding drag and drop to a React app. Banks proposes separate agents using [react-beautiful-dnd](https://github.com/atlassian/react-beautiful-dnd), using [dnd kit](https://dndkit.com/), or taking a test-first approach. Each can work asynchronously, then return an implementation for evaluation. The first library belongs to the historical example: its repository was archived on August 18, 2025, after this talk. The enduring technique is to vary the approach while keeping the desired behavior fixed.

### A conference schedule with room to improve

[5:21](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=321s)

The demonstration starts with the [conference schedule](https://ai.engineer/worldsfair/2025/schedule). Its horizontal scrollbar gives Banks an immediate usability complaint, but the organizers have also published the schedule as JSON. That feed lets other developers build their own interfaces. Pallav’s version adds favorites and bookmarks, and Banks already uses it to keep track of sessions.

Banks asks Pallav for permission to clone the project for the Jules demo. Pallav agrees and reports that he has just fixed a bug with Jules from his phone while sitting in a session. With an existing app to work on, Banks opens Linear to organize the changes.

The first task is to establish a way to tell whether subsequent agent changes work. Banks starts competing test-suite tasks using [Jest](https://jestjs.io/docs/configuration) and [Playwright](https://playwright.dev/docs/api/class-coverage), proposing test coverage as the selection criterion. This uses the variations pattern before moving on to independent improvements: first choose a verification foundation, then let more tasks build on it.

The proposed work then expands:

- **Features:** add a Google Calendar link for a session and an AI summary when a user clicks its description.
- **Neglected maintenance:** use agents for accessibility and security audits, work that often remains on the backlog despite its importance.
- **Selected demo tasks:** run an accessibility audit, fix issues, and improve Lighthouse scores alongside the feature work.

Security is an example of useful backlog work here, not a demonstrated audit result. Banks chooses a front-end project because the changes are easy to show, while noting that the same workflow can apply to back-end development.

### Give the agent a testable foundation

[7:50](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=470s)

Inside Jules, the Jest task proceeds through a concrete execution sequence:

1. **Connect the repository.** Jules accesses the project through its GitHub integration and proposes a plan.
2. **Review the plan.** Banks checks the proposed calendar, search, and session test targets, then approves the work.
3. **Execute remotely.** Jules has its own cloud VM with the entire codebase cloned into it. It can run project commands, including tests, rather than merely suggest edits.

That last step supplies the feedback loop needed for later feature work: the agent can observe a failure and change its implementation.

Banks fast-forwards through test creation. Alongside the Jest tests, Jules updates the `README` with instructions for running them. Those instructions become reusable context: a later task can read the repository and discover how to check its own changes.

Banks estimates roughly 80% test coverage for the Jest candidate. He suggests comparing it with Playwright, but does not show a comparative result or establish a winner on that basis. A useful comparison would need the same file scope and reporting method: Jest distinguishes statement, branch, function, and line coverage, while Playwright’s documented coverage API collects browser JavaScript and CSS usage in Chromium. A percentage alone does not establish which suite better verifies the app.

The Jest pull request is then merged into `main`. This is the dependency boundary in the demo: the shared test foundation lands before Banks requests the calendar feature, so subsequent work can use it.

![GitHub pull request titled “feat: Add Jest testing framework and initial tests” shows a purple Merged badge and a summary of tests and estimated coverage.](https://ai.engineer/api/talk-essay-media/d7b853c8751c2b005f993eb4dbe56857db1574bbcd2ce6a1ebab1bd6596e9290)

The Jest testing pull request is merged on GitHub.

### Let test failures drive the next edit

[9:20](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=560s)

The calendar-button task does not pass its tests on the first attempt. Jules makes changes and runs them again; this time they pass. Banks can now review the code with evidence from the test run. He also mentions eventual inspection in a Jules browser, but that is prospective in this demonstration. The working mechanism here is the edit–test–repair loop inside the agent’s execution environment.

Next comes a Gemini-generated summary opened from a session description. Banks switches to an emulated mobile view to illustrate how the work could be managed from a phone, then shows interaction with the accessibility audit and fixes. He acknowledges visible console errors and says Jules will fix them; their resolution is not shown at this point. Remote access makes the tasks available on another screen size, while the actual coding work remains in the cloud.

### A working feature is not yet a combined release

[10:07](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=607s)

The parallel tasks leave a larger integration job. Banks says he ran out of time to finish the combined merge, naming an [octopus merge](https://git-scm.com/docs/merge-strategies) and joking that Jules’s squid identity should make it a natural helper. Git’s octopus strategy can merge more than two heads, but refuses complex merges requiring manual resolution. It does not automatically solve conflicting edits from concurrent agents.

Instead, Banks checks the calendar feature locally. He refreshes `localhost`, finds the new button, clicks it for his own talk, and adds the session to Google Calendar. That verifies the visible user path for this feature without implying that all the parallel work has been integrated.

Merging the remaining changes into `main` so conference attendees can use them is still a next step. Banks estimates about an hour for the demonstrated work and management of the parallel process. His account includes the calendar feature, test suite, accessibility work, and Lighthouse improvement, but gives no numerical Lighthouse result; the combined merge and public deployment remain unfinished in the demonstration.

### Keep the success criterion fixed

[11:11](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=671s)

**Define how you will verify success before starting the agents.** Otherwise, parallel execution simply produces more pull requests to inspect. Banks recommends making an explicit agreement with the agent: continue until a specified result is observed or a behavior works. A robust merge-and-test process must still assemble the output afterward, even as better assistance for that work develops.

His prompt structure separates the goal from the implementation choice:

1. Give a brief overview of the task.
2. State how the agent will know it got the result right.
3. Supply helpful context.
4. End with a broad approach.

For a complex task, he changes that last line across two or three variants. The goal and its acceptance condition stay stable, making the approaches easier to compare.

His example is a task that reads a number from a webpage each day. Today’s known value is `X`, so the agent should extract the number, log it to the console, and keep working until the output matches `X`. A small JavaScript check can express that observable condition:

```javascript
function verifyExtractedNumber(actual, expected) {
  console.log(actual);
  if (String(actual).trim() !== String(expected).trim()) {
    throw new Error(`Expected ${expected}, received ${actual}`);
  }
}
```

Here `actual` must come from the extraction, while `expected` is supplied independently from today’s known value. The check makes a mismatch visible; the agent still has to repair the extraction and rerun it.

Banks supplies the search query as context, asks one task to use [Puppeteer](https://pptr.dev/), and clones it with the final approach changed to Playwright. In a reusable prompt, that separation looks like this:

```text
Task: Read the number from the target webpage each day.
Success: Today's known value is X. Log the extracted value to
         the console and keep working until it matches X.
Context: [the search query that locates the target webpage]
Approach: Use Puppeteer.
```

The second candidate changes only the approach line to `Use Playwright.` Both candidates must satisfy the same observable outcome, so the experiment compares ways of solving the problem rather than different definitions of done.

![Slide lists task overview, how to know it is right, helpful context, and a broad approach, alongside a webpage-number logging example and Puppeteer and Playwright.](https://ai.engineer/api/talk-essay-media/5bca6d4bf02f7566ec40bb487d2546ffc013adde45ad4e5dea81220d4cf7cb2b)

A Jules prompt format pairs success criteria with a varied approach.

### Make experimentation affordable to verify

[12:30](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=750s)

Banks closes by encouraging an abundance mindset: with easy verification, developers can try alternatives that a serial workflow would never make time for. The useful expansion is not merely a larger task count. It is the ability to inspect several plausible solutions before deciding which one deserves to become part of the product.

That freedom still depends on the surrounding workflow. Use AI to help create tasks and to support the merge-and-test work afterward. Keep context in Markdown files, documentation links, and getting-started guides so agents can discover how the project works. The earlier `README` update is a concrete example of turning one completed task into guidance for the next.

Banks recommends supplying extensive context and letting agents identify the relevant parts, then qualifies that advice as perhaps especially applicable to Gemini models. He identifies **Gemini 2.5 Pro** as the model powering Jules at the time. The final design choice is therefore to make both the task and its environment legible: give agents enough information to act, and a clear result against which to check their work.

## Resources

- [Jules public-beta announcement](https://blog.google/innovation-and-ai/models-and-research/google-labs/jules/) — Google's launch account explains Jules's cloud execution, parallel tasks, Gemini 2.5 Pro foundation, and free-beta conditions.
- [Get started with Jules](https://jules.google/docs/) — Current instructions for connecting GitHub, preparing a task, approving a plan, and supplying repository instructions.
- [World's Fair 2025 schedule and community views](https://ai.engineer/worldsfair/2025/schedule) — The conference schedule links its public JSON data and community interfaces, including Pallav's list and bookmarking app.
- [react-beautiful-dnd](https://github.com/atlassian/react-beautiful-dnd) — The React list drag-and-drop library from Banks's variation example; its repository is now archived.
- [dnd kit](https://dndkit.com/) — Current documentation for building drag, drop, sorting, and reordering interactions.
- [Jest coverage configuration](https://jestjs.io/docs/configuration) — Configure coverage collection, included files, reporting, and minimum thresholds for Jest tests.
- [Playwright browser coverage](https://playwright.dev/docs/api/class-coverage) — Collect JavaScript and CSS usage through Playwright's Chromium coverage API.
- [Git's octopus merge strategy](https://git-scm.com/docs/merge-strategies) — Git's reference explains multi-head merges and the octopus strategy's conflict-resolution limits.
- [Puppeteer](https://pptr.dev/) — Browser automation documentation for the tool Banks proposes as an alternative to Playwright.

## Slides

### Your coding agent just got cloned

Rustin introduces himself as a Google Labs product manager and opens a talk on cloned coding agents.

[0:19](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=19s) [Title slide says a coding agent just got cloned and your brain is not ready.](https://assets.ai.engineer/sites/aiecode2025/sha256/291deaeb8cc46fba025d1ddc59728b7a70fe0ce67786414a83402f7dc7f7b351.webp)

Your coding 🐙 agent
just got cloned and
your brain Isn’t ready

[illegible]s (@rustinb)
[illegible] Labs* (PM Jules)

*opinions my own

Interface text:
AIE
Microsoft
AI Engineer World’s Fair
augment code
aws
smol ai

### A bulletin board system

The speaker hosted this bulletin board on salvaged computers in his parents’ closet. When AI arrived, its text-based interfaces felt familiar to him.

[0:40](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=40s) [A colorful text-based bulletin board menu beside ASCII art of a castle.](https://assets.ai.engineer/sites/aiecode2025/sha256/a185f99082e254c6e097752232380cc507ab5457e4f2235d0a54d2e30378298f.webp)

Members have more fun! Subscribe today!

The KEEP BBS -=- Main Menu
1] Electronic Mail
2] Forums/Message boards
3] Library of Files
4] Online Games
5] Matchmaker
6] User Registry
7] Calendar
8] Internet Services
9] Chat Rooms.
U] Account Settings
/RATES] Membership rates
/RULES] System Rules
=?] help with global cmds
.?] help with action words
+] Quickscan forums
[illegible]] Check for new mail
G] Goodbye/Logoff

[illegible] choice here [=>

Interface text:
AIE
Microsoft
AI Engineer World’s Fair
augment code
aws
smol ai

### ChatGPT dictionary update example

ChatGPT 3.5’s Python example uses dict1.update(dict2) to add dict2’s entries to dict1. The output is incomplete; the speaker recalls how slow the system was despite being state of the art two years earlier.

[1:08](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=68s) [A code example uses Python’s update method to merge two dictionaries; the displayed output is incomplete.](https://assets.ai.engineer/sites/aiecode2025/sha256/41a68a614bb8038445cdb3200ed625284c77668e517a6cd326c7baf56607d3c8.webp)

add the key-value pairs from one dictionary to another. For example:

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}

# Update dict1 with the key-value pairs from dict2
dict1.update(dict2)

# The dictionaries have been merged
print(dict1)  # Output: {'a': 1, 'b': 2, 'c': 3, 'd':

[illegible]dium.com/@tanyamarleytsui/coding-with-chatgpt-b50ab3fcb45f

Interface text:
Copy code
AIE
AI Engineer World's Fair
Microsoft
[illegible]ugment code
aws
smol ai

### Jules proposes an SEO task plan

For an SEO unit-test request, Jules presents a plan to fix HTML and metadata issues. The demo shows the plan awaiting review, with an auto-approval countdown.

[1:14](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=74s) [The Jules interface shows an SEO unit test request and a plan awaiting review.](https://assets.ai.engineer/sites/aiecode2025/sha256/5680733d5472a3ecbb66c77597c82d0be0f768aaa04692af6189b8e6c850f63b.webp)

Write me some unit tests for SEO

1. Correct Invalid HTML in src/components/Head.astro: Remove the nested <head> tag.
2. Fix Hardcoded og:image in src/components/Head.astro: Modify the component to use the image prop for og:image.
3. Add Canonical URL to src/compo[illegible]Head.astro: Include a <link [illegible]

Please review the plan. Let me know if you have any feedback. Otherwise, let me know and I'll get started!

Approve plan?
Plan auto-approves in 04:40

Sequences shortened.

Interface text:
jules beta
jules-demo/jules-surf-shack
Search for repos or tasks
Recent tasks
Write me some unit tests for S...
Fix the wrapping in the navbar
Codebases
jules-demo/jules-surf-sha...
firebase/firebase-admin-go
firebase/firebase-admin-n...
firebase/firebase-admin-p...
Daily task limit (1/30)
Feedback
New
Talk to Jules
Jules can make mistakes so double-check it and use code with caution

AIE
AI Engineer World's Fair
Microsoft
augment code
Gemini
aws
smol ai

### Jules use cases

Seth Ladd reports using Jules to replace a deprecated Firebase library in his Flutter app. Chong-U describes building a feature, pushing a GitHub branch, and testing a Vercel preview from his phone.

[1:52](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=112s) [Two public posts describe using Jules for a Firebase update and developing from a phone.](https://assets.ai.engineer/sites/aiecode2025/sha256/cbd6a92d92112da78568e4b19d4210fc4edf04738a229a374c07dc41ce7000a4.webp)

Seth Ladd
@sethladd

Fun! Just had Jules change my Flutter app's usage of the firebase vertex ai to the new Firebase AI Logic API. All I told Jules was "firebase_vertexai is now deprecated. replace it with the new library that they just announced from Google IO"

It worked! Thanks Jules!

Jules.google.com

3:46 PM · May 31, 2025 · 1,195 Views

Chong-U @chongdashu · May 29
🚀 Really digging Google’s Jules AI agent lately
✅ Perfect for quick, well-defined tasks
📱 Browser based-no app needed

In this video:
1 Built a feature
2 Pushed a GitHub branch
3 Tested with a Vercel preview

All from my phone... while chilling on the sofa.
👇 Check it out:

Interface text:
AIE
Microsoft
AI Engineer World's Fair
augment code
aws
smol ai

### Parallel agents: session agenda

The talk introduces background parallel agents, then moves through a real-world demo and use case and best practices learned from watching people use Jules.

[2:18](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=138s) [Agenda covering background parallel agents, real-world examples, and best practices.](https://assets.ai.engineer/sites/aiecode2025/sha256/737b16036ff0627588ced0366f5f52c5db991530407f1c5830c9e9e4e7d80e26.webp)

1. Learn about parallel agents meant to run in the background
2. Show you real world examples of using parallel agents
3. Best practices to get the most out of parallel agents

Interface text:
AIE
AI Engineer World’s Fair
Microsoft
aws
smol ai

### AI support across the parallel coding workflow

AI can turn backlogs and bug reports into tasks, while critic, merge and testing agents help with the review and merge cycle after coding.

[3:05](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=185s) [Task sources feed agent work, followed by review and merging supported by critic, merge and testing agents and automated CI/CD.](https://assets.ai.engineer/sites/aiecode2025/sha256/9fbfbf4281ecb0e5b2a40f7a2906d9ac71fb5e14902d15205edba84aab2e7127.webp)

For coding agents to work in parallel, AI needs to help with more of the process

1. Backlog
2. Bug reports
3. Alerts
4. Log Analysis

Define a task
Agent works on the task
Review & merge changes

1. Critic Agents
2. Merge Agents
3. Testing Agents
4. Auto CICD

Interface text:
AIE
AI Engineer World’s Fair
Microsoft
aws
smol ai

### Remote agents and parallelism

IDE agents offer control over setup but share limited laptop resources. Remote agents can run in parallel, stay connected, and be accessed from any device.

[3:31](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=211s) [Comparison of IDE agents and remote agents, including environment control, resource limits, connectivity and device access.](https://assets.ai.engineer/sites/aiecode2025/sha256/fb3582c4f63c19f73ae18f6ee71f62153ff56db609330f876f748b75f6dce0df.webp)

Remote agents are uniquely suited for parallelism

Agent in IDE
• Ultimate control over environment & setup
• Limited resources

Remote Agent
• Create “infinite” agents
• Always connected
• Develop from any device (your phone!)

AIE
Microsoft
aws
smol ai

### Two types of parallelism

Multi-tasking runs different tasks in parallel, then merges and tests them. Multiple variations runs one task several ways; an agent or the user can test and choose among the results.

[4:24](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=264s) [Multiple tasks merge and test, while variations of one task are tested and compared.](https://assets.ai.engineer/sites/aiecode2025/sha256/0add94656abf68e63b32159de50d40f871585c2f4adf3a330a496f5d4dec7117.webp)

Two types of parallelism emerging

Multi-tasking
Task 1
Task 2
Task N
Merge & Test

Multiple Variations
Task 1
Variation 1
Variation 2
Variation 3
Test and Choose

Interface text:
AIE
Microsoft
AI Engineer World’s Fair
WorkOS
aws
smol ai

### Multiple variations

For a React drag-and-drop task, parallel agents can try different libraries or write tests first. The results are then tested and one approach is chosen.

[4:43](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=283s) [A task branches into three approaches: React Beautiful Dnd, dnd-kit, and writing tests first; the results are tested and chosen.](https://assets.ai.engineer/sites/aiecode2025/sha256/f7c2e50ad8d2a60dd9a85bb2017ab40b1442a3f4d562fb0d88abbecb0d2f6b37.webp)

Multiple variations is running a task in parallel with different approaches

Task to be done

“Try using React Beautiful Dnd”
“Use dnd-kit”
“Write the tests first”

Test & Choose

Event branding: AIE; Microsoft; AI Engineer World’s Fair; WorkOS; aws; smol ai

### Demo Time

The speaker introduces a demo using the conference schedule website.

[5:16](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=316s) [A dark slide with the words Demo Time.](https://assets.ai.engineer/sites/aiecode2025/sha256/be78de4ef1df8da3a029b4ce527e9340dee0cdf19f85282d116d09a3cf5b4d8a.webp)

Demo Time

AIE
AI Engineer
World’s F[illegible]
Graphit[illegible]
Microsoft
aws
smol ai

### Conference schedule website

The presenter starts the demo on the conference schedule page, which offers session JSON for custom views and identifies Sessionize as the most up-to-date schedule.

[5:26](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=326s) [The conference schedule page shows venue information and links to session data.](https://assets.ai.engineer/sites/aiecode2025/sha256/854b61f15a0b8245f8312fb7936224af0d6b76ce25c94194ee5bc4b4c0335e6d.webp)

World's Fair 2025 Schedule

SF Marriott Marquis, June 3–5, 2025 · San Francisco
Foothill/SOMA rooms are on Level 2
Golden Gate Ballrooms are on B1
Yerba Buena Ballrooms and Salons are on B2
Google Maps   Floor Plans

To import all sessions to your calendar, click this iCal link.

For hackers: Get all sessions in JSON (or raw JSON or speakers JSON) for your own vibecoded view! We manually update this JSON dump regularly but the Sessionize schedule is the most up to date source of truth.

Unofficial Views (may be out of date): @noodlesoup's app (Tinder-style talk discovery) or

Interface text:
ai.engineer/schedule
AI Engineer World's Fair
AI (MCP/llms.txt)
Side Events
Schedule
Speakers
Sponsors
Venue & Hotel
Buy 2025 Tickets
Talk to AIE
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 5 11:38 AM

### Schedule grid

The speaker points out the schedule’s horizontal scrolling as the grid clips its leftmost track. Keynote sessions span the track columns below.

[5:42](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=342s) [A conference schedule grid shows track columns and keynote sessions, with content clipped at the left edge.](https://assets.ai.engineer/sites/aiecode2025/sha256/7f6ff3a86ebd3493ed9eddd0fb6e4864ca56015af86b8b91774e30bc2921d19e.webp)

@pallavmac's app (list+bookmarking) or Hebe Hillhorst's app or @CedricVidal's iOS TestFlight (vibecoded).

[illegible]lden Gate [illegible]llroom C: [illegible] in the [illegible]rtune 500
SOMA: AI Architects
Yerba Buena Ballroom 7&8: SWE Agents
Yerba Buena Ballroom 2-6: Reasoning + RL
Golden Gate Ballroom A: Retrieval + Search
Golden Gate Ballroom B: Evals
Foothill C: Security
Foothill G 1&2: Design Engineering
Foothill F: Generative Media
Foothill E: Autonomy + Robotics

KEYNOTE/GENERAL SESSION (YERBA BUENA 7&8) 9:25 am → 20 min
Thinking Deeper in Gemini
Jack Rae
Keynote  Keynote

KEYNOTE/GENERAL SESSION (YERBA BUENA 7&8) 9:45 am → 5 min
Why should anyone care about Evals?
Manu Goyal

KEYNOTE/GENERAL SESSION (YERBA BUENA 7&8) 9:50 am → 20 min
Containing Agent Chaos
Solomon Hykes

Interface text:
AI Engineer World's Fair
AI (MCP/llms.txt)
Side Events
Schedule
Speakers
Sponsors
Venue & Hotel
Buy 2025 Tickets
Talk to AIE
ai.engineer/schedule
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 5 11:38 AM

### Schedule data and unofficial views

The conference publishes session JSON for people to build their own views. The page lists Pallav’s bookmarking app among several unofficial alternatives and identifies the Sessionize schedule as the most up-to-date source.

[5:47](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=347s) [The conference schedule page lists session data links and unofficial schedule applications.](https://assets.ai.engineer/sites/aiecode2025/sha256/0b4073e38e17072157fcd418e94b8ef9c53eb54c43be29855863d5223c261040.webp)

SF Marriott Marquis, June 3–5, 2025 · San Francisco
Foothill/SOMA rooms are on Level 2
Golden Gate Ballrooms are on B1
Yerba Buena Ballrooms and Salons are on B2
Google Maps  Floor Plans

To import all sessions to your calendar, click this iCal link.

For hackers: Get all sessions in JSON (or raw JSON or speakers JSON) for your own vibecoded view! We manually update this JSON dump regularly but the Sessionize schedule is the most up to date source of truth.

Unofficial Views (may be out of date): @noodlesoup's app (Tinder-style talk discovery) or @pallavmac's app (list+bookmarking) or Hebe Hillhorst's app or @CedricVidal's iOS TestFlight (vibecoded).

Golden

Interface text:
AI Engineer World's Fair
AI (MCP/llms.txt)  Side Events  Schedule  Speakers  Sponsors  Venue & Hotel  Buy 2025 Tickets
Talk to AIE
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
ai.engineer/schedule
Thu Jun 5 11:38 AM

### Conference schedule app

Pallav’s schedule app lets attendees filter sessions, bookmark talks, and mark plans to attend. The speaker uses it to track sessions and will clone it for a Jules example.

[5:55](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=355s) [A conference schedule showing session cards, day filters, bookmarks, and attendance controls.](https://assets.ai.engineer/sites/aiecode2025/sha256/8fb61a0c1e047f500b2220863a15001d9ba4d278da06ebc03cb931af956792ac.webp)

AI Engineer World's Fair 2025 Schedule
June 3-5, 2025 · San Francisco · 👨‍💻 @pallavmac
Contribute   Contact   Schedule up to date

Talks   Speakers   All Tracks
List   Calendar   All Days   Tuesday June 3   Wednesday June 4   Thursday June 5   Bookmarked   Going
Compact   Search

Jun 5   9:05 AM - 9:25 AM   20 min
A year of Gemini progress + what comes next
Over the last year, Google and Gemini models have shown rapid progress across all dimensions (model, product, etc). Let's highlight all the work that has...
Logan Kilpatrick
Google
Product, Google Deepmind
Introductory and overview   Case Study/War Story

Jun 5   9:25 AM - 9:45 AM   20 min
Thinking Deeper in Gemini
Progress towards general intelligence has been marked by identifying fundamental intelligence bottlenecks within existing models and developing...
Jack Rae
Google DeepMind
Principal Research Scientist
Intermediate   Technical deep dive   Keynote

Jun 5   9:45 AM - 9:50 AM   5 min
Why should anyone care about Evals?
An introduction to the evals track
Manu Goyal
Braintrust
Founding Engineer, Braintrust
Introductory and overview   Introductory (landscape)

Interface text:
Chrome   File   Edit   View   History   Bookmarks   Profiles   Tab   Window   Help
Thu Jun 5 11:38 AM
localhost:3000

### Development task list

The presenter starts with seven Linear tasks and plans to run Jest and Playwright testing in parallel, then compare their test coverage.

[6:27](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=387s) [An issue list includes testing, calendar, accessibility, and performance tasks.](https://assets.ai.engineer/sites/aiecode2025/sha256/7c142513e20aecd37201f166df5b69f850f04288363eacf1ff6fad5110d357f1.webp)

Todo 7
STU-14  Add tests using JEST  Jun 5
STU-15  Add tests using Playwright  Jun 5
STU-10  Add a session to Google Calendar  Jun 4
STU-17  Add an AI summary when I click on a description  Jun 5
STU-18  Use hardcoded routes instead of sessions on the query string  Jun 5
STU-13  Perform Accessibility Audit  Jun 4
STU-19  Improve Lighthouse scores  Jun 5

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 5 11:39 AM
linear.app/stuff-jules-can-improve/team/STU/active
stuff-jules-c...
Inbox
My issues
Workspace
Projects
Views
More
Your teams
Stuff-jules-can-improve
Issues
Projects
Views
All issues  Active  Backlog
Filter  Display
Add tests using JEST
What's new
Automate intake with Asks fields and Triage routing
https://linear.app/stuff-jules-can-improve/issue/STU-14/add-tests-using-jest

### Development task list on stage

The presenter starts with tests to check the agent’s work, planning to run Jest and Playwright variations in parallel and compare their coverage before tackling the other tasks.

[6:37](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=397s) [The issue list appears beside the presenter and conference branding.](https://assets.ai.engineer/sites/aiecode2025/sha256/56acdfbd92d78fbefa3c61efff6baaa52adc7fb191896f7b2dee1be1b1bf8570.webp)

Todo 7
STU-14  Add tests using JEST  Jun 5
STU-15  Add tests using Playwright  Jun 5
STU-10  Add a session to Google Calendar  Jun 4
STU-17  Add an AI summary when I click on a description  Jun 5
STU-18  Use hardcoded routes instead of sessions on the query string  Jun 5
STU-13  Perform Accessibility Audit  Jun 4
STU-19  Improve Lighthouse scores  Jun 5

AIE
AI Engineer World’s Fair
vellum
Microsoft
aws
smol ai

Interface text:
linear.app/stuff-jules-can-improve/team/STU/active
stuff-jules-c...
Inbox
My issues
Workspace
Projects
Views
More
Your teams
Stuff-jules-can-improve
Issues
Projects
Views
All issues
Active
Backlog
Filter
Display
Add tests using JEST
What’s new

### Requesting Jest tests in Jules

The presenter asks Jules to add Jest tests to a scheduling app and plans a parallel Playwright run, then intends to choose between them by test coverage.

[6:45](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=405s) [A Jules task prompt requests Jest tests for a conference scheduling app.](https://assets.ai.engineer/sites/aiecode2025/sha256/4e38c1e8f49c7612ef27089afba97b40c7eb0ac72b5cdb5641a4a8f52bf022ad.webp)

Meet Jules: an async development agent. Jules tackles bugs, small feature requests, and other software engineering tasks, with direct export to GitHub.

rustinb303/aiengineer-schedule
main

This is a conference scheduling app. We are going to install tests.

Install a testing framework and write tests for all the major functionality such as selecting sessions, bookmarking etc. Run the tests and make sure they pass. At the end, lot to console your estimated test coverage. Append information about running tests to the readme.md file.

See readme.md for details on how to build and run the app.

Use the JEST framework.

Internal settings (optional)
CMD+Enter
Give me a plan
How it works
Need inspiration?

Interface text:
jules.google.com/task
jules beta
Feedback
Search for repos or tasks
Recent tasks
Codebases
rustinb303/ai-pr-watcher
rustinb303/AIcoderstats
rustinb303/aiengineer-schedule
rustinb303/bolt.new
rustinb303/firebase-ios-sdk
rustinb303/flutterfire
rustinb303/hipapp
rustinb303/make-real-starter
rustinb303/tetris-react
rustinb303/trackcommits-jules
simpsoka/jules-reference
google-labs-code/jolly-boat

AIE
AI Engineer World's Fair
vellum
Microsoft
aws
smol ai

### Jules testing plan

After the testing plan is approved, Jules begins writing CalendarView tests. The visible plan also calls for running the tests, estimating coverage, and updating the README.

[7:50](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=470s) [Jules shows an approved test plan and a current step to write calendar view tests.](https://assets.ai.engineer/sites/aiecode2025/sha256/f006d0505f52e49014f3475b51b454988b360acbeb014656d5d543f4e1f58b94.webp)

This is a conference scheduling app. We are going to install tests. Install a testing framework and write tests for all the major functionality such as selecting sessions, bookmarking etc. R...

9 Run all tests and ensure they pass.
10 Log estimated test coverage.
11 Update README.md with testing information.
12 Submit the changes.

Hide

I've created a plan to add tests to the project. Please review it and let me know if you have any feedback. Otherwise, let me know if it looks good, and I'll get started.

Plan approved 🎉

Working on
Write tests for CalendarView.tsx.
Test that the calendar view renders correctly.

Interface text:
Chrome: jules.google.com/task/2821290515955692508
jules beta
rustinb303/aiengineer-schedule
Feedback
Search for repos or tasks
Recent tasks
Codebases
rustinb303/ai-pr-watcher 1
rustinb303/AIcoderstats
rustinb303/aiengineer-schedule 3
rustinb303/bolt.new
rustinb303/firebase-ios-sdk
rustinb303/flutterfire 1
rustinb303/hipapp 2
rustinb303/make-real-starter
rustinb303/tetris-react 14
rustinb303/trackcommits-jules
simpsoka/jules-reference
google-labs-code/jolly-boat
Talk to Jules
Jules can make mistakes so double-check it and use code with caution

AIE
AI Engineer World's Fair
vellum
Microsoft
aws
smol ai

[8:10](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=490s) [Jules shows an approved testing plan and work on calendar-view tests.](https://assets.ai.engineer/sites/aiecode2025/sha256/dc100fd0a520e7d7f0923c068578cca98bf73d2a73f26086eb1139fb7e2ad15d.webp)

This is a conference scheduling app. We are going to install tests. Install a testing framework and write tests for all the major functionality such as selecting sessions, bookmarking etc. R...

9 Run all tests and ensure they pass.
10 Log estimated test coverage.
11 Update README.md with testing information.
12 Submit the changes.

Hide

I've created a plan to add tests to the project. Please review it and let me know if you have any feedback. Otherwise, let me know if it looks good, and I'll get started.

Plan approved 🎉

Working on
Write tests for CalendarView.tsx.
Test that the calendar view renders correctly.

Interface text:
Chrome: jules.google.com/task/2821290515955692508
Tab tooltip: This is a conference scheduling app. We are going to install tests. ...
jules.google.com
Memory usage: 501 MB
jules beta
rustinb303/aiengineer-schedule
Feedback
Search for repos or tasks
Recent tasks
Codebases
rustinb303/ai-pr-watcher 1
rustinb303/AIcoderstats
rustinb303/aiengineer-schedule 3
rustinb303/bolt.new
rustinb303/firebase-ios-sdk
rustinb303/flutterfire 1
rustinb303/hipapp 2
rustinb303/make-real-starter
rustinb303/tetris-react 14
rustinb303/trackcommits-jules
simpsoka/jules-reference
google-labs-code/jolly-boat
Talk to Jules
Jules can make mistakes so double-check it and use code with caution

AIE
AI Engineer World's Fair
vellum
Microsoft
aws
smol ai

### Installing Jest

Jules installs Jest and adds a README command for running tests, giving it a reference for future changes.

[8:27](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=507s) [Jules reports installing Jest beside a README diff with test instructions.](https://assets.ai.engineer/sites/aiecode2025/sha256/4de3aa0f96784f2e91b5cbc28e6e2698f424c87f36e29bb45df956118c66efcb.webp)

Submit the changes.

I've created a plan to install Jest, write tests for the core functionalities, ensure they pass, estimate coverage, and update the README. Please review the plan and let me know if you have any feedback. Otherwise, let me know if you approve, and I'll get started.

Plan approved 🎉

Ran: npm install -D jest jest-environment-jsdom @testing-library/react @testing-library/jest-dom @babel/preset-env @babel/preset-react @babel/preset-typescript ts-jest

Installed Jest, configured it for the Next.js project, and added a test script to package.json.

Updated jest.config.js, package-lock.json, and package.json

README.md

pnpm dev

Open [http://localhost:3000](http://localhost:3000) to view the app.

## Running Tests

This project uses [Jest](https://jestjs.io/) for testing. To run the...

pnpm test

This will execute all unit and integration tests, providing a summar...

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request...

## 📄 License

This project is open source and available under the [MIT License]...

## 🙏 Acknowledgments

- Built for the AI Engineer World's Fair 2025
- Thanks to all contributors and the open source community

Interface text:
jules beta
rustinb303/aiengineer-schedule
This is a conference scheduling app. We are going to install tests. Install a testing framew...
Code
README.md
SearchOverlay.tsx
useBookmarksAndStars.test.ts
Search for repos or tasks
Recent tasks
View more
Codebases
rustinb303/ai-pr-watcher
rustinb303/AIcoderstats
Talk to Jules
Jules can make mistakes so double-check it and use code with caution
jules.google.com/task/1580055755137156923
AIE
AI Engineer World's Fair
daily
Microsoft
aws
smol ai

### Session tests

Jules runs session-selection and detail-view tests, showing two failed runs before a passing run. The README alongside records how to run the Jest suite.

[8:46](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=526s) [Jules shows test runs and reports passing tests for session selection and details.](https://assets.ai.engineer/sites/aiecode2025/sha256/affc086c9388d00b96c35abb6a1b5b010c525cf5eac85af0b27b2445e343a6fe.webp)

This is a conference scheduling app. We are going to install tests. Install a testing framew...

Ran: npm install --save-dev @testing-library/jest-dom

Ran: npm test components/__tests__/SessionCard.test.tsx
    components/__tests__/SessionDetailModal.test.tsx

Ran: npm test components/__tests__/SessionCard.test.tsx
    components/__tests__/SessionDetailModal.test.tsx

Ran: npm test components/__tests__/SessionCard.test.tsx
    components/__tests__/SessionDetailModal.test.tsx

Wrote and passed tests for session selection (SessionCard.tsx) and session details view (SessionDetailModal.tsx).

Updated components/__tests__/SessionCard.test.tsx
components/__tests__/SessionDetailModal.test.tsx
jest.config.js and 1 more

README.md:
pnpm dev
```

Open [http://localhost:3000](http://localhost:3000) to view the app.

## Running Tests

This project uses [Jest](https://jestjs.io/) for testing. To run the [illegible]

```bash
pnpm test
```

This will execute all unit and integration tests, providing a summar[illegible]

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request[illegible]

## 📄 License

This project is open source and available under the [MIT License]([illegible]

## 🙏 Acknowledgments

- Built for the AI Engineer World's Fair 2025
- Thanks to all contributors and the open source community

Interface text:
jules beta
jules.google.com/task/1580055755137156923
rustinb303/aiengineer-schedule
Search for repos or tasks
Recent tasks
This is a conference schedulin...
This is a simple conference ca...
run a simple accessibility audi...
This is a conference schedulin...
This is a conference schedulin...
Run an accessibility audit and ...
This is a simple conference ca...
This is a simple conference ca...
This is a simple conference ca...
I'd like you to do an accessibili...
View more
Codebases
rustinb303/ai-pr-watcher
rustinb303/AIcoderstats
Code
README.md
SearchOverlay.tsx
useBookmarksAndStars.test.ts
useBookmarksAndStars.t[illegible]
Talk to Jules
Jules can make mistakes so double-check it and use code with caution
Feedback
AIE
AI Engineer World's Fair
daily
Microsoft
aws
smol ai

### Starring tests

Jules shows a failed test run followed by a passing run for the starring hook and session components. The README also documents how to run the Jest suite.

[8:48](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=528s) [Jules reports passing tests for starring functionality.](https://assets.ai.engineer/sites/aiecode2025/sha256/171f14334f4f767a434a36b937182b42a6c93471c8ad5a3b8d226a72831c93bb.webp)

and app/hooks/useBookmarksAndStars.ts

Ran: npm test
  app/hooks/__tests__/useBookmarksAndStars.test.ts
  components/__tests__/SessionCard.test.tsx
  components/__tests__/SessionDetailModal.test.tsx

Ran: npm test
  app/hooks/__tests__/useBookmarksAndStars.test.ts
  components/__tests__/SessionCard.test.tsx
  components/__tests__/SessionDetailModal.test.tsx

Wrote and passed tests for starring functionality, ensuring comprehensive coverage in the useBookmarksAndStars hook and relevant components like SessionCard and SessionDetailModal.

Updated app/hooks/__tests__/useBookmarksAndStars.test.ts
and components/__tests__/SessionCard.test.tsx

README.md
pnpm dev
```

Open [http://localhost:3000](http://localhost:3000) to view the app.

## Running Tests

This project uses [Jest](https://jestjs.io/) for testing. To run the [illegible]

```bash
pnpm test
```

This will execute all unit and integration tests, providing a summar[illegible]

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request[illegible]

## 📄 License

This project is open source and available under the [MIT License]([illegible]

## 🙏 Acknowledgments

- Built for the AI Engineer World's Fair 2025
- Thanks to all contributors and the open source community

Interface text:
Chrome
jules.google.com/task/1580055755137156923
jules beta
rustinb303/aiengineer-schedule
Feedback
This is a conference scheduling app. We are going to install tests. Install a testing framew...
Code
README.md
SearchOverlay.tsx
useBookmarksAndStars.test.ts
Search for repos or tasks
Recent tasks
This is a conference schedulin...
This is a simple conference ca...
run a simple accessibility audi...
Run an accessibility audit and ...
I'd like you to do an accessibili...
View more
Codebases
rustinb303/ai-pr-watcher
rustinb303/AIcoderstats
Today 07:15
Talk to Jules
Jules can make mistakes so double-check it and use code with caution
AIE
AI Engineer World's Fair
daily
Microsoft
aws
smol ai

### Calendar button request

After merging the tests, the presenter asks Jules to add a Google Calendar button to each session card. Jules lays out changes to the icon, card component, and tests alongside a code diff.

[9:15](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=555s) [Jules displays a request and plan to add a Google Calendar button to conference session cards.](https://assets.ai.engineer/sites/aiecode2025/sha256/b8e29b4c51b1db753f09790e1a04d9d84b49a5029507d8b15a7b8f98a7d9d7de.webp)

This is a simple conference calendar app. On each card, below the bookmark and check, I'd like you to add a “Add to Google Calendar” button with appropriate icon. When clicked it should use the data from the card to create the appropriate calendar invitation.

You will know you got it write when the app renders the calendar icon correctly with the correct link. Run the existing tests and add tests.

Look at readme.md for information on buiding and running the app.

1. Add a new calendar icon to app/utils/svgs.tsx.
2. Modify app/components/SessionCard.tsx to include the new button.
3. Add tests for the new functionality.
4. Run all tests and ensure they pass.

Code
SessionCard.tsx  svgs.tsx  SessionCard.test.tsx  pnpm-lock.yaml
/app/components/SessionCard.tsx

"use client";
import { Session, Speaker, Room } from "../types/schedule";
import { localStorageUtils } from "../utils/localStorage";
import { formatTime, formatDate, getDuration } from "../utils/dateTi[illegible]
- import { CompanyIcon, RoomIcon, StarIcon } from "../utils/svgs";
+ import { CompanyIcon, RoomIcon, StarIcon, CalendarIcon } from "../ut[illegible]

interface SessionCardProps {
  session: Session;
  speaker?: Speaker;
  room?: Room;
  onClick?: () => void;
  isBookmarked?: boolean;
  isStarred?: boolean;
  isCompactView?: boolean;
  showBookmarkedFilter?: boolean;
  showStarredFilter?: boolean;
  onBookmarkToggle?: () => void;
  onStarToggle?: () => void;
}

export default function SessionCard({
  session,
  speaker,
  room,
  onClick,
  isBookmarked = false,
  isStarred = false,
  isCompactView = false,

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Thu Jun 5 11:42 AM
jules.google.com/task/5996003018717872028
jules  beta
rustinb303/aiengineer-schedule
Feedback
Search for repos or tasks
Recent tasks
This is a conference schedulin...
This is a simple conference ca...
run a simple accessibility audi...
This is a conference schedulin...
This is a conference schedulin...
Run an accessibility audit and ...
This is a simple conference ca...
This is a simple conference ca...
This is a simple conference ca...
I'd like you to do an accessibili...
View more
Codebases
rustinb303/ai-pr-watcher
rustinb303/AIcoderstats
Today 07:39
Talk to Jules
Jules can make mistakes so double-check it and use code with caution

AIE
AI Engineer World's Fair
daily
Microsoft
aws
smol ai

## Full transcript

[0:00](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=0s) [upbeat music] Hi, everyone.

[0:15](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=15s) I'm Rustin. I'm a product manager with Google Labs, and really thrilled to be here and get to speak to you today. This is really like a, a dream come true.

[0:25](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=25s) So I'm an engineer at heart. This is my first compiler, Borland C++ 3.1. It came in the mail on 10 five-and-a-half inch floppy disks. I ordered it from AOL Classifieds.

[0:37](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=37s) It was amazing. This is my bulletin board, yeah, that I hosted out of my parents' closet on salvaged computers. And I just think it's ironic that when I saw AI come out, I recognized the text-based interfaces perfectly from hosting bulletin boards.

[0:53](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=53s) And then when I saw this, like many of you, I dedicated my career to AI coding. And this is ChatGPT 3.5. Isn't it crazy that we-- that how slow this is, and this used to be state-of-the-art only two years ago?

[1:10](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=70s) It's pretty amazing. Right now, I'm a product manager for Jules, and Jules is an asynchronous coding agent meant to run in the background and do all those tasks that you don't wanna do in parallel in the background.

[1:26](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=86s) And we launched this just two weeks ago at I/O to everyone, everywhere, all at once, for free,

[1:37](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=97s) while Josh was up on the stage trying to demo other Google Labs products. [laughs] And so he called us, and we said, "Oh, we gotta shut it down so that we can demo other products," and, and luckily, we got it up and going.

[1:49](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=109s) But it was a super exciting launch, and the best part about it is to see these use cases where this is what we really wanna solve. We want to do the laundry, so to say, so that you can focus on the art of coding.

[2:03](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=123s) So the next time Firebase updates their SDK, Jules can do that for you, or if you just wanna develop from your phone, Jules can do that for you. So in the last two weeks, we've had forty thousand public commits, and we're super excited what we can bring to the open source world.

[2:19](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=139s) So, but as developers, we're meant to think serially. We take a task from the queue, we work on it, we go onto the next one. That's our default workflow.

[2:30](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=150s) Today, we'll learn about how to maximize parallel agents. I'll try a real-world demo, and we'll go through a real-world use case, and then I'll go through some best practices we've learned from watching people use Jules.

[2:44](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=164s) So for this parallel process really to work well, we need to get better with AI at the beginning and the end of the workflow. Meaning, if it's on me to now I just have to write a bunch of tasks all day, that's not fun, and if I'm reviewing PRs and handling merge messes at the end of the

[3:01](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=181s) day, that's not gonna work well either. So luckily, help is on the way. So for example, AI can easily work through backlogs, bug reports to create tasks for you, with you, and then, uh, at the end of the SDLC, help is on the way where we can use critic agents, merging agents that can bring everything together and

[3:24](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=204s) make it so that this tr-- this parallel workflow that we've envisioned can really come together and not drive us crazy.

[3:33](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=213s) Remote agents are uniquely suited for this. Agents inside of our IDE are always gonna be limited by our laptop. And when you have these remote agents in the cloud, essentially agents as a service, they're infinitely scalable, they're always connected, and then you can develop from anywhere from any device.

[3:51](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=231s) We've seen two types of parallelism emerging. This is the type that we expected, which is multitasking. Oh, I'm just-- I have ten different things on my backlog. Let's do them all at once, and then we'll merge them together and test them.

[4:08](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=248s) Interestingly, you saw an example of the second type this morning with Solomon from Dagger showing how he wanted three different views of his website at the same time. This was the emergent behavior we didn't expect, which is multiple variations.

[4:22](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=262s) Essentially, we see users taking a task, especially if it's a complex task, and saying, "Try it this way, try it that way," or, "Give me this variation to look at," or multiple variations to look at, and then you can test and choose.

[4:38](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=278s) And we can have the agents test and choose the best ones, or the user can, can test and choose.

[4:45](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=285s) So for example, we see lots of people who are working on a front-end task, test, and they're in a React app, and they're saying, "I'm adding drag and drop.

[4:55](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=295s) Maybe try it using this library, uh, the react-beautiful-dnd, beautiful drag and drop, or maybe use dnd-kit, or maybe try it using the test first." And in this parallel asynchronous environment, you can just spin up multiple agents at the same time.

[5:11](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=311s) They can try it, they can easily come back together, choose the best one, and you're off to the races. Okay. Demo time.

[5:21](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=321s) So exit out of this. For a demo, I'm going to use the conference schedule website. And

[5:32](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=332s) swyx, for all his skills, as you can see, has probably not spent a lot of time designing the, the schedule website, as you can see there. Anytime there's a horizontal scroll, scroll bar, uh, we, we know that's a problem.

[5:46](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=346s) But luckily, they knew that, and they said, "We're just gonna publish the JSON feed, and we'll let, we'll let hackers hack. Uh, engineers do what we do, and let's build from it."

[5:56](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=356s) So Pallav, who is here, built this amazing, uh, conference site where you can favorite things, you can bookmark things, and, uh, this is what I use to keep track of my, my sessions for the conference.

[6:09](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=369s) And so I messaged him, I said, "Hey, can I u- can I use, clone this and use this for, as an example for Jules?" And Pallav said, "Oh yeah, sure.

[6:18](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=378s) Actually, I was sitting in my last session on my phone, and I fixed a bud- a bug using Jules." So I thought that was perfect. So this is how I would start something like this, is I would go into Linear, and I would say, "Okay, first thing we need to do," we just heard Scott talk about it,

[6:34](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=394s) is I want to add a way to know if this parallel agent is gonna do a bunch of things at the same time, that it's getting it right. So first we're gonna add in some tests, and then I'm gonna actually, I'm gonna kick this one off while I'm thinking about it.

[6:50](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=410s) And then, using that idea of multiple variations, I'm gonna say, "Add it with Jest, and add it with, add it with Playwright at the same time," and then we'll look at the test coverage, and we'll choose the one that has the best test coverage.

[7:04](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=424s) Once that's done, then I can go to that other mode of parallelism, and I say, "I would like a link to add a session to my Google Calendar. I would like an AI summary when I click on a description."

[7:14](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=434s) And these are all features, but what I'm really excited for is for AI to do the stuff that we never seem to get to, such as accessibility t- audits and security audits, all those things that seem to go on the backlog but are really important, and I'm super excited for AI to do that.

[7:31](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=451s) So we're gonna also have it do an accessibility audit and improve our Lighthouse scores at the same time. This is mostly a front-end demo because, well, I'm mostly a front-end engineer, and it, it's a better visual representation, but we've seen all these, all these apply to the back end as well.

[7:50](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=470s) Okay, so here's Jules. We a- told it to add, add tests in a Jest framework. It connects to my GitHub, all my GitHub repos, and, uh, it's gonna give me a plan.

[8:02](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=482s) That looks about right. I can see it's gonna test the calendar, the search relay, the session. That sounds great. I can approve the plan. So Google, so Jules now has its own VM in the cloud.

[8:13](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=493s) It's cloned my whole, whole code base. It can run all the commands that I can run, and un- and importantly, after it has these tests, it can run these tests so it can know when we add a new feature if it gets things right.

[8:26](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=506s) So I'm gonna fast-forward a little bit here. And so this is adding, uh, Jest tests. You can see all the, the things it's, or all the components it's, it's added to the tests.

[8:39](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=519s) It's added to the README, so now next time that it goes to add something, it'll look at the README and remind itself, "Oh, this is how I run the tests."

[8:47](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=527s) And let's see how it did on test coverage.

[8:52](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=532s) Okay, we got down to, looks like about, estimated test coverage looked like about 80%, so that's pretty good. We could compare that with Playwright, and then we could just choose the, the one we like the best.

[9:06](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=546s) We merge that into main, and now we're, we're off to the races. So that, again, it's automatically integrated into GitHub. We merge that into, into main, and now we can start saying, "Okay, now I want a calendar link."

[9:20](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=560s) So I want a calendar button that can go in, and Jules will work on that, and then sure enough, it ran the test. The test didn't pass the first time.

[9:29](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=569s) It makes some changes. Now the tests pa- pass, and I can review this code. Eventually I could look at this in Jules browser, but I feel pretty confident about testing this knowing that all the tests pass.

[9:42](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=582s) Similarly, for, uh, the Gemini summaries, when I click on a description, I can get a Gemini summary. I put this one in an emulator, or I emulated a mobile view, just so you can see I could have done this from my phone.

[9:54](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=594s) So this is making accessibility audit, fixing any issues from my phone. Uh, never mind the console errors. Jules is going to fix those. And then I can go back.

[10:07](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=607s) I can... Now we have this big merge we need to do, and to be honest, I ran out of time to finish the merge, and Jules should help me with this merge, and it's called an Octopus merge.

[10:18](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=618s) So surely Jules, as a squid, should help with the Oc- Octopus merge. But let's just pull our, check out our add to calendar button.

[10:28](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=628s) Go back to this. Localhost. Refresh. And now I have a calendar button. Let's test it. Okay, let's add this to my calendar to make sure I know to come to my own talk, and there it's on, it's on my calendar.

[10:45](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=645s) I could then now, again, pull this back into the main branch, and now everybody at the conference has the ability to add, add sessions to their Goo- to their Google Calendar, along with everything else that we saw there, a full test suite, all the accessibility audits, a Lighthouse scores improvement, and that took me all about an hour,

[11:06](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=666s) and managing the, the parallel process in the back end.

[11:11](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=671s) Okay. So, in fair- in summary, the secret to working in parallel is a clear definition of success, because nobody wants to review PRs all day. So think before you get started, "How am I gonna easily verify that this works?"

[11:28](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=688s) Again, Scott hit on this as well. Create this agreement with the agent. Tell it, "Don't stop until you see this," or, "Don't stop until this works." And then a robu- robust merge and test framework at the end to put everything back together, and help is coming.

[11:45](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=705s) This is how I prompt for Jules. I give it a brief overview of the task. I tell it when it will know when it, it got right, any helpful context, and then I'll, at the end, I'll append a simple broad approach, and then I'll change that last line maybe two or three times, depending on the complexity of

[12:02](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=722s) the task. So for example, if I need to log this number from this webpage every day, I'll say, "Today the number is X, so log the number to the console and don't stop until the number is X."

[12:14](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=734s) That was a simple test that I wrote in. It'll keep going. I give it a helpful context like, "This is the search query," and then I'll say, "Use Puppeteer," and then I'll clone that t- task because I can, it's in the cloud, and I'll say, "Use Playwright."

[12:30](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=750s) So again, have an abundance mindset. We're used to working on a single thing at a time. Easy verification makes it so now we can work on multiple things at the same time, try lots of things.

[12:41](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=761s) As we saw this morning, look at different variations. We can, with a parallel process, we can, we have the ability now to try things that we would never have tried before.

[12:52](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=772s) Let AI help with those bookends, the task creation, and then the merge and, and test part, and context. Keep using MD files or links to documentation to getting started do- documents.

[13:03](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=783s) The more context, the better. And then we tell people, "Just throw everything in there." Jules and other agents are pretty good at actually sorting out which context is important, so more context is better at this point, but maybe that's just for, uh, the Gemini models, which I should have mentioned, Jules is powered by Gemini 2.5 Pro.

[13:24](https://www.youtube.com/watch?v=X4BwOu0GWb8&t=804s) Quick shout-out, thank you, Team Jules. Couldn't have done any of this without you. If you have any questions, you can DM me. I'm Rustin Banks, [REDACTED:username] on X. Thanks, everybody. [upbeat music]
