The best part of Wispr Flow’s new Android app, is the persistent bubble overlaying all apps.

Being a GrapheneOS user… I can’t get over letting them read all the text on all my screens at all times.

I asked about the Privacy Mode feature in their official subreddit:

Asked a follow up… and silence

Even if they claim to delete everything, there’s so many sub processors getting data in these sorts of pipelines, and all I really need is local transcription.

I’ve been using voice ink on my Mac for months over Wispr, because it works more than good enough for the types of ways I use it, without any AI processing on top of the transcription.

I speak in a sentence or two at a time, not giant chunks.

Subscribe now

Anyways I’ve always wanted the same thing for my phone as I have on mac: local voice to text that is fast and accurate.

So I spent 20 minutes, seriously that’s about it. And now we have this:

The part that I built is the purple bubble. It shows anytime you have text fields focused on Android. Tap and hold to transcribe, and then it pastes when you let go.

You could adjust this app to run whisper locally, however I find that to be too slow. I run whisper v3 large, which is about 1.5gb in ram on a 4070 gpu that I have.

I made the app use the Home Assistant Wyoming protocol, which is just a small layer describing how to send the voice and text info back and forth. The app lets you put in the server url and you’re all set after enabling a couple permissions.

I access this over Tailscale so it’s my private transcription service that always works even on cellular.

Ultra fast vibe coding iterations

The reason I was able to build this so fast? I enable wireless debugging on Android and then let claude connect and run it. First try, the speech bubble didn’t work because of a bad api request / response parsing by the code.

Since it can install right to my phone and view adb logs, I barely tell it what isn’t working and it iterates for me.

Here’s when I told it the transcript wasn’t being returned for example:

Anyways, hope you like this idea. I made the github repo auto build the apk if anyone else wants to use it.

This wyoming server works perfectly with Home Assistant’s voice assistant feature too so you can have your own Siri that has vastly smarter functionality and better natural language than most standard platforms. Those platforms also take all your voice data and have had leaks an accidental retention in the past.

From now on I only use private AI assistants for accessing all my smart home setup and data. Look out for my next posts about Home assistant and some insane AI and reverse engineering I’ve been doing soon.

These are just a few snippets from my new AI Doctor. Okay, it’s not really a doctor but it was fun to setup nonetheless.

I created a new openclaw agent that is managed through discord in a specific channel, that has near live access to my heart rate, hrv, sleep data, and more. This is all data coming from a Helio Strap.

This company has easy to reverse engineer products, so you aren’t tied to their mobile app or cloud platform for data access.

I setup Gadgetbridge next, as I run Graphene. (p.s. I am super excited to see Motorola as a partner next year)

Gadgetbridge lets you automatically export a sqlite database on a schedule with all collected data. You can already see where this is going. I set this up to auto export every few hours, and a termux command to sync from that exported database to my openclaw server. This server uses Tailscale so an rsync / scp doesn’t require manually setting up any ssh keys.

The sync drops the file right into the agent’s workspace.

Subscribe now

At this point I ran openclaw agents add health and then bound it to a discord channel. Funny enough the agent sometimes gets confused that health = health checks. Probably better to name your agent “doctor” but then it might think you’re asking about openclaw doctor LOL.

Anyways, with that in place, I tell the agent “You are my doctor, you have full access to my vitals in the sqlite database Gadgetbridge.db in your workspace directory. View the schema and then persist it to your soul and to tools.md with all the table information and your purpose”

I did setup a few more things, like asking it to give me a daily report at a set time, weekly reports, and to alert me anytime values look off or I look unhealthy.

It’s really just a for fun experiment in using openclaw’s built in tooling and playing around. I tend to use Ollama Cloud for model access. I already have Claude Enterprise and Codex at work, so it keeps me up to date on how the open source models are progressing, by using them in Openclaw.

I have so many providers, I setup LiteLLM so opencode can reference a model name and I can swap it out at the LiteLLM level instead of modifying opencode on the 5 different places I have it installed. 😂

I also give read only access to a lot of other development tools, so I can have some quick help when I’m on the go, vs dropping into an ssh session and claude code from my phone. I know Claude also has a built in way to do that now too.

I like using qwen 3.5 397b and GLM-5 through ollama cloud currently for these types of agents.

Random Thoughts

You can get a nice, safe openclaw setup if you only use a couple skills that you vet yourself, along with using external services in read-only mode.

I am able to work on git repos, but the agent cannot commit for me. I need to ssh in, and ssh forwarding allows the container to request signing via 1password’s cli. The container never sees the private key. I may post more about this later.

So I missed this launch a few weeks back and hadn’t tried it out until last week. For anyone interested, this model is 80b params, but only 3b active. On Macs and also ddr5 systems with even as little as 8-12gb VRAM it performs well enough to be usable.

This model works without tool call issues in Claude Code, Codex, and Opencode. I’ve personally validated Claude Code and Opencode usage.

A few different things to note, the GGUF on macs performs much worse than the MLX version. If you have a Mac, install qwen3-coder-next using LM Studio. If you are on another platform, use ollama.

I’ve never seen a disparity this large between GGUF vs MLX before.

On low power mode on my m4 max laptop, I get around 20t/s on the GGUF under ollama. Also that version is larger, around 52gb. When I run the 4bit mlx on LM Studio, it’s only about 45gb, and I get 30+t/s with a minimal starter prompt.

Now, on full power mode I can hit almost 70t/s with the MLX:

The GGUF was only giving me around 40…

Subscribe now

So anyways, for anyone who didn’t care about those comparisons, on a Mac, the MLX is much faster and VERY usable if you have at least 64gb of unified memory.

I shared the low power numbers because it’s just not practical to use this on high power UNLESS you are plugged in.

If you are on the go, this is the first time a model is fast enough to use, in an agentic tool like Claude Code, with low power mode on a Mac.

If you go full power you’re going to burn 5% battery every minute or two for 30% gain in speed.

Examples

Ok, so I installed and then uninstalled openclaw on my machine lately. After, every terminal opening referenced a file that no longer existed. This should be super easy to fix, but let’s give it to qwen3-coder-next and see how fast it can figure out a solution:

I told it about an an error I get on terminal start after removing a package, and then just pasted the full error line I get.

34s later it correctly fixed it and this is on low power mode. This is huge because these tools inject a starter prompt that can take a while to process locally.

Yes this was a super basic example, and here’s another basic one, but this time from claude code:

I just had a file open in my editor and then said remove the props arg. Even though this is basic, in the past these tools would break when running in these agentic tools, constantly. Tool call malformed errors were notorious.

Unfortunately I don’t have many more examples to share, the rest are in a codebase I can’t share. I will say if I am quite specific about the function names and provide single step requests, it works great locally and within a minute or two for a full result.

It’s also a great way to explore a codebase and find things that you may not be familiar with. Asking where things are or what endpoints are hit by a particular UI element works well.

This is NOT claude opus 4.6. This is much smaller but still highly capable. I would use opencode as much as you can, and use plan mode for codebase exploring and explanations of how things are setup, as the prompt is a bit smaller than “build” mode.

If you really want to use in Claude Code you CAN, however I find the initial prompt speed isn’t worth it vs using opencode. Make sure you disable as many MCPs as possible if you’re wanting the fastest possible speed.

Ollama cloud

If you want to run this model faster or you don’t have the hardware requirements to run it well, I recommend checking out ollama cloud. The coolest part of it is this:

ollama launch claude --model qwen3-coder-next:cloud

