Login

u/AutoProspectAI

r/claudeskills r/mcp r/OpenaiCodex r/OnlyAICoding r/aiagents r/LovingOpenSourceAI r/windsurf r/CursorAI r/GithubCopilot r/ClaudeCodeTLDR r/ChatGPTCoding
I gave AI coding agents a dopamine loop. On my benchmark, it beat Ponytail on code, tokens, cost, and time.
▲ 1 r/OnlyAICoding

I gave AI coding agents a dopamine loop. On my benchmark, it beat Ponytail on code, tokens, cost, and time.

https://preview.redd.it/ryi8v19di2jh1.png?width=1194&format=png&auto=webp&s=1f1c468282dfd6594d15eaeffbc3992d5d4cddd3

Coding agents often mistake motion for progress. Ask for a small endpoint and you may get a new service layer, repository abstraction, response wrapper, and configuration system before the route even exists.

I built Dopamine to change that behavior. It is inspired by the way prediction and feedback guide human effort. The agent predicts the result, takes the cheapest useful action, measures what happened, adjusts, and stops when the request is verified.

Before creating custom code, it checks whether the behavior already exists, whether configuration is enough, whether the project already has the right helper, whether the platform provides it, and whether an installed dependency solves it. It writes something new only after the cheaper options fail.

I evaluated it on 12 tasks in a real open-source repository. Across four runs per task, Dopamine completed 48 trials with no timeouts or nonzero exits. Compared with the no-skill agent, it used 63.8% less source code, 29.7% fewer tokens, 27.9% less estimated cost, and 31.1% less time.

It works with Codex and Claude Code, includes a dependency-free installer, and has no telemetry, runtime service, or secrets. MIT licensed.

github.com/ujjwalredd/Dopamine

Progress that cannot be verified is just expensive motion.

UPDATE:

A benchmark that rewards smaller output has an obvious weakness: an agent can appear efficient by leaving work unfinished.

Instead of hiding that problem, I published the complete evaluation and its limits.

Dopamine is an open-source skill that makes agents choose effort based on uncertainty, test predictions against evidence, and stop at the smallest verified result. It reduces unnecessary work without treating validation, security, or correctness as optional.

The evaluation uses a pinned real repository, 12 identical tasks, isolated workspaces, one model, one reasoning level, recorded usage events, Git-based LOC measurement, and reproducible reporting. Dopamine ran four times per task; the comparison results remain frozen at one run per task to avoid later model and service drift.

Against the recorded Ponytail result, Dopamine measured 3.7% less source code, 15.2% fewer tokens, 11.8% lower estimated cost, and 7.4% less wall time. It finished lowest on all four measured efficiency metrics in this development benchmark.

That does not prove universal superiority. The tasks were used while tuning Dopamine, competitor variance is unknown, and feature completeness was not executable-graded. Those limitations are published beside the results because a defensible claim needs boundaries.

The repository includes the raw trials, hashes, benchmark harness, rejected candidates, chart generator, installer, and reproduction instructions. Anyone can rerun it, challenge the method, or build a stronger holdout.

Repo and full benchmark: github.com/ujjwalredd/Dopamine. If the result breaks under a better test, I want the test.

reddit.com
u/AutoProspectAI — 5 days ago
▲ 1 r/windsurf

I Built an AI Skill Inspired by How Humans Think

I built Dopamine, an AI skill inspired by how humans think, predict, act, and learn.

It focuses on making coding agents more efficient instead of blindly generating more code.

I benchmarked it against Ponytail, and Dopamine performed better on my 12-task benchmark across code generated, tokens, cost, and execution time.

Already at 51 GitHub stars and growing 🚀

Would love for people to try it, benchmark it, and tell me where it can improve.

https://github.com/ujjwalredd/Dopamine

u/AutoProspectAI — 5 days ago
▲ 10 r/CursorAI+2 crossposts

I gave AI coding agents a dopamine loop. On my benchmark, it beat Ponytail on code, tokens, cost, and time.

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

u/AutoProspectAI — 5 days ago
▲ 40 r/ClaudeCodeTLDR+3 crossposts

