r/CursorAI

I've been using Claude Code quite a bit and realized I was constantly looking back at my screen to see whether it had:

• finished the task
• stopped and needed my input
• was still working

So I built BrainSnack, a VS Code/Cursor extension that handles this for me.

While Claude is working, it opens a small panel with something short to read — AI news, technical articles, interview questions, output-based questions, etc.

And when Claude finishes or needs my input, it plays a sound so I know I can come back.

The interesting part is that it doesn't monitor the screen or scrape terminal output.

It's free and open source.

I'd really appreciate some honest feedback from other developers.

I also shared the build/story on LinkedIn. If you'd like to see it there (and help a small indie project get a little more reach), here's the post:

👉 Linkedin post link

Download links -
VS Code - https://marketplace.visualstudio.com/items?itemName=shikhargupta.brainsnack
Cursor - https://open-vsx.org/extension/shikhargupta/brainsnack

Thanks! Would love to hear what you think.

I wanted to test a narrow question: can an instruction skill make a coding agent use less code, fewer tokens, and less time on real repository tasks?

I created Dopamine, an open-source instruction skill that makes an agent first check whether the requested behavior already exists, whether configuration is enough, whether the project already contains the right helper, whether the platform or standard library provides it, and whether an installed dependency can solve it. The agent writes custom code only when those options are insufficient, then runs a targeted verification check and stops.

I evaluated it using a pinned checkout of tiangolo/full-stack-fastapi-template. The benchmark contained 12 identical frontend and backend tasks, isolated Git-initialized workspaces, GPT-5.6 Terra at medium reasoning effort, recorded model usage events, Git-based source LOC measurement, and process wall time. The evaluated conditions were a no-skill baseline, Caveman, Ponytail, and Dopamine.

The no-skill baseline averaged 138.5 added source lines, 222,256 processed tokens, $0.1447 in estimated API-equivalent cost, and 87.2 seconds per task. Caveman averaged 98.3 lines, 190,097 tokens, $0.1198, and 66.3 seconds. Ponytail averaged 52.1 lines, 184,212 tokens, $0.1183, and 64.9 seconds. Dopamine averaged 50.2 lines, 156,277 tokens, $0.1044, and 60.1 seconds.

Relative to the no-skill baseline, Dopamine measured 63.8% less added source code, 29.7% fewer processed tokens, 27.9% lower estimated cost, and 31.1% less wall time. Relative to the recorded Ponytail result, it measured 3.7% less source code, 15.2% fewer tokens, 11.8% lower estimated cost, and 7.4% less wall time.

Dopamine was run four times per task, producing 48 trials. The comparison conditions contain one recorded run per task. I kept those results frozen instead of rerunning them after the model and service environment changed. This prevents one kind of drift, but it also means competitor variance cannot be estimated and the final conditions were not measured simultaneously.

These results are development-set efficiency evidence, not proof that Dopamine produces better software or is universally superior. The tasks were inspected while Dopamine was being tuned, competitor conditions have only one run per task, and feature completeness was not executable-graded. A successful agent process does not prove that its implementation was correct. LOC, tokens, estimated cost, and time also do not measure security, maintainability, or usability.

The defensible conclusion is that Dopamine produced lower measured LOC, token usage, estimated API-equivalent cost, and wall time than the recorded comparison runs on this 12-task development benchmark. Proving an equal-quality advantage would require unseen tasks, executable correctness graders, simultaneous randomized runs, and repeated trials for every condition.

I published the raw trial records, task definitions, pinned inputs, skill hashes, benchmark harness, rejected experiments, deterministic chart generator, and reproduction instructions so others can inspect the methodology, reproduce the calculations, and propose stronger tests.

Disclosure: I created and maintain Dopamine.

Repository and full benchmark: github.com/ujjwalredd/Dopamine

As per title, I've been running off of composer 2.5 and later grok 4.5 for a few months now on the 20$ cursor sub. 20 is about as much as I use anyway, never really ran out.

If I sub to this supergrok option and use grok 4.5 in cursor next month onwards, can I expect similar limits or will they be much degraded from what I've come to expect?

Can anyone with experience shed any insight? I don't use multimodal GENERATION at all, I am exclusively a coder but I might paste images (mostly graphs, like box and whiskers etc) into the cursor prompt window durinf the coding process.

What usage band(s) can I expect if I go for this supergrok plan?

note that this is NOT asking about grok efficacy, I find 4.5 serviceable as is I do not wish to debate this point. this is purely/exclusively about value obtained from the 68% price drop (since it will be approx comparable to a cursor plan at that price)