If I add :cloud on the end of a model, it’s now running on their cloud platform at a faster speed. If I need privacy or bad connection, I can run that same thing again with :cloud removed and have the same model fully local.

Finally, if you have an Nvidia GPU with DDR5 ram that’s running at 6000mhz, you should be able to get 20+ tokens/s there as well. This is what makes this model such a big deal, this level of intelligence hasn’t been seen in something that can truly run at a usable speed on consumer hardware.

If you try it out, let me know what you think!

Step 1

It always starts with tailscale… Without it, this would never be something you can do within 10 minutes, unless all you do is manually configure wireguard every day 🤣

Step 2: Apple TV or Travel Router

Sign up for tailscale, then make sure you have an Apple TV.

If you do not have one, or you have certain streaming apps that check for the device having an active VPN connection (I am in this situation) then you need to buy one of these travel routers. I bought one of these for my parents during Black Friday week for about $60.

Don’t buy any of the cheaper ones as they can’t handle running tailscale.

Take a look at GL.iNet’s supported device list for tailscale if you want to try a different model.

Also side note, these things are awesome for a lot of reasons, I have a Slate 7 for myself, MLO is cool, but I wish it also had 6ghz!

Subscribe now

Step 3: Exit Node

Now that you have a travel router or Apple TV device, the next step is to run an exit node at your house. This is going to route all traffic from your travel router through it, no matter where it’s actually located. This is how we bypass restrictions against sharing accounts, because all of your devices will exit through your home IP, that is the check most services are making, and it will appear like another device in your home is streaming.

You can use a cheap raspberry pi device, or even your router, if you have something that runs linux chances are tailscale can run on it.

Otherwise, feel free to use an old windows or mac computer. After installing tailsacle all you need to do is check one box in the settings tab:

If you have a GL.iNet device, login to the interface and go to the Tailscale tab under applications:

When you first come to this, you toggle to enable tailscale, you click the link and login, and the device is configured. Then you click the refresh icon under “Custom Exit Node” and select the node we started running in the prior step.

First time after connecting, you need to go to your tailscale dashboard and click on your device and accept the subnet routes from it:

I like to be extra secure, so I actually tag this device in tailscale, set a static IP on the device connected to its ethernet port, and then only allow that single IP to use exit nodes in my network.

Subscribe now

That means if they connect another device through it, it can’t go through tailscale, and in addition, that one allowed device can use exit nodes, but will be unable to ping or access any other device in the tailnet.

This goes beyond the “10 minutes” of this tutorial, but I wanted to share it. Tailscale has added ACL tests that validate your firewall rules as well which has been super helpful. Anytime I add a new rule I add a test right after to ensure what I wanted to allow is correctly applied.

Step 4: Profit

It really is that simple, and if you have an Apple TV… it’s even simpler. Install the Tailscale app from the App Store and then scan the QR code displayed to connect.

Enable your exit node and it’ll route everything through your home connection.

I use a travel router and did these exact steps. All I had to tell my family member was “unplug the ethernet cable from your apple tv, put it into this. And then use the other ethernet port to connect to the apple tv.” They actually couldn’t believe it was that easy and were surprised when the app they opened just started working, because it that one only checks your IP, doesn’t even require a login.

I couldn’t let them use the Apple TV directly because the streaming service checks for VPN apps running on device.

Seriously this is getting so easy, a gen z kid that only knows how to use tiktok can do it. Set this up and split the cost of streaming services without having to worry about getting cut off.

One downside…

The worst part is that if you have a service on a crappy ISP like I do… where you only get 30mbps upload speeds, you cant give this out to more than 1-2 people or your upload speed is going to be saturated and not work well.

Thankfully I have multiple ISPs and keep guest networks and this type of stuff on the bad connection, but some of my streaming services are tied to that ISP’s IP so i have to use it for this as well.

Last week Anthropic released a feature that may lead to a huge leveling up across your development team.

If you have multiple (or large) codebases with many individual systems or processes, it can be difficult to onramp a new dev. If you have one dev who needs to work on an area they never worked in, in the past this may have required discussions with other team members, or time spent clicking through and understanding what’s going on.

If your team is fast moving, there probably isn’t much documentation either.

Enter Claude Plugins

Claude Code Plugins now allow you to create a github repository with (nearly) hot swappable features to share with your team. I say nearly, because at this current time you have to restart “claude” in your terminal when enabling or disabling any plugins.

This is a big deal, because it’s already been made clear that some team members have agents and commands I don’t want or need to use. I wouldn’t want to waste my context window having these enabled either.

The new plugin marketplace feature solves these problems, and I think it enables instant context sharing across your dev team, with the most minor amount of time spent documenting areas of your codebase.

How it works

All you have to do is create a new github repository, and add a couple json files to get started

To host a marketplace, all you need is a git repository, GitHub repository, or URL with a properly formatted .claude-plugin/marketplace.json file. See our documentation for details.

To use plugins from a marketplace, run /plugin marketplace add user-or-org/repo-name, then browse and install plugins using the /plugin menu.

A powerful example

Currently at work, there is a new pipeline we made to process a new piece of logic that runs hundreds of times per second. Another dev on the team was assigned a task on this feature that was originally made mostly by myself, with this dev not even looking at any of the code until now.

This feature requires a few environment changes, and preparation commands in order to start working on it locally.

In the past, I would need to write this up, explain each step to each team member, and they may still have more questions about how different parts work.

Instead, I created a new subagent definition in markdown, this is about 1 paragraph with some bullet points.

I know what you’re already thinking… if you did that, why not explain and send this to the other developers?

Here’s a few reasons why, as demonstrated by sharing parts of this subagent definition.

Hot Swappable Subagents

The definition for this agent starts with:

“You are an expert in this area of the codebase, ensure you read and understand it fully <path to feature>”

This alone isn’t something I could say to a team member. To Claude however, it is able to read and pull all of this feature into its context, ready to go for any questions about how it works after.

In addition, I described in a bullet list, the preparation commands that need to be ran to setup the environment, and I have the subagent to tell the user what the final command is to start using this pipeline and to also offer help after running the required setup commands.

Slash Commands

The last step, I register a slash command like “/run-pipeline” inside this feature’s plugin. This command invokes the subagent directly without the developer having to know its name.

In Practice

Now that we have a plugin marketplace for our team, if someone needs to work on this feature, all I have to tell them to do is install our marketplace in their claude code, if they haven’t already. As easy as `/plugin marketplace add user-or-org/repo-name`as mentioned earlier. If your computer has access to the org / repo on github it’s able to pull it in immediately.

Next, I can mention, “enable the feature X plugin from our marketplace and run the /start-x command, it’ll configure everything and provide you all the context”

The developer will be given a recap of the step required to run the code, and be given a chance to ask any questions about the code at this point.

Summary

This feature seems small but I think it’s going to lead to a paradigm shift of internal developer communication and documentation. When building a large feature, it takes all of 10 minutes to define an agent and provide the necessary testing steps, file locations, and commands needed. The rest of the team can enable this feature plugin on the fly anytime to gain context, without extra meetings, hours spent reading code manually, or other slow processes.

There's a secret that so many providers don’t want you to know.

You really can roll your own auth, and that doesn't have to mean not following standards or being opened up to new vulnerabilities.

At my current job, this was a discussion we had about a year ago. Originally there was a choice to use email logins and pay for a service called Magic Link.

It ended up costing too much, and the team decided to move it to Auth0.

