Recursi
Self improving vibe coding env with no API fees
161 followers
Self improving vibe coding env with no API fees
161 followers
An extremely powerful environment for vibe coding, allowing you to use web based chatbots (Claude/Gemini via aistudio/ChatGPT, etc) extremely efficiently while staying firmly in their terms of service. A whole lot of apps are provided as samples / templates, including a YouTube playlist app that not only allows a great YouTube experience without ads (also within terms of service!), but "Guitar Hero for piano" that works with a MIDI piano. So much more.
Recursi
Foyer
The "no API fees" framing is interesting but the part I'd want to understand is what's actually happening under the hood. Are you running models locally, routing through your own hosted inference, or something else? That changes the tradeoff pretty significantly, especially for anything compute-heavy. Also curious what "self-improving" means concretely here, whether the environment is updating prompts and context based on your past sessions, or if it's something closer to fine-tuning on your codebase over time.
Recursi
@fberrez1 You can see it in the video what's happening.... it uses the web-based chatbots that are free or cheap. It uses copy and paste but it makes it super efficient so you're not having to go in and open individual files and find the right place and select the right text and then control V or whatever. Instead you just click a single button and it has Within the code coming back from the llm information as to which file and what function to replace. There are other things for instance you can add a dependency or delete a function or things like that but for the most basic stuff you just are replacing one function within one class within one file and the system just knows how to do it so you don't have to go and do it yourself you just click a couple buttons.
Look at 11:50 to 12:30 or so in the video where I do it..... it takes half a minute or so only because I am explaining it as I go.
I like that you're thinking abt beginners and kinds, not only experienced coders. That changes the product a lot. Does Recursi guide people toward a first small project or is it better for users who already know what they want to build?
Recursi
@busra_seker1 There's not a huge amount of guidance other than "watch a video showing how simple it is". I do one in the video where I grab the basic 3d app and have it make it so when you click on the sample geometry, it does some amusing explodey effects. It takes only a minute or so and is easy to copy.
I'd like to do a lot more things like that, and add more samples.
I'd like to know whether the self-improvement loop is mostly focused on code generation quality, or on helping the system build a better understanding of the project over time.
We've seen a lot of agent failures come from losing context between sessions rather than writing bad code in a single session.
Recursi
@zaid_mallik1 I'm not entirely sure what you're asking about the self-improvement loop. This is an app that I have worked on for almost a year, and it's about 80,000 lines of code. When it started out it was just a couple small files that helped manage cutting and pasting between the llm and files so that it would put the changes in the right place. Those also a script to help grab all the files in a directory and put them into a single markdown file so that I could paste it. So like maybe 500 lines of code total.
And when it got to maybe 2000 lines of code, suddenly my productivity started to get much higher because the system was just doing better at all these little tedious things. Maybe by the time it got to 20,000 lines of code, I was way more productive but still here and there there were little issues where I'd have to drop to the file system to fix something. But because my productivity was enhanced that much, fixing these issues with all the faster. So it took way longer to get from 2000 to 20,000 lines of code, then it took to get from 72,000 to 80,000 lines of code. Usually you'd almost expect it to be the other way around because once things get big it starts getting fragile. But again through the process it just keeps improving the thing in every way.
Everything about it gets better the more it increases its functionality and improves itself.
That said when I talk about self-improvement, I'm not talking about what most users are expected to use it for, they're probably not going to be improving recursi itself. Some of them might, I hope for that, but the primary reason they're getting benefit out of self-improvement is that the app is just getting really really sophisticated for something that one person could have put together.
And when I talk about lines of code, obviously I'm not claiming that more lines of code is necessarily better. Recently I went through a process of removing about 20 to 30,000 lines, as it became clear that so much old functionality the llm had just swept under the rug and papered over rather than removing as the app evolved. That is one of the toughest things I've had with llms that it does that. I don't know if the solution to that can be directly built into the app, but it's certainly something that can be taught to users..... You need to regularly go through and tell the llm to get rid of old functionality. And you need to not trust it when it says it's wiped it clean and it's now pristine you need to open it up in a brand new thread and ask it to find the same things and often it will find still a bunch that are left behind. I hope the models get better at this, but if not, it's certainly something that users can learn how to manage so they're apps don't just get filled up with a bunch of crust and then you start seeing old features coming back because the llm sees it in there and thinks it's gospel when it's really obsolete.
The copy-paste automation angle makes sense as a starting point, the friction of manually finding the right function and replacing it is real. What I'm curious about is how it handles conflicts when the LLM changes a function that other parts of the codebase depend on. Does Recursi detect those downstream breaks automatically or does that still fall on the user to catch?
Recursi
@imoluuu Recursi works in tandem with the LLM and almost never breaks things like that it.
It will change things in both files for, instance it will change a function and change where the function is called if that has to change too.
If you're working on a small app the LLM will tend to have all your code to the entire app, but if you're working on a large app -- for instance recursi itself is about 80,000 lines of code -- technically that can all fit into Gemini 3.5 although it's kind of pushing it.
But you also have a lot of tools for choosing which files to include and for it to know what is going on. Sometimes it does result in things not working or a crash but it's really good at sending that information back to the llm so it can figure out which file it needs to go and pull to fix it.
I mean honestly I could go on for a long time about this whole process but that problem is, if not 100% solved, darn close to it. It's extremely rare that it breaks something in that sense, and when it does it's quite easy to fix - its good at pulling not only files but error messages.
I'll go ahead and tell you about a process I use when working on really big projects which is to take the whole project build a prompt that has all the code to the entire thing, and drop that into Gemini. And I tell Gemini to analyze the problem that I'm talking about, tell me the full path to all the files that are involved even if peripherally, as well as just giving some analysis of how it probably can be fixed. But don't write any code.
Then I take what it gives me paste the entire output into a particular tool in recursi and it will build a new prompt that includes all the file paths saw in that output, that is it will grab all the code to all those files, or if I want to set it to only get the signatures or the documentation I can do that. And then I will use that as a start for a new thread where it's more focused and it doesn't have 100,000 lines of code but might have more like 10,000 that is pertinent to the specific problem. And I find that when you do that it tends to be a little smarter because it's not dedicating a lot of it's thought process to stuff that is completely irrelevant.
So there's lots of tricks like that but those really only come into play when you're working on huge apps if you're working on smaller ones no that problem is basically non-existent. If you look at the video where I tell it to take the 3D model and change it to have those amusing explosion effects or whatever, you'll see it affects multiple files and it goes and changes a whole bunch of methods in different files at the same time. So it knows what it's doing if you feed the context to it correctly and this doesn't take a lot of effort on the part of the user most of the tedium of it is handled by the app itself
Does it retain what it learned about your codebase or does each session start fresh?
Recursi
@joy_shekhar It retains it. The first and simplest mode saves it into the "indexed db" in your browser. It is sort of like cookies, except it can store a whole lot of data. You can clear it from your browser history in similar ways to clearing cookies. But it will automatically be there when you come back.. You can tell it to ignore it and come back fresh. (it only changes the functions that change, so not the whole project. good for fairly minor tweaks)
The second thing you can do it open a directory on your disk, and you can "fork" a project into it, renaming it if you want (including changing the names of Javascript classes within). Then it stores it there. Each time you come back to the site, there is a button you can click to re-open your directory and it will just reopen the last subdirectory(s) you were in automatically. So it will be on your disk forever, saving the entire project (but not copying things like shared libraries)
(if you use the first way, you can "upgrade" to the second way, through a menu item. It will copy your projects to disk.)
The third way is to download the repo, which is appropriate if you are changing the whole app itself, or if you want it to store all shared libraries in case the site disappears or something. But it still uses the technology above (the browsers ability to read and write to an approved directory and all subdirectories) to read and save to disk.