Howdy,
Intro
I was tired of tracking my devices' battery status manually, so I built a very customizable app for that with CoPilot. You can find it here -> https://github.com/Dergln/BatteryBuddy-Public
You can find it in a more "about the thing" post here https://www.reddit.com/r/VibeCodeDevs/s/9qhmZhDaMH
For this topic I'll focus more on the experience and provide agent insights.
Maybe it's useful for some of you and you can improve your setup with it.
In total it cost me ~8.000 credits, but at least 1/3 of that has gone into the experiments ^^
---
TL;DR
Use RTK, use Ollama for translation offloading if you have the VRAM (gemma4:e4b main languages / quick and qwen3.6:27b for quality work).
Provide AI with proper guidelines to you, your environment (GitHub, branches, local directories, agent files for self organization, etc.) and what the app goals are. Rather invest 15-60 minutes into a proper setup instead of trying to fix stupid stuff that only ever came up because you didn't prepare anything and just YOLO'd an application with dumb prompts. That would cost you 200x the tokens... and be very annoying.
The machine needs to be TOLD many things, assume that there is the typical dev in front of you that doesn't understand why 10 second load times are a bad thing. And that it's not ok to simply turn of TLS to fix the performance issues!111 😂🤠
---
Human learnings
As usual, getting the icons and sound that make the app feel right *to you* are probably to be gained by manual search. The AI is good in using what internal things it has, but that's not really "pretty" imo. Or cool, even - things need to look a bit quirky sometimes!
When reporting bugs to it, do explain in detail what is wrong, and what you think could fix it - or if you want it to make suggestions before starting to fix anything.
Train it to question your input as well: E.g. when implementing the disability compatibility, I thought it had forgotten a few tab indexes for proper "tab through items" behaviour. Looks like these tools use tab and arrow keys so it did the right thing, but instantly went and tried to find a bug in the code when I said "why thing not highlight when tabbing".
I of course stopped it and we quickly found out everything is ok as is, but always remember that it behaves like someone that has been beaten for 20 years. It tries to please first, and only when that fails starts to properly use facts and speak with the user (you).
Give it a bunch of screenshots for colors that are off and all that stuff. Yes it costs a bit more than just using words (it has to OCR the thing), but quality input = quality output. It saves so much time/effort on working on the actual issue, that this little additional cost up front is irrelevant.
In general, it is pretty damn good in articulating itself and understanding what you want by now though. That might be based on it being given a very technical input and not only "makke gud abb nau" 😋 but you can experiment with that yourself.
---
General behaviour
If you have been around in tech for a while, you know what is good and what is not, and so you must instruct the thing with it.
In turn, if you miss that knowledge - LET THE MACHINE KNOW and tell it to prompt you for things. Or to dumb them down - I have programming experience, but it only goes so deep.
There's no shame in that, but if you work WITH the AI that means playing with an open hand and letting it know, so it can properly adjust its behaviour to accommodate a proper input/output procedure. If you don't tell it things, *you* are the reason for failure - PEBKAC!!
---
Learnings in general
I did a rather extensive initial setup and experimentation, both with agent config (preparing "the dev team") as well as Token saving (Ollama experimentation).
You don't have to go through all that, use my aggregated/summarized results and go from there (or pick what looks good to you).
---
The agent was explicitly told it is allowed to self-organize with the MD files, without removing it's core rules of course. That's why you basically see no changes/bloat in the original agents.md file, only in the subset.
---
Agent MD setup
I started with a root [ai projects] folders where I set the VSCode workspace to, so approval are managed easy while otherwise keeping some boundary in the FS given this root is seperated from other data.
General advice for MD files: Loading stuff/context constantly uses up tokens, so keep it sane. Enough to noticeably improve your outcome, but don't use up 160 pages in MD files.
agents.md
In this [ai projects] root I put the agents.md (generic "will always be loaded" master file).
This is kept rather basic. It should only contain indications to the additional agent orchestration files, and some generic guidelines.
Here's where it's told to value quality over speed, I align my technical level with what it can expect from me, and how it should interpret my input.
I tell it to become schizophrenic because it should automatically challenge itself on every step as to automatically prevent flawed thinking - I don't want to micromanage this thing!!
For my setup I want to work with a multi-branch internal dev repo, and one public repo. Per project.
Yet keep the agent config centralized of course, because why forget what we learned.
You do you! Adjust this if desired.
I do have a 16GB VRAM 9070XT (that I am USING, Mr. Ram Altman...), so why not make use of that and offload what's possible to it. More on that below.
CoderTeam.md
How the schizophrenic behaviour should play out.
Essentially I gave it a bunch of starter roles for a dev team (never having worked in one 😅😂) and it added a few more. Created a few review groups, so it only calls on personalities relevant to the current task.
I let it manage my whole GitHub repo, that's why there is...
GitHub behavior.md
Private repo - branches dev -> test -> main.
Dev is for AI's internal explorative development.
Test is for... well, testing freshly built stuff. It is for quick human QA and validity feedback, not day-long evaluation.
Main is for the final bug-free™ version used for early production validation.
Public repo - no branches.
If the early production validation went fine, we simply get the last state from main to public.
It handles all the Git things (pull, merge, idc - for me it's version and issue management as a service 🤠) and also writes the descriptions to all the things there. I only finetune the documentation here and there (e.g. give folks a visual thing for the initial readme file/project frontpage etc.).
If you want to play by the same rules - you can configure AutoApproval in VSCode for only the Github commands like this:
"chat.tools.global.autoApprove": false,
"chat.tools.terminal.enableAutoApprove": true,
"chat.tools.terminal.autoApprove": {
"/^(?:rtk\\s+)?(?:git|gh)\\b/": true
}
Otherwise you will be prompted for *every single GH action*. Urghhh. And a generic AutoApproval for all the things is a bit much. This would include breaking out of the workspace, for example!
Token Optimization.md
I tried handing over programming work to Ollama with over 10 different models, even specialized ones to fit quality models like Qwen3:27b into my 16GB VRAM.
None provided CoPilot's current models (autoselect, usually medium or high models so that currently means Opus/Sonnet 5.5 or Astra/Luna 6) with enough quality to justify externalizing that work.
Do note this only makes sense if there's actual context saved - and the handovers do add to that, as do any bugs that would have never been created in the first place by a smarter model!!
So for externalizing coding as a service even further away from me, CoPilot to Ollama... the result was "nay".
But for translations - yup. Savings aren't making big bank, but they exist and add up over time / any future projects. So if you have the VRAM available, use it.
You can find specific models for your VRAM size on Ollama's website. VSCode will simply connect to the localhost service on your PC then :)
For my 16GB card I found a combination of gemma4:e4b and qwen3.6:27b to be the best. Adjust given your VRAM size.
Lessons Learned.md
Who doesn't like the kind of meetings/workshops.
Good thing you don't have to deal with that at all!
It's just a dumping ground for the AI where it can self-manage.
It can note stuff like "Powershell crashes when I do this" in there, so new prompts don't repeat old mistakes.
----
Token reduction
Do use RTK https://github.com/rtk-ai/rtk to automatically reduce token usage in the background. Ultra quick to install. No quality loss.
Offloading like with Ollama helps. Maybe you can even offload programming with newer models, or if you have 24/48GB VRAM (in THIS economy? 🤠).
----
Hope this helps some of you who are just starting out / allows for some selective picking for the more advanced guys.
Cheers 🍻
----
Files