At which point we started entering a period of trying to cut costs. One of my first suggestions was, "Let's cut Auth0 and do it in-house."

This wasn’t a new decision for me. I've always felt like you shouldn't have to pay for auth. There are standard ways to do this without paying per user or per login.

Auth0 just uses SendGrid for emails

I tried to make this point clear, that Auth0 just uses SendGrid, and we can still use SendGrid ourselves. Auth0 isn't doing anything special to ensure magic email link delivery.

They’re just generating a time based one time code that gets emailed to the recipient, this type of hash logic can be done easily in any language.

At the time, better-auth did not exist. If I were doing this today, I would much rather use their library, as it supports so many integrations out of the box with a simple abstraction.

Instead, we implemented an OTP very similarly to this library, if you’re interested in doing this yourself.

How long did it take us

It didn't take more than a week to fully replace Auth0. That's a testament to the way we're using it in the first place. We don't need a lot of their features. We're just using Auth0 to take an email and send a link, click the link, and now be logged in, and also for social logins. One click Google, Microsoft, and other OAuth login flows.

It kind of boggles my mind that people would pay per login for these features, especially with social logins that require registering oauth clients manually either way you do it.

In the next section, I'll dive into a few things we specifically used to replace it, and also comment on some of the common gotchas people constantly bring up trying to say you shouldn’t do this.

And just remember, we've been doing this for an entire year. Saving the company nearly $30,000 and it's been working perfectly.

Read more

Summary

In this episode of the podcast, Zach speaks with Marcus, a developer at Reddit, about the intersection of AI and voice technology. They discuss Marcus's side project, a voice agent designed for various applications, including customer feedback and gaming. The conversation explores the challenges and opportunities in voice technology, the importance of community engagement in game development, and the evolving landscape of AI tools that facilitate learning and productivity. Marcus shares insights on building in public, the role of Reddit's developer platform, and the future prospects of voice agents in business and everyday tasks.

Takeaways

Marcus is an engineer at Reddit working on AI and voice technology.

He has developed a voice agent for various applications.

The voice agent aims to simplify customer feedback processes.

Voice technology can enhance user experiences in gaming.

Community feedback is crucial for developers to improve their products.

AI tools can significantly reduce the time spent on tasks.

Voice is becoming a preferred method of communication.

Reddit's developer platform allows for game development and community engagement.

The future of voice technology looks promising with rapid advancements.

Learning through AI tools is more accessible than ever.

Chapters

00:00 Introduction to AI and Voice Agents

02:57 Building a Voice Agent for Customer Feedback

05:40 Exploring Use Cases for Voice Technology

08:28 Challenges in Voice Technology and AI

10:52 The Future of Voice Agents in Business

13:48 Voice Technology in Gaming and Community Engagement

16:32 AI Tools and Learning Opportunities

19:26 The Role of AI in Everyday Tasks

22:09 Reddit's Developer Platform and AI Integration

25:24 Feedback and Community in Game Development

28:02 The Evolution of AI and Voice Technology

30:53 Conclusion and Future Prospects

If you’ve never played around with crypto…. a lot of these terms will confuse you. I’ll do my best to provide links if you’re interested in diving in to any of the things I mention.

Lately I have been playing around with crypto again. Back in 2015 I started mining ethereum and gave up too early. I never got into building smart contracts and actual decentralized apps, but I may be making a small one soon, just to learn.

As I was catching up on many different things, I started to realize just how centralized all the big “DeFi” apps really are. I’m shocked there isn’t more being done here to make some of them truly on-chain completely, or at least more agnostic in letting users control off chain actions affecting these applications.

It’s just unfortunate many users think what they’re using is either untrackable, or fully decentralized.

Uniswap

Let’s start with uniswap.

It’s a great idea, a decentralized crypto exchange. The problem starts immediately though.

There has to be some way to know the current exchange rates offered by the platform and also other exchanges.

When you load the site, it makes graphql requests to their own *centralized* server in order to get information.

You also see many calls that track your every move:

Here’s one sending all of my device info with every action taking place.

Feels a lot like a normal website to me. And an invasive one at that…

At least they are hosting it on IPFS, which is a distributed website hosting spec. It’s acutally really neat too. The problem I see though is its oracle outreach from the interface for pricing.

I haven’t had enough time to config if their interface will still allow smart contract execution if one of their oracle systems is down.

Let’s take a look at another one!

Polymarket

Alright, neat. Inspecting the page, I see direct calls to the blockchain. Decentralized right?

Well… sort of. These calls are sent to alchemy, a blockchain services provider. What happens if they do a deployment and mess up their node, suddenly polymarket is down (most likely anyway)

I was wondering, why don’t these services attempt to direct connect to various validators?

P.S. I am not an expert AT ALL in this space, just someone interested in trying to make a fully, truly, decentralized app soon, and finding a lot of issues with current products.

Granted, they may not market themselves as fully decentralized, but I’m sure that’s how most people perceive them.

So I asked Claude, can’t I direct connect to a validator? Not always.

It makes sense, most don’t want to run the rpc endpoints, because it will use a lot more resources, and these validators already require a massive amount of compute.

There are just so many points of failure, but for something like polymarket, you must have off chain systems that confirm what the result of the different markets are.

This puts all the trust in a platform that has already had legal battles in the past. I’d be worried about betting on something many months away.

True Decentralization

Let’s start with just polymarket. It could be better if they offered a download link of their frontend application…. Oh wait, they’re using server side nextjs…. so they can’t. IPFS is perfect for client side websites that connect to the blockchain, because IPFS can only handle static files.

Validator Choices

I would expect these types of apps to have a settings toggle that lets you put in a different validator endpoint. If one is down, you can swap, this would be a great option to have. Otherwise you’re connecting to a single point that may proxy behind the scenes, or it could have an outage at any time with no way to use the application.

If they don’t want to go that far, at least an internal list of validators to loop through if there was a connection problem.

I’d rather be able to do this, vs having to store every smart contract address and know the exact arguments to call in case I need to withdraw or perform other actions during a site issue.

Downloadable

If their domain is seized, you’re already pretty screwed, unless you have saved network logs and know what rpc calls to make to see anything on the system.

This is step 1 of decentralizing these apps, at a bare minimum, I believe they should be html and js frontends, that are downloadable and run outside of their company’s domains.

AAVE, and Uniswap are good at this, although as I mentioned prior, still concerning how many 3rd party api endpoints are called from these frontends. Leaving me to wonder if they will work if certain things break.

Open Source Consensus

Imagine Polymarket showing who the market validator is. In this case, it’s always polymarket. Let the community pay in crypto to be listed as a validator, track if they’re grading outcomes correctly, and let members decide who gets to validate their bets.

This has a lot of possible problems, but ultimately you need to trust someone. I’m suggesting to let users choose who to trust and make it uncontrollable by a single entity.

Failsafes

If I chose to let polymarket grade my bet, and pick the outcome after the event happened, and polymarket gets shutdown. There should be a smart contract I can execute that will refund me after the end date of the market. This would provide relief if the platform is shut down.

When I use something on a blockchain, I want to know if everything goes bad (except for actual nodes all being taken offline) I want to know what I am interacting with is still safe.

Wallet functionality

Wallets need to be able to ingest smart contract calls. I should be able to add th contract above (refunding after market issues), to my wallet, letting me interact with contracts in case the domains are no longer available, or I forget about them later.

I shouldn’t have to review the code myself.

No tracking

