“I don’t want an AI that watches me code. I want one that codes while I sleep.”
Let me describe a workflow you’ve probably lived through.
It’s 11 PM. Work sprint is done. Your GitHub notifications tab has that little red badge you’ve been ignoring all day. Somewhere in there is a dependency issue someone filed on your open source project two weeks ago. It’s a valid issue. You know exactly how to fix it. It’ll take you 45 minutes you don’t have tonight.
So you close the tab. Tell yourself you’ll get to it this weekend.
<a href="https://medium.com/media/f5bbb18d72481baaf167dccf487c423d/href">https://medium.com/media/f5bbb18d72481baaf167dccf487c423d/href</a>
Except you won’t, because the weekend brings three other things, and the issue quietly ages into the backlog, and the backlog quietly becomes a graveyard, and your open source project quietly becomes “that thing I used to maintain actively.”
I’ve been that developer. I was that developer.
Then I met Jules — Google’s autonomous AI coding agent — and the whole maintenance dynamic shifted.
The Problem With “AI Coding Assistants” 😤
Before I talk about what Jules does right, I want to be honest about what most AI coding tools actually are.
They’re synchronous. They need you present. You write a prompt, you watch the output, you guide the next step. It’s collaborative in the best case — and babysitting in the worst case. You’re not offloading work. You’re doing the same work, faster, with a very smart autocomplete.
That’s useful. I use those tools. But for open source maintenance? That model breaks down immediately.
Open source maintenance isn’t glamorous work. It’s:
- Dependency versions falling behind
- Test coverage that needs to exist but doesn’t yet
- Bug reports sitting in the queue while you’re heads-down in your day job
- Contributors who opened a PR two weeks ago and are still waiting on a review
These tasks don’t need me watching over a shoulder. They need an agent that can take the task, understand the codebase, make the change, and come back with a PR I can review when I have 10 minutes.
That’s exactly what Jules does. And the distinction matters.
Personal reflection #1: The moment I understood Jules wasn’t a coding assistant but an autonomous coding agent was when I kicked off my first task and just… closed my laptop. Not minimized it. Closed it. And when I came back, there was a pull request waiting. That’s a different product category entirely.
<a href="https://medium.com/media/f444d13761a983c091cd65ae25b0ab84/href">https://medium.com/media/f444d13761a983c091cd65ae25b0ab84/href</a>
What Is Jules, Exactly? 🧬
Jules is Google’s autonomous, asynchronous AI coding agent. It was introduced in December 2024 as a Google Labs project, went into public beta at Google I/O in May 2025, exited beta in August 2025, and is now generally available with structured pricing tiers.
Here’s how it works under the hood:
- You connect Jules to a GitHub repository
- Jules clones your codebase into a secure, isolated Google Cloud virtual machine
- It reads your entire project — not just the relevant file, the entire codebase
- It builds a plan and shows it to you before touching a single line
- You review the plan, approve it, and Jules executes
- It comes back with a clean diff and a pull request
- You review, merge, move on
The key architecture detail here: Jules runs in a sandboxed Google Cloud VM. Your code runs in an isolated environment. It’s private by default and does not train on your private code.
It’s powered by Gemini 2.5 Pro, which gives Jules the reasoning depth to not just pattern-match your code but actually understand architecture decisions, trace dependencies, and think through the consequences of a change before making it.
Actionable takeaway: Jules is not a chatbot wrapper around a coding model. It’s closer to a background teammate you delegate to, then review like you would any other contributor’s PR.
<a href="https://medium.com/media/9c019e84f6c7c1fdb6ab415b0f787c40/href">https://medium.com/media/9c019e84f6c7c1fdb6ab415b0f787c40/href</a>
Async Is the Real Innovation Here ⚡
Let me explain why asynchronous matters more than most people realize.
Every other major AI coding tool right now — Cursor, Windsurf, Lovable — operates synchronously. They live inside your IDE or browser. They respond when you prompt. They need you to be there, watching, guiding, approving at every micro-step.
Jules is fundamentally different. You kick off a task, and Jules runs in the background — in a cloud VM, not on your machine — completely independent of whether your laptop is open or not. You can start a task at 9 PM, close your computer, and come back to a PR in the morning.
As someone running a full-time engineering job and maintaining multiple open source repositories, this is not a productivity improvement. It’s a qualitative shift in what’s even possible.
How I Actually Use Jules for My Projects 🛠️
Let me get specific. Because “I use AI for my open source projects” is exactly the kind of vague claim that tells you nothing.
Here are the projects I’m maintaining at github.com/TheJenilDGohel and exactly how Jules fits into each one.
Synapse — The AI Memory Layer 🟣
Synapse is my most active open source project right now — a local-first MCP server that gives AI agents persistent memory, a knowledge graph, and semantic code recall. TypeScript codebase. 74 MCP tools. Actively used and actively evolving.
The irony of using an AI agent to help maintain a project about AI agent memory is not lost on me.
The first real Jules task I gave it was a dependency audit. Synapse has a non-trivial set of npm dependencies — sqlite-vec, better-sqlite3, vector tooling, MCP SDK — and keeping them aligned is tedious work that breaks things in subtle ways if you miss something.
I typed:
“Audit all npm dependencies in Synapse for outdated packages. Bump to latest stable versions that don’t introduce breaking changes. Update any affected imports. Confirm the build still passes.”
Jules laid out its plan: which packages it intended to bump, why, and what it was checking. I read through it, approved it, went to make coffee.
When I came back: a clean PR with organized diffs, a summary explaining every bump decision, and a note flagging one dependency where the latest version had a breaking API change — so it bumped to the last safe minor instead.
That last part mattered. Jules didn’t just blindly run npm update. It reasoned about the change before making it.
Personal reflection #2: A naive tool would’ve bumped everything and left me to discover the breaking change in CI. Jules flagged it proactively. That’s the difference between a tool that automates actions and an agent that actually understands consequences.
enhanced_jailbreak_root_detection — The Flutter Security Plugin 🛡️
enhanced_jailbreak_root_detection is a multi-layered Flutter security plugin. RootBeer for Android. IOSSecuritySuite for iOS. Frida-heuristics. Magisk detection. It’s protecting data for production users at scale, which means the quality bar is high and I can’t afford regressions.
Writing exhaustive tests for a security plugin is the kind of work that’s genuinely important and genuinely tedious. Edge cases in detection logic don’t announce themselves. You have to think about every path — rooted device with no obvious indicators, emulator masquerading as a real device, Frida injection with obfuscated hooks.
I gave Jules the detection layer and asked it to write unit tests covering the non-obvious edge cases.
It read the plugin architecture — the Kotlin native bridge, the detection heuristics, the response aggregation — and wrote tests that actually reflected how the code worked. Not generic happy-path tests. Tests that targeted the specific detection layers and their failure modes.
It surfaced two edge cases I hadn’t covered.
I’m not embarrassed by that. I’m impressed by it. And I fixed both before the next release.
Actionable takeaway: Don’t use Jules just for bug fixes and dependency bumps. Test generation on security-sensitive code is one of the highest-ROI tasks you can give it. It brings a fresh read of your logic without the blind spots that come from having written it yourself.
ar_flutter_reloaded — The ARKit/ARCore Plugin 🔵
ar_flutter_reloaded is a Flutter plugin for immersive AR experiences — ARKit on iOS, ARCore on Android. Cross-platform AR development done in Dart with native bridges in Kotlin and Swift.
Platform SDK dependencies are the bane of this plugin’s existence. ARCore updates. ARKit updates. Gradle version changes. Each one can quietly break the native bridge, and the surface area spans two languages and two platform SDKs.
Jules has become my standing “bump and verify” agent for ar_flutter_reloaded. New ARCore SDK drops, I tell Jules. It traces every affected import, updates the Kotlin bindings, checks the iOS bridge for corresponding changes, runs the build, and opens a PR with a clear description contributors can actually understand.
The PR descriptions Jules writes are, honestly, better than the ones I write when I’m rushing. They explain the why, not just the what. Contributors find that useful. I find it useful when I come back to the PR six days later and have no idea what I was thinking.
The GitHub Issues Integration Is a Superpower 🔗
One of Jules’ most underrated features — and one I didn’t fully appreciate until I started using it daily — is GitHub Issues integration.
You can point Jules at an open issue and say “fix this.” Jules reads the issue, reads the codebase in context, builds a plan, and opens a PR.
For open source maintainers, this changes the triage flow entirely. I now have a jules-assigned label in my repos. When an issue comes in that's well-scoped — a clear reproduction case, a bounded fix — I label it and route it to Jules. By the time I check GitHub the next morning, there's a draft PR waiting for my review.
Contributors who filed those issues? They’re not waiting three weeks for acknowledgment. They’re getting a PR to review.
The whole dynamic shifts from “backlog guilt” to “active maintenance.”
Personal reflection #3: The mental model I’ve settled into is this: Jules handles the maintenance treadmill so I can focus on the architecture decisions. I design systems. Jules keeps them running. The division of labor is actually natural once you trust the review process.
Pricing: What You Actually Get 💰
Jules has a free tier and paid tiers tied to Google’s AI subscription plans.
For solo open source maintainers, the free tier is genuinely sufficient to start. 15 tasks per day covers most maintenance workflows — dependency audits, test generation, targeted bug fixes. The concurrency limit (3 parallel tasks) matters less when you’re working solo anyway.
If you’re running multiple active repos and want to parallelize — like kicking off a dependency audit on three projects simultaneously — Pro starts making sense. But don’t pay before you’ve hit the free tier ceiling.
Actionable takeaway: Start with free. Run Jules on one project for two weeks. See which task categories give you the best return. Then decide if Pro concurrency limits are worth the upgrade.
The Jules Tools CLI: Because Developers Live in the Terminal 🖥️
In October 2025, Google released Jules Tools — a command-line interface that brings Jules directly into your terminal.
Install it:
npm install -g @google/jules-tools
Use it like this:
# List connected repos
jules remote list --repo
# Kick off a task directly from the terminal
jules remote new --repo TheJenilDGohel/Synapse --session "write unit tests for the knowledge graph traversal logic"
# Pipe GitHub issues directly to Jules
gh issue list --assignee @me --limit 1 --json title \
| jq -r '.[0].title' \
| jules remote new --repo .
That last one is the one I use most. I pull my assigned GitHub issues, pipe them straight to Jules, and let it draft the first pass. It removes the “I’ll get to this later” friction almost entirely.
Jules Tools is also scriptable — which means you can build it into your own workflows, CI pipelines, or task runners. The Jules API (also released October 2025) opens up even deeper integration for teams that want Jules as infrastructure, not just a standalone tool.
The Audio Changelog: My Unexpected Favourite Feature 🎧
I want to talk about a Jules feature that doesn’t get enough attention: audio changelogs.
Jules can turn your recent commit history into a spoken summary — a generated audio file that walks through what changed in the project and why.
I’ve started using this as a re-entry ritual when I context-switch back to a project after several days away. Instead of reading through commits or trying to reconstruct my mental model from git log, I listen to the summary while I open the codebase. It’s like a standup with your past self.
It sounds like a small thing. In practice it saves 10–15 minutes of disorientation every time I pick up a project I haven’t touched in a week.
What Jules Is Not (Honest Section) ⚠️
I want to be clear about the boundaries here, because overclaiming is how these tools get a bad reputation.
Jules is not a replacement for architectural judgment. It doesn’t decide what to build or how to design systems. It executes well-scoped tasks on codebases it understands. The scoping judgment still lives with you.
Jules is not infallible. I review every PR before merging. Always. Jules gets things right at a high rate — but “high rate” and “perfect” are different things, especially when the task is ambiguous or the codebase has unusual patterns.
Jules is not magic for poorly scoped tasks. The quality of output tracks directly with the quality of your task description. Vague tasks produce vague results. Be specific about what you want and what success looks like.
The Google Labs team has been transparent about this too — Jules is designed to notify you if it gets stuck or hits a situation it can’t resolve without input. It pauses and asks rather than guessing. That’s the right behavior, and I appreciate that it was a design choice rather than an afterthought.
Personal reflection #4: My workflow discipline improved because of Jules, not despite it. When your output depends on clear task scoping, you get better at scoping tasks. That skill transfers to working with human collaborators too.
Why This Matters for Open Source Maintainers Specifically 💡
Open source maintenance is a particular kind of problem that the developer tooling ecosystem hasn’t fully solved yet.
You’re not on a team with shared accountability. There’s no sprint planning, no PM prioritizing your backlog, no on-call rotation. It’s just you and a GitHub notification tab that keeps refilling.
The maintenance work that matters most — keeping dependencies current, writing tests, fixing well-scoped bugs, writing clear PR descriptions — is also the work that’s hardest to prioritize when you have a day job. It’s important but not urgent. It’s technical debt you’re accruing in a project you care about.
Jules is the first tool I’ve used that actually addresses this dynamic in a way that fits how solo maintainers actually work. Async execution means it works around my schedule, not inside it. GitHub integration means it lives where open source projects already live. Plan review before execution means I stay in control of what goes into my repos.
The open source graveyard — projects abandoned not because the maintainer lost interest but because the maintenance overhead became unsustainable — doesn’t have to be inevitable.
Actionable takeaway: If you have even one open source project with issues you’ve been meaning to get to, connect Jules to it today. Give it your oldest, most well-scoped bug. See what it comes back with. The first PR review is the proof of concept.
Getting Started with Jules 🚀
- Go to jules.google and sign in with your Google account
- Connect your GitHub account and select a repository
- Start with a well-scoped task: “Update all npm dependencies to latest stable versions” or “Write unit tests for [specific module]”
- Review the plan Jules proposes before approving
- Review the PR Jules opens before merging
That’s the whole loop. It takes about 5 minutes to set up, and the first task result tells you more than any amount of reading about it.
The Bigger Picture 🔭
Here’s what I think Jules represents beyond the immediate utility.
We’re moving from synchronous AI assistance (you prompt, it responds, you’re present throughout) to asynchronous AI delegation (you task, it executes, you review outcomes).
That’s not a small shift. It’s a different mental model for what AI tools are for.
Synchronous tools augment how you work. Asynchronous agents change what you can reasonably take on. A single developer who can effectively delegate maintenance work to an AI agent can maintain more projects, at higher quality, with less burnout. That has real implications for the open source ecosystem — more projects that stay healthy, more maintainers who don’t burn out, more contributors who get timely responses.
Jules isn’t the end of this trend. It’s an early, working proof that the trend is real.
Try It, Break It, Tell Me 🤝
If you’re maintaining open source projects and this resonates — try Jules. Connect it to one repo. Give it a real task. See what the PR looks like.
Check out my projects on GitHub — they’re all fair game if you want to see what the output looks like in practice:
- Synapse — AI memory layer, TypeScript
- enhanced_jailbreak_root_detection — Flutter security plugin, Dart
- ar_flutter_reloaded — AR plugin for Flutter, Kotlin/Swift
Drop a ⭐ if they solve a problem you’ve felt. It genuinely helps with visibility.
And if you’re already using Jules — leave a comment. I want to know what tasks you’re routing to it and what the hit rate looks like on your codebase. The more we share real workflows, the faster this gets useful for everyone.
Follow me on Medium for more writing on AI agents, mobile architecture, and building in public. The next post covers what happens when you wire Synapse’s persistent memory into a Jules workflow — AI that remembers your project, building your project, while you sleep.
Keywords: Google Jules AI agent · Jules autonomous coding agent · Jules GitHub integration · open source maintenance AI · asynchronous AI coding agent · Jules vs Cursor · Jules open source · Google AI coding tool · Jules Gemini 2.5 Pro · AI for open source maintainers · Jules tutorial 2025 · Jules pricing · Jules Tools CLI · Jules audio changelog · developer productivity AI