I gave AI coding agents a dopamine loop. On my benchmark, it beat Ponytail on code, tokens, cost, and time.

Coding agents often mistake motion for progress. Ask for a small endpoint and you may get a new service layer, repository abstraction, response wrapper, and configuration system before the route even exists.

I built Dopamine to change that behavior. It is inspired by the way prediction and feedback guide human effort. The agent predicts the result, takes the cheapest useful action, measures what happened, adjusts, and stops when the request is verified.

Before creating custom code, it checks whether the behavior already exists, whether configuration is enough, whether the project already has the right helper, whether the platform provides it, and whether an installed dependency solves it. It writes something new only after the cheaper options fail.

I evaluated it on 12 tasks in a real open-source repository. Across four runs per task, Dopamine completed 48 trials with no timeouts or nonzero exits. Compared with the no-skill agent, it used 63.8% less source code, 29.7% fewer tokens, 27.9% less estimated cost, and 31.1% less time.

It works with Codex and Claude Code, includes a dependency-free installer, and has no telemetry, runtime service, or secrets. MIT licensed.

github.com/ujjwalredd/Dopamine

Progress that cannot be verified is just expensive motion.

UPDATE:

A benchmark that rewards smaller output has an obvious weakness: an agent can appear efficient by leaving work unfinished.

Instead of hiding that problem, I published the complete evaluation and its limits.

Dopamine is an open-source skill that makes agents choose effort based on uncertainty, test predictions against evidence, and stop at the smallest verified result. It reduces unnecessary work without treating validation, security, or correctness as optional.

The evaluation uses a pinned real repository, 12 identical tasks, isolated workspaces, one model, one reasoning level, recorded usage events, Git-based LOC measurement, and reproducible reporting. Dopamine ran four times per task; the comparison results remain frozen at one run per task to avoid later model and service drift.

Against the recorded Ponytail result, Dopamine measured 3.7% less source code, 15.2% fewer tokens, 11.8% lower estimated cost, and 7.4% less wall time. It finished lowest on all four measured efficiency metrics in this development benchmark.

That does not prove universal superiority. The tasks were used while tuning Dopamine, competitor variance is unknown, and feature completeness was not executable-graded. Those limitations are published beside the results because a defensible claim needs boundaries.

The repository includes the raw trials, hashes, benchmark harness, rejected candidates, chart generator, installer, and reproduction instructions. Anyone can rerun it, challenge the method, or build a stronger holdout.

Repo and full benchmark: github.com/ujjwalredd/Dopamine. If the result breaks under a better test, I want the test.

u/AutoProspectAI — 6 days ago
▲ 19 r/OpenaiCodex

I gave AI coding agents a dopamine loop. On my benchmark, it beat Ponytail on code, tokens, cost, and time.

https://preview.redd.it/trorpmkgj2jh1.png?width=1194&format=png&auto=webp&s=82b891211e4b660c69719483d8c4a2611c89acd0

Coding agents often mistake motion for progress. Ask for a small endpoint and you may get a new service layer, repository abstraction, response wrapper, and configuration system before the route even exists.

I built Dopamine to change that behavior. It is inspired by the way prediction and feedback guide human effort. The agent predicts the result, takes the cheapest useful action, measures what happened, adjusts, and stops when the request is verified.

Before creating custom code, it checks whether the behavior already exists, whether configuration is enough, whether the project already has the right helper, whether the platform provides it, and whether an installed dependency solves it. It writes something new only after the cheaper options fail.

I evaluated it on 12 tasks in a real open-source repository. Across four runs per task, Dopamine completed 48 trials with no timeouts or nonzero exits. Compared with the no-skill agent, it used 63.8% less source code, 29.7% fewer tokens, 27.9% less estimated cost, and 31.1% less time.

It works with Codex and Claude Code, includes a dependency-free installer, and has no telemetry, runtime service, or secrets. MIT licensed.

github.com/ujjwalredd/Dopamine

Progress that cannot be verified is just expensive motion.

UPDATE:

A benchmark that rewards smaller output has an obvious weakness: an agent can appear efficient by leaving work unfinished.