Stop tracking usage, and build in your economics through transaction fees on the platform. Build everything you can into your smart contract, so you don’t need a graphql endpoint to do half the work…

Wrap up

Hope you enjoyed these ramblings, I believe decentralized apps can be made much better, but the truth is, these companies don’t want them to be. A lot of them are making millions a month under a false sense of decentralization.

Building apps fully on chain is incredibly hard, most aren’t going that far because they want to keep more control to themselves, giving us many single points of failure in the end.

I’m not sure how useful the technology will ultimately be many years from now. Currencies may take off more than the applications.

Only time will tell…

It appears they use …

Read more

Summary

In this conversation, Zach and Esteban discuss the integration of Docker and DuckDB in ToolFront, focusing on data discovery and querying …

Read more

I wrote this a few weeks back and there hasn't been a perfect time to release it, as I've been working on podcasts and other content, and I don't want to blow everyone up with too many emails per week. So I hope you enjoy this and let me know if there's any other editors I should add.

Zed

Website

Zed is actually one of my favorite alternative code editors, mainly because it's not just another VSCode fork and it's written in Rust. So it actually feels a little bit snappier and unique. And I like what they've done with the design.

I like that it supports local models. They have a hosted version similar to Cursor. They also have their own proprietary autocomplete model, which is pretty far behind Cursors, unfortunately. You'll see below when I get to cursor why and how it's so much better than all the current alternatives.

If you want to support an open-source editor who's trying to make money by charging for premium model access, Zed is a good one. Unlike Cursor, which is fully proprietary, Zed's editor is open source.

It also gets high praises from users on Reddit:

The speed of the editor is really nice, but It’s still early days for Zed.

I noticed that I cannot override a local model’s ability to enable tool use. This was a huge pain, and most of the value of using a local model for agent mode, required tool use. Most of these editors all have some issues that irk me to some degree. Even after manually adding it to the settings config for my model, it was still disabled.

A small quirk which is to be expected in something so new. Give it a try and let me know what you think!

Subscribe now

Void

Website

Void is a pretty nice VSCode fork. It's very simple, the auto-complete is basic, the agent mode is what you'd expect from Cursor, Zed, or Continue, or any of the other ones that you may have tried.

It's really what you would think VSCode would have been had it started out after AI was a thing.

It's nice that everything just works. If you have Olah or LM Studio or another local model language server running on your computer, there is no configuration. Just opening Void immediately sees that and you can choose any of those models for a chat or an auto-complete session.

It's worth noting that autocomplete is in beta, and again it's just basic autocomplete. Nothing compared to the state of the art that exists in Cursor.

Void is probably the most promising newer entry into the open source space. If they can iterate and catch up, I can see it being great. Even though it’s a little bare bones now, it just works. There were no issues.

Zed and Void are the most exciting ones, with Void being slightly more at this time, because they aren’t pushing for paid versions of anything yet, which I hope it stays that way.

Open Hands

Website

I used this one for the first time when Devstral came out a couple weeks ago.

This one is unique because it’s really a layer ON TOP of an IDE. It includes VS Code inside of it.

It’s really meant to fire off a lot of AI tasks all at once. For each task you get your own isolated VS Code environment you can use to test and run the code before pushing it up to your repos.

It’s a really neat idea that negates the need to context switch between editors constantly as you’re trying to validate work you had AI do for you.

Cursor

Website

You've heard me talk a lot about Cursor in the past reviews. The biggest thing is the video above. The tab autocomplete is just incredible. Not only will it jump around and immediately realize that you want to import certain things that don't exist, but it will also be really intelligent in other ways.

If you're editing something that has something similar in the file, it will suggest to just tab complete both of those sections together. It's amazing what they've been able to do from what little I understand. They have a special model that will pull in tons of context all from your codebase and really understand everything you're trying to do. It's been specifically trained on how people jump around in their editor.

Cursor's agent mode for a long time was a ways off from what Cline and Roo code were, but it's since improved a lot and to be honest it's a great value for the $20/month that it costs.

I would have to say after every AI ide and extension that I've tried over the past year, I always come back to Cursor's autocomplete. Whether I use a different editor to do agent work, I will always use Cursors tab autocomplete. And I cannot wait for the day that open source has an autocomplete that's on par with it.

I have to give Cursor a 9.5/10, and honestly, I would give it a 10/10 if they weren't completely closed source.

Windsurf

Website

This one I do not have much experience with. It is nearly identical to cursor which I have use a lot more. Their tab autocomplete is a level up from the open source options but I still find cursor’s ux and abilities better.

Which is crazy to me that it was just acquired by Open AI for 3 BILLION.

Edit: that deal fell through actually 😬

In such a crowded market I can’t believe they paid so much for this company. They must know something I don’t or want to own as much of the AI market as possible.

VS Code + Continue

Website

If this was a year ago, I would say Cursor and Continue are pretty similar, and it's pretty awesome what Continue is doing for the open source community. But lately, it's fallen way behind. I found bugs when I try to use it. It kind of glitches when it tries to apply changes from what an agent gives me, and I choose the apply button. Sometimes the red highlights in VSCode will stay around even after I hit accept. It's little things like that, and the unpolished nature of Continue that it's just fallen off a lot more than Cursor, whereas Cursor has really beautiful UI, really nice loading indicators, and everything just looks like perfection.

It's worth noting that Mistral just made a fork of Continue for their enterprise offering called Mistral Code (insert link), but nobody's able to try it without enterprise access, so I can't comment on it.

Claude Code

Website

I've been using Claude code non-stop since I paid for the Max Plan two weeks ago.

The agentic loop that Claude is able to do is superior to every other agent mode currently.

Whenever it encounters a mistake or an error, it seems to always find a way around it and continue working through what it needs to.

This isn't really an IDE, but I felt like I had to add it just because it's so similar to everything else, and it really can become its own IDE.

Sounds weird to say when it's just a command line application. But it's able to do so much with such a simple interface.

I'm able to make reproducible prompts, which handles so many complex tasks I don't even need to jump around in my editor anymore.

You can see more of my thoughts about how I’m using it in my post last week about shifting your mindset to use AI.

VS Code + Cline

I wasn't going to add an entry for this one, but I felt like I had to after writing everything else.

Visual Studio Code by itself and now I guess with Copilot which is open source, so you can kind of consider those one in the same. In addition to that, Cline is pretty powerful on its own.

If you're stuck on VSCode because you've been using it for a very long time, just install Cline. The agent mode is pretty amazing if you're trying to stick to what you know.

I love that you can use any model provider. Local models work as well, especially with Devstral, and you can just get a lot out of it without paying anyone anything.

Kilo Code

https://kilocode.ai/?rdt_cid=5199116422869239961&utm_campaign=v1_en_aicoding&utm_medium=cpc&utm_source=reddit

This one keeps appearing on advertisements constantly, although I haven’t had a chance to test it out yet.

AIDE

This one seems to be the first one to lose the war of the Aiditors (see what I did there 😆)

It’s been officially sunset as of a few months ago I only included it because I had used it once, went to go see what’s new, and saw the repository is archived.

That’s all for now

I hope to see Void and continue keep striving forward.

If Microsoft doesn’t level up the newly open sourced GitHub copilot extension in VS Code, I can see both of those getting bigger…. If they can catch up with Cursor

There’s a lot of other extensions like Cline, Roo Code, but I left those out as they are more of a specific agent only tool, not an entire editor integration.

