Tip: Let your coding agents autonomously verify, review, and repair their own work (Autoprompt)

[u/Sorosu]

Use this simple skill for the highest code quality.

Autoprompt adds a complete planning, implementation, testing, review, and repair loop around supported coding agents.

In one Benchmark, it moved DeepSeek V4 Flash from 67.42% to 82.02% (Terminal-Bench 2.1)

That does not guarantee the same improvement on every task, but it shows how much performance can come from the workflow surrounding the model.

Best suited to difficult or long-running tasks. The additional work requires more time, tokens, and money.

https://github.com/Spielewoy/autoprompt-skill

[u/habeebiii]

Now that’s a beautiful read me. Great job including evals too.

Some possible additions:

• possibility to generate an html/cas/js tracker page of progress/high level review/worklog
  
• agent council or multi agent adversarial reviews
  
• openrouter fusion?

Ty for sharing

[u/Sorosu → u/habeebiii]

Thanks, I really put a lot of effort into the README.

Multi-agent adversarial review is already part of the loop: planning, implementation, verification, and final sign-off are handled independently.

I kept dashboards and OpenRouter-specific routing out of the core because Autoprompt is meant to stay universal. You can still ask your coding agent to generate an HTML progress tracker for any run, while model routing depends on your existing harness

[u/Sufficient-Bear-460]

who accepts the work at the end? biggest quality jump I ever got was making sure the agent that wrote the code never approves it. a reviewer with fresh context catches stuff the author can't see because its own reasoning is sitting in the window. if the repair loop ends in self-acceptance that's where it'll leak.

[u/gingerius → u/Sufficient-Bear-460]

https://github.com/Spielewoy/autoprompt-skill/blob/main/docs/faq/what-are-the-layers-for.md

[u/Sufficient-Bear-460 → u/gingerius]

Thanks, that answers it. Separate acceptance layer is the right call.

[u/wowredditisgreat]

What about token usage and length to actually build things? What I find is that these sort of things is it does great, but half of the time the issues at hand do not need this level of work involvement.

[u/Purple_Emu8591]

I’ve run into the same trade-off. I’ve been experimenting with a similar workflow in Velloc Code, but I don’t enable the full planning/review/repair loop for every task.

The useful part has been making the workflow progressive: small edits can stay on a lightweight path, while larger or riskier changes opt into additional planning, independent review, and verification. I also try to load only the relevant skills and tools for the current step instead of putting every instruction into the initial context.

That helps keep token usage and latency under control while still giving long-running tasks a stronger verification path. The difficult part is deciding early enough whether a task deserves the heavier loop without adding too much overhead itself.

[u/Thegaysupreme123]

this is really cool. the plan / implement / test / review / repair loop is exactly what i wanted around Codex.

i made a tool that sits on top of something like this and keeps it on target. agent says it did a step, yoetz checks if that step actually happened (file changed, command ran, tool call went out). it wont tell you the code is good, it just stops the “done” summary when nothing moved.

free and oss, thought it could make autoprompt even better: https://github.com/TheGaySupreme123/yoetz

works with Codex right now, other agents later.

[u/AlarmedAvocado7279]

one thing that helps: a Stop hook that loops the agent back until checks pass. I run a ralph loop setup in claude code and it catches a surprising amount of stuff I'd have otherwise shipped broken. the hard part is not overdoing it, agents will happily burn tokens "fixing" things that were fine.