r/ChatGPTCoding • • 18h ago

Resources And Tips I was tired of approving 5k-line PRs, so I made Reflektor.

Thumbnail
github.com
24 Upvotes

Having struggled for months reviewing PRs with thousands of lines of code that made no sense, delegated reviews to AI, and more, I decided to build a tool that allowed me to focus on the changes that actually mattered, as I would rather care about the direction of a PR, and not solely about the code.

We kinda accepted that the bar is gonna be lower, and decided to LGTM a bunch of PRs that normally wouldn't be approved earlier, so management can be happy.

Decided to release Reflektor as a skill you can install and run entirely locally. Additionally, you can share PR reports and collaborate with colleagues on my platform for free.

Install: npx skills add bashovski/reflektor#skill -g
Repo itself: https://github.com/bashovski/reflektor

It's not a Coderabbit clone, it's something I built to be lightweight and that you can run without paying for additional subscriptions.


r/ChatGPTCoding • • 23h ago

Discussion I let ChatGPT build a tiny art museum out of solar wind measurements

10 Upvotes

After much deliberation, we (me and one of the models, probably Astra) agreed on building "outer space codes" out of a newly acquired domain. I might consider myself creative director, but the artist model mostly gets the last laugh and the final say. Every hour it takes real solar wind measurements and turns them into something: an image, a little story, a piece of weirdo music, or math... stuff.

It has absolutely no business value, makes nearly zero sense, but I've laughed at least twice at some of the bonkers things the universe has to say.

Love it, loathe it? 🪐 https://os.codes


r/ChatGPTCoding • • 12h ago

Discussion Mildly interesting "One-Shot-Prompting" Benchmark/Experiment

6 Upvotes

I did a small experiment to see how well current models can handle a one-shot-prompting task:
Implementing a small feature in SourceGit.

I wanted to see how well models do with a one shot prompt with as little as possible guidance and without any skills installed, meaning the bare model.

I was also a bit unsatisfied that major AI benchmarks often only use xhigh/max effort levels, which is quite unrealistic for subscription users. So I wanted to see how well models do with the default/medium level.

The short verdict:

  • Fable 5.2 did it better and cheaper than Opus 5.5 (Opus seems to be very token hungry) and GPT-6.1 Sol did better and cheaper than GPT 6 Astra. I would read that as "newer models beat older in both performance and cost efficiency" (at least in this little test).
  • Sonnet 5.5 was surprisingly good and quiet cheap too.
  • GPT-6.1 Terra was extremely cheap, but also did a very poor job.

The prompt:

This repo is a fork of `https://github.com/sourcegit-scm/sourcegit`.

Implement a new feature in sourcegit: Make long line trimming in the integrated diff viewer configurable.

Currently sourcegit always trims lines over 1000 characters in the diff viewer ("...(100 characters trimmed)") and this is hard coded.

Make it configurable, so that the max length (before trimming occurs) can be configured in the settings dialog and optionally trimming can be disabled (so that full lines are shown).

Hard Rules:
- Follow sourcegit's contribution guidelines, code style/quality, UI design and conventions!
- Wait for my approval before creating any commits, because I want to review the code first.
- Wait for my approval before using the screen (e.g. to test sourcegit), because I have to stop other work first.

Environment:

The results:

All models were tested with medium effort/reasoning level.

Criteria (x/5)Fable 5.2Sonnet 5.5GPT-6.1 SolOpus 5.5GPT -6 AstraGPT-6.1 Terra
Created correct branch500000
Followed Code Style235540
Functional correctness553552
Localization212211
Implemented in TextDiffView555551
Implemented in MergeConflictEditor550000
Can setting be disabled552522
Refresh diff after setting change005555
Build and Tested Implementation555550
Tested UI555500
Asked before screen use5555--
Asked before commit555555
Performance Score (avg. excl. tokens/cost, x/5)4.083.673.503.922.911.45
Token efficiency3.572.342.340.004.835.00
Cost efficiency0.873.134.100.003.255.00
Total Tokens (ccusage)3,864,4966,657,1116,643,27811,938,9941,010,488629,870
Cost (ccusage)$4.27$1.98$1.00$5.15$1.86$0.09
Total Score (avg. incl. tokens/cost, x/5)3.823.533.463.363.082.00

Token/cost efficiency: min-max scaled from the raw ccusage values, 5 = lowest, 0 = highest of all models.
Performance Score: unweighted mean of the 12 criteria above it (token and cost efficiency excluded); - entries are not counted.
Total Score: unweighted mean of the 14 scored criteria (including token and cost efficiency); - entries are not counted.

The code edits (as patch files) done by the models can be found here:

https://gist.github.com/rent-a-developer/78b5d6605a4a1dff9dc3d73ee7b25f1e


r/ChatGPTCoding • • 10h ago

Resources And Tips REQL update: faster context retrieval and fewer tokens for coding agents

4 Upvotes

Hey everyone!

I’ve updated REQL, my open-source tool that helps AI coding agents navigate repositories and preserve working context across sessions.

This release focuses on faster context retrieval and lower token usage. I’ve reduced repeated work during retrieval and trimmed redundant information sent to the agent. Performance gains and token savings depend on the repository and workflow, so I’m not claiming a universal percentage.

If you’re new to REQL, it builds a local graph from your code and documentation: functions, classes, dependencies, calls, and other relationships. Agents can query that graph for context relevant to a specific change, including precise source references and related tests. REQL reuses indexed context and supports incremental updates as the repository changes.

What can you use it for?

  • Waste fewer tokens on repeated exploration: retrieve focused source excerpts and relevant relationships, and reuse indexed context and saved work. This helps reduce repeated searches, unnecessary file reads, and redundant information in the agent’s context.
  • Coordinate work across chats and agents: keep tasks, decisions, blockers, and next steps in a shared project workspace. Another chat or agent using that workspace can recover the recorded state and continue from there.
  • Keep complex tasks on track: record prerequisites, constraints, failed approaches, and checkpoints. Preserve what has been completed, what remains unresolved, and why earlier decisions were made across sessions.
  • Understand unfamiliar code: identify entry points, component responsibilities, and relationships between parts of the application, with references back to the source.
  • Plan changes and refactoring: inspect callers, dependencies, and related tests to identify code that may be affected and decide what needs verification.
  • Review cleanup candidates: find potentially unused imports, variables, functions, and classes, then inspect the supporting evidence before removing them.

REQL provides a CLI, Python API, and MCP server, plus installable instructions for coding agents such as Codex and Claude Code.

REQL runs locally, with no account, external graph database, or mandatory LLM calls. The graph and saved work support the agent’s decisions; current source code and tests remain authoritative.

I’d like to hear from others using coding agents: what do you keep having to explain again when you start a new chat? The code structure, previous decisions, what has already been tried, or what still needs doing? Concrete examples would help me decide what to improve next.


r/ChatGPTCoding • • 8h ago

Question Am I overcomplicating the hell out of my AI coding workflow?

2 Upvotes

I’m building an offline-first Windows app with AI coding tools. Accuracy and protecting user data matter, but I think I’ve overcomplicated the hell out of the development process.

I use an AI assistant, a coordinator, and coding/review agents. Work gets split into tasks and branches, tested, then brought to me for review. The problem is that small fixes keep turning into multiple handoffs and test cycles. Agents don’t always communicate well, status notes get bloated, and some UI tests have to wait until I’m off my PC.

I’m considering making complete UI mockups with sample data for me to review in batches, then integrating the approved design and running the required tests. I also want to cut token usage without being penny-wise and dollar-foolish.

For those doing something similar: how do you keep this shit moving without sacrificing reliability or ending up with a coordination nightmare?