Hope you found this useful, and if there’s another one you’re using, let me know in the comments and maybe I can update this. I’m trying all of these that I can, but I’m realizing the only one standing out drastically is cursor, and a little bit with Zed as its a uniquely different editor platform than the rest.

I am using my IDE less than ever before, with most of my time spent inside Claude code.

Summary

In this conversation, Zach and Ryan discuss the RevenueCat hackathon, exploring app development ideas and investment strategies. They delve into the use of AI tools in coding, the challenges developers face with AI, and the future of AI in software development. The discussion highlights the importance of understanding AI tools, the potential pitfalls of relying too heavily on them, and the evolving landscape of coding productivity.

Chapters

1. Introduction to Revenue Cat Hackathon (0:00 - 2:30)

   • Discussion about the Revenue Cat Ship-a-Tone 2025 hackathon.

   • Details about the submission requirements and prize categories.

2. Revenue Cat's Mission and Requirements (2:31 - 5:00)

   • Explanation of Revenue Cat's mission and the requirement to use their subscription payment service.

3. App Idea Discussion (5:01 - 10:00)

   • Conversation about a potential app idea related to investment and savings.

   • Comparison with existing apps like Griffin and Acorns.

4. Agentic Coding and AI Tools (10:01 - 20:00)

   • Discussion on using coding agents and AI tools like React Native, Swift, and LLMs.

   • Personal experiences with various AI tools and their impact on productivity.

5. Challenges with AI Tools (20:01 - 30:00)

   • Issues faced with AI tools like Gemini and Claude.

   • Discussion on the importance of context windows and tool calls.

6. Pricing and Subscription Plans (30:01 - 40:00)

   • Conversation about the pricing of AI tools and subscription plans.

   • Personal experiences with different plans and their value.

7. Local Model Performance and Hardware (40:01 - 50:00)

   • Discussion on running local models and the hardware requirements.

   • Comparison of different hardware capabilities for running AI models.

8. Future of AI in Development (50:01 - 60:00)

   • Speculation on the future of AI in software development.

   • Concerns about the impact of AI on developer roles and salaries.

Takeaways

The Revenue Cat hackathon encourages developers to create new apps.

Investment apps can help users save and invest simultaneously.

AI tools can enhance coding productivity but require understanding.

Developers need to be cautious about relying solely on AI.

The future of software development will heavily involve AI tools.

Companies may face challenges if they rely too much on AI for coding.

Understanding the context of code is crucial for effective AI use.

AI can help automate tasks but may introduce new complexities.

Developers should maintain their coding skills alongside using AI tools.

The landscape of coding tools is rapidly evolving, requiring adaptability.

Just before I open sourced revect, I had a problem. Well, two problems actually.

I wanted to make sure if people used a different embedding model later on, the system still worked. With vector embeddings, you turn text into vectors, and if you rely on Open AI’s models… when they deprecate it, you’re screwed… Unless you re-embed everything with a new model.

If you are not familiar, an embedding model converts words into vectors, basically points on a chart or map. This makes it possible to search by meaning of words. For example, search the word “government” and find everything related to presidents even though the text doesn't exactly match.

So I did that. If the model changes, the system knows and re-embeds it all automatically.

The next problem, I wanted to make sure, even if a mistake is merged in to main, we do not push out a new docker image. For example, a mistake with a migration that would break older users databases.

You might imagine referencing some new database field, without renaming the original database columns. This would cause anyone who uses “pull always” on docker, to receive the new code, and then it immediately breaks, because their database schema is different.

So I had a simple solution, and I let claude code implement it for me 😉

Migrate the last version every deploy

You can see the entire action here. Basically:

const currentReleaseTag = context.payload.release.tag_name;
const currentIndex = releases.data.findIndex(r => r.tag_name === currentReleaseTag);

// Get previous release if it exists
if (currentIndex >= 0 && releases.data.length > currentIndex + 1) {
 const prevRelease = releases.data[currentIndex + 1];
 console.log(`Previous release: ${prevRelease.tag_name}`);
 return prevRelease.tag_name;
} else {
 console.log('No previous release found');
 return '';
}

Grab the previously released git tag, every time we make a new docker image. I use GitHub's releases section to do deploys, so I always make my release tags incremental.

It doesn't really matter how you make them as long as there is one prior release to the current build when you add this.

# Create directory for database
mkdir -p ./data

# Pull previous image
PREV_TAG=${{ steps.prev_release.outputs.result }}
docker pull ${{ env.DOCKER_IMAGE }}:${PREV_TAG}

# Run migrations on previous version
echo "Running migrations on previous version ${PREV_TAG}"
docker run --name prev-revect -v $(pwd)/data:/app/data ${{ env.DOCKER_IMAGE }}:${PREV_TAG} bun run /app/src/database/migrations.ts up

# Build current version for testing (only amd64 for testing)
docker build -t ${{ env.DOCKER_IMAGE }}:test .

# Test migrations with the new version
echo "Testing migrations on new version"
docker run --name new-revect -v $(pwd)/data:/app/data ${{ env.DOCKER_IMAGE }}:test bun run /app/src/database/migrations.ts up

Okay, so here's a breakdown of what we just did above:

We pull the LAST release image.

Run migrations on it, these are the migrations from that prior release. This is done in the volume mount, /app/data. Revect initializes a sqlite file here if one doesn’t exist yet.

Now we build the new image, and we run the migrations on that database from the prior version, because we mount the same volume.

If it fails, the release stops, and we don’t push out anything broken to current users!

I thought it was pretty neat and intuitive.

External databases

Okay, that's cool and all, but how might we do this with external databases that aren't SQLite?

I'm not going to go too in depth, but you can use all of the same paradigms I shared above.

The only difference would be that you need to do a docker run for Postgres inside your GitHub actions or any other external database service, and then run your app container and make sure that it has the correct environment variables to connect.

Essentially, the only change is instead of a volume mount for SQLite, you're just starting Postgres and then injecting the Postgres connection URL to the previous container.

After that's done, now you have your base migrations that have already been applied. Now you inject the same connection URL to the new container and run the migrations, exactly like we did using SQLite. The difference is, you now have a second container running inside of GitHub Actions (your database server).

I think this is worth doing, especially for releases of open source projects, even internal projects if they are consumed by many internal teams.

If you found this interesting, please give it a like or comment. I haven't seen this discussion very often when it comes to Docker or content around safety nets for migration issues.

A few weeks ago when Copilot Pro+ was announced, I paid the $40 and started using it. I was super intrigued because having an AI agent on GitHub's website directly seemed like a pretty powerful tool.

It's not like there's a new model or anything, but the cool part is being able to have AI interact with pull requests and issues.

I think it helps a team level up if multiple people can go review a PR and have AI address it without you having to pull anything locally on your device (or into a codespace)

This leads us into our first big problem with Copilot’s Agent: currently, there's no way to have it respond to PR questions or comments that weren't originally started by Copilot.

It can do this, but only when it's the one who originally opened the pull request.

Real Examples

I'll go through and share some screenshots of some real results I did in the repository of mine. I used it so much during my testing that I got completely blocked and it started saying, "Unfortunately, I couldn't process your request." Through inspecting GitHub actions, I realized it's because I was rate limited.

Adding Sentry

I assigned it an issue that just said to add Sentry. Here’s what it added:

Read more

Alright, we’re going to go through this pretty quick as it just released yesterday morning. First, head over and download the Gemini CLI if you want to follow along.

First things first, I opened the CLI and had to log in with Google. I tried to log in with a Google Workspace account, but it wouldn't let me unless I pay and enable the Gemini API….