Instead of hiding that problem, I published the complete evaluation and its limits.

Dopamine is an open-source skill that makes agents choose effort based on uncertainty, test predictions against evidence, and stop at the smallest verified result. It reduces unnecessary work without treating validation, security, or correctness as optional.

The evaluation uses a pinned real repository, 12 identical tasks, isolated workspaces, one model, one reasoning level, recorded usage events, Git-based LOC measurement, and reproducible reporting. Dopamine ran four times per task; the comparison results remain frozen at one run per task to avoid later model and service drift.

Against the recorded Ponytail result, Dopamine measured 3.7% less source code, 15.2% fewer tokens, 11.8% lower estimated cost, and 7.4% less wall time. It finished lowest on all four measured efficiency metrics in this development benchmark.

That does not prove universal superiority. The tasks were used while tuning Dopamine, competitor variance is unknown, and feature completeness was not executable-graded. Those limitations are published beside the results because a defensible claim needs boundaries.

The repository includes the raw trials, hashes, benchmark harness, rejected candidates, chart generator, installer, and reproduction instructions. Anyone can rerun it, challenge the method, or build a stronger holdout.

Repo and full benchmark: github.com/ujjwalredd/Dopamine. If the result breaks under a better test, I want the test.

reddit.com
u/AutoProspectAI — 7 days ago
▲ 22 r/claudeskills

I gave AI coding agents a dopamine loop. On my benchmark, it beat Ponytail on code, tokens, cost, and time.

https://preview.redd.it/ryi8v19di2jh1.png?width=1194&format=png&auto=webp&s=1f1c468282dfd6594d15eaeffbc3992d5d4cddd3

Coding agents often mistake motion for progress. Ask for a small endpoint and you may get a new service layer, repository abstraction, response wrapper, and configuration system before the route even exists.

I built Dopamine to change that behavior. It is inspired by the way prediction and feedback guide human effort. The agent predicts the result, takes the cheapest useful action, measures what happened, adjusts, and stops when the request is verified.

Before creating custom code, it checks whether the behavior already exists, whether configuration is enough, whether the project already has the right helper, whether the platform provides it, and whether an installed dependency solves it. It writes something new only after the cheaper options fail.

I evaluated it on 12 tasks in a real open-source repository. Across four runs per task, Dopamine completed 48 trials with no timeouts or nonzero exits. Compared with the no-skill agent, it used 63.8% less source code, 29.7% fewer tokens, 27.9% less estimated cost, and 31.1% less time.

It works with Codex and Claude Code, includes a dependency-free installer, and has no telemetry, runtime service, or secrets. MIT licensed.

github.com/ujjwalredd/Dopamine

Progress that cannot be verified is just expensive motion.

UPDATE:

A benchmark that rewards smaller output has an obvious weakness: an agent can appear efficient by leaving work unfinished.

Instead of hiding that problem, I published the complete evaluation and its limits.

Dopamine is an open-source skill that makes agents choose effort based on uncertainty, test predictions against evidence, and stop at the smallest verified result. It reduces unnecessary work without treating validation, security, or correctness as optional.

The evaluation uses a pinned real repository, 12 identical tasks, isolated workspaces, one model, one reasoning level, recorded usage events, Git-based LOC measurement, and reproducible reporting. Dopamine ran four times per task; the comparison results remain frozen at one run per task to avoid later model and service drift.

Against the recorded Ponytail result, Dopamine measured 3.7% less source code, 15.2% fewer tokens, 11.8% lower estimated cost, and 7.4% less wall time. It finished lowest on all four measured efficiency metrics in this development benchmark.

That does not prove universal superiority. The tasks were used while tuning Dopamine, competitor variance is unknown, and feature completeness was not executable-graded. Those limitations are published beside the results because a defensible claim needs boundaries.

The repository includes the raw trials, hashes, benchmark harness, rejected candidates, chart generator, installer, and reproduction instructions. Anyone can rerun it, challenge the method, or build a stronger holdout.

Repo and full benchmark: github.com/ujjwalredd/Dopamine. If the result breaks under a better test, I want the test.

reddit.com
u/AutoProspectAI — 7 days ago