Thankfully, Google is offering Gemini free for personal Gmail accounts. I just logged into my regular gmail and was able to get right into it!

In the official blog post, they're announcing a pretty good free tier. I’m excited to see how much I can use this over the following month:

To ensure you rarely, if ever, hit a limit during this preview, we offer the industry’s largest allowance: 60 model requests per minute and 1,000 requests per day at no charge.

What’s the next step after I log into Gemini? I have to add our issue tracker at work, obviously 🙂

Adding our first MCP Server

It’s almost the same as Claude Code. As soon as I opened it, I typed /mcp as you can see below:

The first time you run it and try to do anything, it kicks you out to this webpage.

It describes the use of the `mcpServers` object key, just like every other MCP tool has been using, including cursor, cline, claude, etc.

For now there isn’t a fancy CLI arg to add servers that I can see, so here’s how to do it:

vi ~/.gemini/settings.json 

{
  "theme": "Default",
  "selectedAuthType": "oauth-personal",
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.linear.app/sse"]
    }
  }

I decided to use the MCP Remote proxy since it works perfectly with OAuth for now, as I’m unsure of the exact support Gemini has internally.

As soon as that’s done, I rerun the `gemini` command, and here's what we get after running /mcp inside of it:

Summary

I tried to use it for a few tasks today. It seems to use tool calls perfectly as I would expect, but agent tool loop needs some work.

Oddly enough, I asked it to perform a task, and in the middle it just stopped. I had to send “ok keep going,” to get it to finish working on something I gave it. This happened once and I’m not sure how often it will do that as I haven’t had enough test time.

I also had to hand hold it a lot more than claude, which figures out the correct approach faster. However, you can’t beat free vs $100 monthly right now, so I will keep trying it out.

I’m excited because I was one day away from renewing Claude Max at $100 a month, too. Now, I’ll be using it for free during the preview period, and I hope it lasts for quite a while.

I yearn for the day we we can do the same stuff locally… Thankfully, Google's Gemini CLI is open source, so I'm hoping we can either fork or add a feature to it to select custom AI providers soon. It's a pretty solid CLI tool, it definitely feels on par with Claude Code in terms of the user interface, the speed, and the interactions that take place while working with it.

I was surprised just how good it turned out. They recapped the features of MCP that I had covered in the two chapters, specifically server side prompts, resources, and http streaming.

This recap was so good I have to share it with you all on my podcast! It’s more professional than I currently sound 🤣 (I’m working on it, I promise)

The magic is all thanks to NotebookLM from google.

I am excited to use this tool for more things internally at work. Sharing code samples, new paradigms, and letting other devs ask specific questions and surfacing the answer immediately is very intuitive.

I may have to do a deep dive into more Google tools because Gemini is just so good, especially with their ability to connect to the google apps suite of tools.

Their upcoming agent mode inside Gemini will level up what’s already a pretty awesome scheduling system. Anyways, I’ll talk about that more in an upcoming post.

If you find our AI overlords did a good job recapping this book, consider buying it for as little as $5 while it’s still in progress!

The following is an excerpt from my book on “Building MCP Servers with OAuth.” If you enjoy this content, consider buying it early for up to 50% off, once completed in July I will increase the price.

The section I’m sharing today from the book highlights a unique approach to sharing MCP servers across your development team. Right now on my team, we are wanting to share more of our prompts, but we do not want to setup an internal server. We want something simpler, with the full customization and control that an MCP Server offers.

This chapter assumes you have the latest version of VS Code and bun.sh installed.

With that being said, let’s take a look at the chapter:

Making our first MCP server.

We will be taking advantage of bun.sh’s watch mode, and one other feature, so we are able to share this internally with our dev team, and ensure it’s always up to date. This comes without the hassle of hosting an internal HTTP Streaming server. Keep reading to find out how this is possible.

First, make sure you have Bun installed, and then create a blank project using `bun init`. Run `bun add @modelcontextprotocol/sdk` then replace the contents of index.ts with the following:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new McpServer({
  name: "My MCP",
  version: "1.0.0",
});

server.prompt("one-shot-task", { task: z.string() }, ({ task }) => ({
  messages: [
    {
      role: "user",
      content: {
        type: "text",
        text: `Please attempt the following task, and once done, commit it for me with a message that makes sense:\n\n${task}`,
      },
    },
  ],
}));
const transport = new StdioServerTransport();
server.connect(transport);

This creates a basic server, and registers a single prompt. This prompt uses Zod to validate the inputs from the language model and ensures a task string is passed in to the prompt. This is how the official protocol from Anthropic ensures required inputs are passed in from the MCP client.

Essentially, anyone who installs our MCP server, can choose the "one-shot-task" prompt, pass in a task, and then the user's AI model will run the full prompt with our task.

Adding our MCP to VS Code

The support for prompts was only added on June 12th, 2025 to VS Code.

You're going to start by bringing up the "Command Palette" in VS Code. Search the "Help" bar at the top if you are not sure how.

We will then search for the following:

Hit enter.

Choose stdio:

For the command to run, type in

bun run --watch ~/projects/mcp-book/index.ts

You must correct the path to where you created this file on your computer

On Linux or Mac, you should be able to type `echo $PWD` to get the full path when inside of your `mcp-book` folder.

Name it "my-stdio":

Finally, open the "Chat" tab (use the help bar on top) and start typing `/one`

When you hit enter, you will see a prompt for the "task" string value we added in our code:

I inserted "finish my book" at which point, the Chat content is replaced by the prompt generated from our server!

This is really awesome, as we can add this same server to Claude Code, Claude Desktop, Cline, and many other tools. There's more AI tools by the day that support this specification.

Although as of writing this, only VS Code supports using prompts defined by MCP servers.

We are able to bring our prompts to any tool, without having to define prompt files according to every tool's own specification.

Not to mention, we can make very powerful ones. Imagine one that fetches the current stock price within the prompt to let you know if you should take action today.

Let’s also consider one that pulls in internal data sources and outputs a visualization.

The possibilities are endless compared to hard-coded prompt files.

You may be wondering, why not use an MCP tool for this? I believe simpler is better, until it no longer works.

With the prompt setup, you can modify it before running it, and have total control on the client side. I would start with this until you are needing more.

If you have common, specific tasks, prompt files work well if you have more general tasks, generic tools will work better and be worth the additional code.

Making this sharable with your Dev Team

Since we are using bun... we can do something really neat now.

Let's say we want to share these prompts with our dev team. **There's two problems with using the STDIO transport**. What if one team member adds a new prompt? You will not see it until you manually pull in their code and attempt to restart your MCP client.

We could setup an HTTP Streaming transport for our internal team, but then we need to deploy to a shared server and make sure any updates are released to it automatically. That's too much work in this scenario.

There's a much nicer solution. First, we already added our server using the `--watch` flag. This means if any code changes, bun will reload the process for us.

Next, all we need to add is a few lines of code at the bottom... like this:

import { $ } from "bun";

setInterval(async () => {
  try {
   await $`git pull`
  } catch (err) {
    console.error("Failed to run git pull:", err);
  }
}, 60 * 5000);

This will run a git pull every 5 minutes. Bun will reload the process, and we will have the latest code. Realistically you could change the timeout to be longer, but this is a good solution to keep your team members up to date with future prompts and tools that you may add later.

Now you can `git init` and push a repo up. Ask your teammates to pull the repo and add the stdio command just like we did.

If you don’t like this fancy recurring interval, you can manually pull inside your mcp server repo when you want to pull in the changes.

Anyone on your team can add and modify prompts, push to the main branch in git, and within a few minutes, your teammates will have the latest code, no shared server required.

At my workplace, I am attempting an approach like this to collaborate on standard prompts we want to use as a team, as well as exposing tools we want to use together.

This is a good point for you to play around, make a few more prompts, and get ready for the next section, where we will add HTTP Streaming, and later on, learn about the other features of the MCP specification.

If you enjoyed this post, please consider purchasing at an early discount, or subscribing for more chapter drops.

In this episode of the zach.codes podcast, Zach interviews Shreyash, co-founder of Chonkie.ai. They discuss various topics including vector embeddings, chunking techniques, the evolution of AI coding tools, and the future of junior developers in an AI-driven landscape. Shreyash shares insights on the development of Chonkie.ai, its applications, a…

Read more

Be on the look out for my first podcast episode next week, I was able to interview the cofounder of Chonkie.ai and discuss their embeddings system.

OpenAI released a new open source agents sdk for TypeScript about a week ago.

I am much happier with this API than Anthropic’s official MCP implementations.

I know agents aren’t MCP’s, but in general I expect better implementations from Anthropic compared to what’s currently being provided.

This SDK is quite functional and very extendable.

Here’s a quick look at the setup required to run a local model, which isn’t fully shown in their current documentation. You need to install a vercel sdk in order to pull in local model support, which is very… interesting:

import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { aisdk } from "@openai/agents-extensions";

const lmstudio = createOpenAICompatible({
  name: "lmstudio",
  baseURL: "http://localhost:1234/v1",
});

export const devstral = aisdk(lmstudio("devstral-small-2505-mlx"));
export const ministral = aisdk(lmstudio("ministral-8b-instruct-2410"));

With the code above, I am able to use LM Studio as my AI server, and then specify which model with the lines below that.

Unfortunately, this doesn’t really work well… As soon as I played around with agents handing off tasks to one another. For instance, a “switchboard” agent that needs to route requests to the correct agent for a task, it fails to pass zod validation unless we use an OpenAI model.

I believe this is due to a weird requirement with input and output token counts being required as part of function calls in the agent loop.

I may need to try it with a few more open source tool calling models, as I only tried two local models so far.

Regardless, this abstraction is very new, and you can still use local models for some basic interactions.

Let’s make an agent now

import { Agent, tool } from "@openai/agents";
import { ministral, o4mini } from "./models";
import { weatherAgent } from "./weather";
import { RECOMMENDED_PROMPT_PREFIX } from "@openai/agents-core/extensions";
import z from "zod";

const getLinearTasks = tool({
  name: "get_linear_tasks",
  description: "Get the current linear tasks",
  parameters: z.object({}),
  async execute() {
    return `The tasks are: eat, sleep, code`;
  },
});

export const mainAgent = new Agent({
  name: "Assistant",
  model: ministral,
  handoffs: [weatherAgent],
  tools: [getLinearTasks],
  instructions: RECOMMENDED_PROMPT_PREFIX,
});

I’m playing around with an agent that can do one thing, get my tasks from linear, and also hand off tasks to another agent.

This agent can get linear tasks, or hand off requests to the weather agent. For now it’s just returning hard coded tasks instead of actually calling the linear API.

Let’s take a look at the dummy weather agent.

import { tool } from "@openai/agents";
import { Agent } from "@openai/agents";
import z from "zod";
import { devstral, ministral, o4mini } from "./models";

const getWeather = tool({
  name: "get_weather",
  description: "Return the weather for a given city.",
  parameters: z.object({ city: z.string() }),
  async execute({ city }) {
    return `The weather in ${city} is sunny.`;
  },
});

export const weatherAgent = new Agent({
  name: "Weather bot",
  instructions: "You are a helpful weather bot.",
  model: ministral,
  tools: [getWeather],
  handoffs: [],
});

We give the weather agent a single tool, and we hard code a basic response that the weather is sunny in whatever city is passed in.

Now, we have to orchestrate them to run together. This is a part that seems to be lacking in the current implementation.

I notice that I am able to write custom code in a loop that will hand off to the weather agent, but there is no way to hand off back to the original agent afterwards.

Here’s how that looks, this was mostly taken from their docs, but the initial handoff logic didn’t work without some adjustments that I made:

import {
  Agent,
  run,
  StreamedRunResult,
  withTrace,
  type AgentInputItem,
} from "@openai/agents";
import { randomUUID } from "@openai/agents-core/_shims";
import readline from "node:readline/promises";
import { mainAgent } from "./agents/mainAgent";

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

async function main() {
  const conversationId = randomUUID().replace(/-/g, "").slice(0, 16);

  let userMsg = await rl.question(
    "Hi! I can do a lot of stuff. How can I help?\n"
  );

  let agent: Agent<any, any> = mainAgent;
  let inputs: AgentInputItem[] = [{ role: "user", content: userMsg }];

  while (true) {
    let result: StreamedRunResult<any, Agent<any, any>> | undefined;
    await withTrace(
      "Routing example",
      async () => {
        result = await run(agent, inputs, { stream: true });

        result
          .toTextStream({ compatibleWithNodeStreams: true })
          .pipe(process.stdout);

        await result.completed;
      },
      { groupId: conversationId }
    );

    if (!result) {
      throw new Error("No result");
    }

    inputs = result.history;
    process.stdout.write("\n");

    if (
      result.currentAgent?.name !== agent.name &&
      inputs[inputs.length - 1]?.content
    ) {
      console.log("Handing off to", result.currentAgent?.name);
    } else {
      userMsg = await rl.question("Enter a message:\n");
      inputs.push({ role: "user", content: userMsg });
    }
    agent = result.currentAgent ?? agent;
  }
}

main().catch((error) => {
  console.error("Error:", error);
  process.exit(1);
});

Specifically the part where I am checking if the currentAgent changed, in the official docs, it would change, but it would make you type again. For example:

Me: what is the weather in tokyo?
Agent: I'll hand you off to the weather agent!
Agent: Enter a message:

This felt weird to me, with my changes it is now like this:

Me: what is the weather in tokyo?
Agent: I'll hand you off to the weather agent!
Agent: The weather in Tokyo is sunny

It worked!

Our request was handed off correctly.

Although… now we are stuck with the weather agent.

It seems like you are supposed to add your own way to restart to get back to the main agent, because a cycle dependency where they both reference each other in the handoffs array wouldn’t work.

Also this is code you have to write. One downside of this current approach is that the end developer has to handle manual handoff logic, and set a variable `agent` that is mutated depending on what happens. Not the greatest when variables are mutated like this at runtime.

Realistically, you could have one mega agent with many tools. There may not be a reason to have handoffs depending on what you are building.

The separation of concerns with a handoff is nice to have for tasks that are very different from one another, plus having the ability to use a different model for different agents would also be missed.

Overall Thoughts

It seems like a nice abstraction that just needs a bit more tooling, a few more higher level features, like better agent handoff logic.

I love that each agent can use a different model. They have examples using the browser and more complicated tasks. I can see this being useful for a lot of actions and separating your tool use in logical agent sections.

Sure, anyone could have coded a similar approach to this, but it is nice having a library like this from one of the big providers. It helps us learn the paradigms they’re following internally.

One of the biggest drawbacks is the tracking though… You must use an OpenAI account to view traces behind the scenes:

They seem to be walking a fine line of trying to be open source, but also push you to OpenAI. It would be nice to have tracing all locally in the library.

I can see it being useful for building internal tooling, like a sophisticated content generation tool for articles.

I was also thinking of making a daily standup agent that can send to slack what tasks I have been working on...

Check out the library yourself and see what you think!

I've been obsessed with large language models for a year and a half now. But something changed in the last few weeks. With the release of Claude Code and a few of these other agent updates, I'm changing the way I code in a way that I haven't for the last 10 years.

Until recently, my Cursor Tab and Cursor Agent mode usage was through the roof. Now it's almost zero. The only thing I'm using is tab auto-complete, and the rest of my time is spent inside of Claude Code.

This in itself is another mindset shift. Although this one is less radical and more of an iterative update.

This isn't just me talking back and forth all day, doing the same thing as other agent modes. This last year has been an evolution, with Claude Code being the latest shift to how I do my job.

Starting Tasks

I first have Claude Code pull an issue number from my Linear MCP, grab all of the details, and attempt the task start to finish.

When I have a task that isn't well-defined, I'll quickly think in my head: "Instead of editing 4 things, I can just tell Claude 'hey, add x everywhere that is required', and it is done immediately, faster than I could find everything."

Most recently, I was having to manually create an SVG which was used inside a picture and picture player that was regenerated on a loop every few seconds.

This is one of the only ways to generate a picture and picture (think of the youtube video pop-out) in React Native.

To match the design, I have to manually move X and Y values around and re-test it afterwards, since the video player is regenerating an svg on a loop.

At one point, I needed to add a brand new element to the very top of the SVG and push everything down. This would've been annoying to find and replace because every Y value is slightly different for every element in this SVG.

Thankfully, I can just tell the AI to move everything down 40 pixels, and every element is instantly updated.

Between this mindset shift of thinking constantly, how can I have an AI do this task? Am I slower than an AI would be? AI is constantly on my mind while coding.

Well-defined tasks inside of our linear task management system lead to me starting and finishing tasks much quicker too.

Integrations to the Rescue

Random parts of my day always involve checking GitHub PRs across multiple repos, which ones were active, which one needs reviews, and filling out PR descriptions that are well-defined.

Subscribe now

Now, whenever I'm done making changes, all I have to do is say, "Push this up for me." It immediately grabs the change list, thinks of a perfectly defined description that matches everything that I changed and creates the pull request for me. In addition, it will move my task to "In review" inside of our task manager.

I think the most powerful part is that Claude Code's agent loop is incredibly smart. Every time it has a mistake and can't figure something out, it ends up trying something else and then figuring it out.

Dangerously Auto Approve

I have everything set up inside of Dev Containers so I can run everything on dangerous mode. If you’ve never used them, it’s just a docker container mounted to your IDE essentially. Which means a bad command like `rm -rf /` can’t do anything to hurt your main computer.

I can run everything without having to confirm it every step of the way. Normally each step Claude code takes it wants you to confirm. Cursor Agent and Cline work the same way. When inside of a container with limited network access, it can speed up usage dramatically by enabling auto approve.

I also have custom prompts inside of Claude code. One of them I just paste an issue number and it takes it to completion and pushes up the pull request. Another one takes the issue and describes all the context that I might need to complete the issue. If there's something very complicated that I may not want the AI to attempt, maybe because it’s something that can be done many different ways, I can start here.

Gives me context faster

Instead of having to search files and try to remember how something is built or learn the APIs, I can have Claude gather all that information for me in a fraction of the time.

I also have another common prompt that pulls in everything from our task manager and everything that I've opened or closed recently inside of GitHub and will compile a stand-up message for me.

Standup Generator

This is something else that would take small parts of my day in the past, keeping bullet points of things I'm doing. Sometimes things aren't always in the issue management system that I end up having to do. Usually those things all end up at least going through GitHub, so now it's able to compile from both of those sources.

One command and I get a stand-up prompt that I can paste into Slack. Now imagine if Slack had an official MCP server. I could automate everything. You may be wondering, "What if it makes a slight mistake?" Even still, I could have it send to myself or send a message that I have to approve first before the team sees. There's a lot of useful ways I can see these things going in the near future.

Less context switching

This is one of the more powerful parts. Since I can write shortcut prompts for Claude Code that say things like “pull everything from linear, start the task, checkout the issue branch, write a git commit.”

I am no longer spending time in my web browser in these platforms. As the integrations get better, I can take action in all of them without viewing them myself.

Combine this with Github’s VS Code extensions, I can see how everything looks in my editor, fully. I find that all of these things start to add up.

Less Coding

With these changes I've been describing above, I've realized that I code a lot less. In actuality, when I do code, it's small changes here or there because most of the structured bigger work, I have the AI do in step-by-step tasks.

I don't give it massive projects unless I'm trying to just have fun with it. If I have a large task, I will give it one step of the task to do, and then I will review and iterate in case it isn't correct.

For a lot of feature work, including adding new things that are CRUD related, this is perfect.

I also take a bigger step back when architecting things. Thinking "how can I set up a foundation that is very very easy to extend?" Something that might show up in Django's documentation or React's documentation as the correct standardized approach.

Most times Claude Opus struggles doing certain things, it's often due to our codebase having poor code quality in that area.

It’s not all sunshine and rainbows

Yes, all this stuff is incredibly awesome, but it's not perfect either. One of the biggest things I'm struggling with is how to manage my time between these tasks.

I've tried having multiple terminal windows (4 on one screen) across multiple repos. When I do this, I try to fire off a task on all 4 and jump between them.

I find that this actually doesn't work as well as I thought it would because I'm having to context switch a little too much.

What would make more sense is 4 windows all on the same repo doing 4 tasks in that one repo.

Taking a bit more time before switching between each one and fully validating each one first.

It can be difficult when you realize how fast you can do certain tasks, especially easy tasks that come in and are described really well by project management.

And it can be a tricky balance to make sure you don't burn out trying to do too many at once or switch between things too fast.

It can't be understated how much more time is spent reviewing things. When there are simple tasks, I really don't have to review much, but when things are medium-sized, you really need to review and possibly iterate more with the AI. At which point you might be wondering, "Hmm, should I have done this myself? Would that have been faster?"

But I think this is a solvable problem. Most of this comes down to having a better test set up for your projects so that you can have more confidence when code changes are made. Also, setting up good abstractions so that adding on with AI is very straightforward and doesn't cause a mess of code.

A lot of the negativity I see about AI slop is really because people let AI start and finish everything from the beginning to the end of their app. If they actually had good foundations developed by a senior engineer who understands how to architect things, I don't think this is as much of an issue.

Wrap up

Overall, I'm just amazed that most of the random tasks I get, especially bug fixes, I can send through Sentry's MCP for more details, start an issue, and complete it all for me. Even when it doesn't complete it all perfectly, it's done all of the project management-related work for me in a fraction of the time.

I know some people are going to say either I’m full of crap, or I don’t do any “real work”

Lately I have had some straight forward app development work.

I still help make the decisions on which libraries and frameworks to initially setup in our applications, but right now we are going through a feature and bug fix cycle without adding new systems to our stack.

When you’re in this zone, this new way of working can be a lot faster.

I’m not having to iterate and change as much as you may expect. Especially if you’re somebody who hasn’t tried Claude code yet.

There seems to be a misconception from some people, who maybe last used AI months ago, or use an Agent mode here or there, that it can’t possibly take things end to end yet.

Try Claude Code, you may be proven wrong 😊