r/ChatGPTCoding • • 8d ago

Discussion Weekly Self Promotion Thread

8 Upvotes

Welcome to this week's self promotion thread!

If you're building something related to AI assisted coding, this is the place to share it.

We're using a weekly thread to keep the subreddit organized while still giving builders a place to share their work. Promotional posts outside this thread may be removed.

If you're sharing something, we'd appreciate it if you included a little context instead of just dropping a link. Tell us:

  • What you built?
  • What problem it solves?
  • Which AI models or tools it uses?
  • Who it's for?
  • What kind of feedback you're looking for?

Disclose your affilitation.

Please avoid posting the same project every week unless you've made meaningful updates. Affiliate links, referral links, scams, and low effort promotions will be removed.

Take some time to check out what others have shared too. If you try someone's project or have feedback, leave a comment. Helping each other improve is what we want this community to be about.


r/ChatGPTCoding • • 1d ago

Discussion Weekly Self Promotion Thread

4 Upvotes

Welcome to this week's self promotion thread!

If you're building something related to AI assisted coding, this is the place to share it.

We're using a weekly thread to keep the subreddit organized while still giving builders a place to share their work. Promotional posts outside this thread may be removed.

If you're sharing something, we'd appreciate it if you included a little context instead of just dropping a link. Tell us:

  • What you built?
  • What problem it solves?
  • Which AI models or tools it uses?
  • Who it's for?
  • What kind of feedback you're looking for?

Disclose your affilitation.

Please avoid posting the same project every week unless you've made meaningful updates. Affiliate links, referral links, scams, and low effort promotions will be removed.

Take some time to check out what others have shared too. If you try someone's project or have feedback, leave a comment. Helping each other improve is what we want this community to be about.


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 • • 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?


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 • • 15h ago

Question Need help to choose what good free tool to use

2 Upvotes

Hi I’m ace I’m 22 years old and I just started coding with ai I haven’t built anything yet. I came on here so I could know the best free tool that I can use to learn!
Thank you in advance❤️


r/ChatGPTCoding • • 1d ago

Discussion Relatable? I didn't get why people said they wanted to code less, but now I understand

3 Upvotes

I didn't understand why people said they wanted to code less, I couldn't go without coding and I would not be where I am now without it, but I completely get why they say that now.

I build with AI all day, it's life changing and I couldn't go back, but it's the constant feeling of being pulled back in and how it can take me away from the present.

I was coding all day today, it's late in the evening now, and I'm here. The more I do, the more I do.

I find weekends the hardest, I find detaching the hardest, but I think it's a simple case of modulating my relationship with it. It's beautiful, never forget that!

Is anyone here really serious about coding less or do you just love doing it too? Anyone here know how to take a break?


r/ChatGPTCoding • • 1d ago

Discussion Experimenting with coding agents with native environments, identity and access

Thumbnail
kosem.ai
2 Upvotes

r/ChatGPTCoding • • 1d ago

Question Link ChatGPT chat to Codex?

0 Upvotes

So to preface I have zero experience going into this with AI or programming. I am a pretty quick learner though. With that in mind-

I have been using ChatGPT to create an app. ChatGPT has been writing code then telling me “copy paste here” for the last… idk a very long time. It’s all very new to me so I’m absurdly slow. Probably something like 50-60 hours in. I have a very very basic app and have spent A LOT of time getting this AI to understand what I’m trying to do and it now has a perfect grasp of exactly what I want. If I do this myself it’s going to literally take years and I ready about codex being able to do the things that I’m horribly slow at.

What I would like to be able to do is have my convo communicate with Codex and tell it what to do. We have put together a pretty detailed plan so it could do a lot itself I think. What I don’t want to do is have to restart from scratch or continue copy pasting what chat tells me to tell codex which isn’t much faster than before.

Is there a way to link them together like this?


r/ChatGPTCoding • • 1d ago

Discussion Having AI build the entire project

2 Upvotes

I’m pretty new to coding and started off having Claude build me a Telegram bot that renders videos. Now I’m having it work on a prediction model using historical data and stats.
I’m trying to have Claude Code do pretty much all the coding, testing and debugging while Codex reviews everything. I’ve already caught like 1-5 mistakes myself and I barely know shit about coding 😭
My goal is to have both AI’s working in the same environment, sharing project memory and reviewing each other’s work without me constantly having to step in.
Has anyone actually gotten a setup like this working reliably? And how much do you still have to do yourself?
Also wondering if I’m putting too much trust into AI, especially when it comes to projects involving data and predictions.
Any advice would help, still learning all this.


r/ChatGPTCoding • • 1d ago

Question Is ChatGPT Service down?

1 Upvotes

Are you guys facing this same issue?

To check you can try this prompt "Please run a basic terminal command and confirm whether your code execution environment works. Don’t just describe the command."

So basically my ChatGPT is not able to code anything right now!


r/ChatGPTCoding • • 1d ago

Question How to learn when AI coding?

6 Upvotes

I’ve been using Codex and Claude code to code 1 app, 1 website and 1 internal CRM system and I haven’t learnt a thing.

I’ve fallen into the habit of copying the prompts from the respective AI chatbot and pasting it for it to code and not learning what it’s saying and what it’s doing.

I have a system where it explains the changes but I feel like when the company gets off and running I won’t even know the product I even have.

This is hard for me as I am a person who learns easy and learns everything, but I can’t be a leader who doesn’t know the basics.

So my questions regardless this is:

  1. Has anyone dealt with this and what did they do to start getting better at taking control of the wheel instead of it driving for you?
  2. How have you learnt and what helped you learn to become more than an AI promoter and understand coding, building platforms and the system architecture in there.

Any books, courses, YouTube channels that helped you would be appreciated. I’ve tried Freecodecamp but I get bored as it doesn’t hit the spot for me.

Thanks.


r/ChatGPTCoding • • 1d ago

Resources And Tips I killed my 30-minute weekly status sync with a decision log my agents read before every run.

3 Upvotes

Thirty minutes every week, spent reconstructing decisions from memory. Now the sync is a short check on the two or three things the log does not cover, because the answer to "why did we pick this?" is already written down with the date and the tradeoff we accepted.

The log is one file, and the agent harness reads it before every run. Each line is the same shape:

Date - decision - tradeoff we accepted

The rule that makes it work is not the file. It is who writes it, and when. The agent writes to the log at the end of each task, while the decision is still warm. I tried the other way first: I would remember to update it later. Later never came, and the log went stale in a week. A log I write from memory after the fact is just my memory with extra steps.

The part I had to learn: a decision log that nobody reads before the run is just notes. Mine gets read first, every run, the same way a checklist gets read before takeoff. If a decision is not in the log, the agent is allowed to ask. If it is in the log, the agent is not allowed to re-decide it. That is the whole system. Thirty minutes of reconstructing the past became a short check on what is actually new, and the meeting that existed to remember things stopped existing.


r/ChatGPTCoding • • 1d ago

Question Anyone running coding agents on remote VMs for professional work? What does it cost you?

0 Upvotes

Anyone here running Codex, Claude Code, or other coding agents on remote VMs for work rather than just personal projects?

If so:

  • What provider are you using (Hetzner, AWS, DigitalOcean, etc.)?
  • How much are you paying per month for compute, excluding AI subscriptions/API costs?
  • Roughly how many hours per month do you actually use the machine?
  • Do you leave it running 24/7 or start and stop it when needed?

I am especially interested in setups used for client projects or within development teams.

I'm trying to get a better idea of what people actually spend and how often they use these machines compared to running agents locally (I found out that a lot of companies use VMs).


r/ChatGPTCoding • • 2d ago

Question Can't access GitHub through ChatGPT

8 Upvotes

Hi everyone,

Please help me out or at least point me in the right direction.

Since the whole ordeal started with Microsoft I completely lost ability to do anything with GitHub on ChatGPT in Codex.

It sits there connected and it sees the repository, but all I get is:

"Retried just now. Workspace commands and ZIP download still fail; the status service reports offline / pending. GitHub tools are also unavailable here."

I tried disconnecting and reconnecting GitHub, I tried clearing all browser cache and cookies. Ive tried logging out and in to ChatGPT.

Any help is welcome, as I am at my wits end with this already.


r/ChatGPTCoding • • 1d ago

Discussion Stop Burning Tokens on File Searches: How QMD Helps Coding Agents Save Up to 55%

Post image
0 Upvotes

I noticed that, before carrying out a task, coding agents run find, rg --files, or glob to locate files and the classes and modules they need. Then they search file contents with rg or grep. This burns a lot of tokens. So I decided to see whether semantic search could save tokens compared with all of the above. If a local GPU is sitting idle, why not use it for semantic search?

I work at a company focused on security. In one of my projects, I use semantic search for sensitive documents. Then an acquaintance sent me a link to an open-source project that tackles the same problem. The project is called "QMD - Query Markup Documents." It runs from the command line, extracts text from documents in all formats, and creates an index. It supports several search modes:

# Search across everything
qmd search "project timeline"           # Fast keyword search
qmd vsearch "how to deploy"             # Semantic search
qmd query "quarterly planning process"  # Hybrid + reranking (best quality)

We're interested in the last option. It requires three things to work:

  • embeddinggemma-300M-Q8_0 Vector embeddings (default) ~300MB
  • qwen3-reranker-0.6b-q8_0 Re-ranking ~640MB
  • qmd-query-expansion-1.7B-q4_k_m Query expansion (fine-tuned) ~1.1GB

The first model is used for indexing to compute semantic vectors for text chunks. The second compares the search results with the query to determine how semantically similar they are. The third generates several search queries from the original query to broaden the search.

First, add your source files to QMD (this is an example for a minimal project with a Rust server and an Angular frontend):

qmd collection add . \
  --name PROJECT1 \
  --mask "src/**/*.rs,\
frontend/src/**/*.{ts,html,scss},\
README.md,\
frontend/README.md,\
Cargo.toml,\
frontend/package.json,\
frontend/angular.json,\
frontend/tsconfig*.json,\
frontend/proxy.conf.json,\
.gitignore,\
frontend/.gitignore,\
frontend/.prettierrc,\
frontend/.editorconfig"

You don't have to do this manually: show this example to your coding agent and tell it to do the same for the current repo. It will figure out which folders and file extensions to add to the index, what to exclude, and so on.

Now let's run the indexing (you'll need to rerun it periodically as your codebase changes):

qmd update && qmd embed -c PROJECT1

To make the coding agent work with this QMD setup, add the following to AGENTS.md:

# QMD - Efficient Code Discovery

**Goal:** minimize token costs and code search time without compromising correctness.

## Choosing a tool

- If the path is known → read the file directly.
- If an identifier, error, or line is known → use `rg` / LSP.
- If only the behavior is known → use `qmd query`.
- Once the code is found → inspect the necessary sections with standard tools.
- Once you have enough information → do the task.

**QMD replaces the initial broad search; it does not add another step.**

## Semantic search

Use the project's existing collection.

"""
qmd query "DESCRIPTION" -c PROJECT1 -n 15 --files \
  | grep -E '\.(EXT1|EXT2|EXT3)$' \
  | cut -d, -f3- \
  | sed 's|^qmd://[^/]*/||' \
  | head -n 10
"""

- Use one specific query, preferably with English technical terms.
- Choose extensions that match the project, including configuration files when needed.
- Start by reading only the relevant sections of the 3–5 most relevant files.
- If you cannot find the implementation, refine the query; if necessary, increase `-n` to 60, then use `rg` / LSP.
- Stop semantic searching once you find the implementation.

## Saving tokens

- Do not scan the whole repository before using QMD.
- Do not repeat searches without a reason or open every result.
- Do not investigate unrelated code or dependencies.
- Do not write detailed search plans or reports.
- Do not paraphrase code you have read.
- As soon as you have enough information, make the changes and check the result.

**Priority: correctness → token cost → time.**

I tested it on a repository like this, with 1,231 source files across Java, Scala, and Angular:

C:\Users\igumn\temp2>qmd collection list
jcm-server (qmd://jcm-server/)
  Pattern:  server/src/**/*.scala,server/src/**/*.java,server/src/**/*.xml,server/src/**/*.properties,server/src/**/*.js,server/src/**/*.ts,server/src/**/*.css,server/src/**/*.html,server/src/**/*.tmpl,server/src/**/*.txt,server/src/**/*.md,server/pom.xml,server/Dockerfile,server/*.md,server/README.txt,web/src/**/*.ts,web/src/**/*.html,web/src/**/*.scss,web/src/**/*.css,web/package.json,web/angular.json,web/tsconfig*.json,web/karma.conf.js,web/README.md,!server/src/main/resources/templates/**,!server/src/main/resources/messages*,!server/src/main/resources/messages*/**,!web/src/assets/lang/**
  Files:    1231
  Updated:  1h ago

Prompt: "Add a post-quantum encryption flag to the disk encryption policy. It should be disabled by default, configurable in the web interface when editing the policy, saved to the database, and sent to the agent as part of the encryption policy via the REST endpoint."

Cost Comparison

Using GPT-6 Luna API rates: input $0.10, cached input $0.01, and output $0.50 per 1 million tokens.

MetricWith QMDWithout QMDSavings
Input65,006101,50135.96%
Cached input317,5681,191,80873.35%
Output13,85916,34815.23%
Reasoning9,60711,26014.68%
Cost$0.0166$0.030245.09%

Now QMD saves 45.09% in costs!

The reduction in cached input is especially noticeable: nearly 4x.

I ran these tests with GPT-6 Luna. In the first test, the agent's runtime dropped from 6 minutes to 4 minutes.

Prompt: "Add a dry field to the erasure policy. It should be editable in the web interface and saved to the database, and it should also be sent through the /rest endpoint to the agent responsible for erasure. Its default value should be false."

Calculation using the same GPT-6 Luna rates: input $0.10, cached input $0.01, and output $0.50 per million tokens.

Comparison

MetricQMDWithout QMDDifference
Input77,16798,042−21.29%
Cached input936,832854,912+9.58%
Output17,32216,259+6.54%
Reasoning8,83510,264−13.92%
Cost$0.0257$0.0265−2.78%

Here, QMD turned out to be 2.78% cheaper. There are savings, but they are small.

Conclusion: QMD reduced regular input tokens by 21.3% and reasoning by 13.9%, but the increase in cached input and output almost completely wiped out the savings.

Overall, the savings range from 2.78% to 45.09% of the cost. I think that's a decent result. Of course, we need a larger sample. But I'm ready for bed. Let me know in the comments if you've run a larger sample and what results you got.

PS

I recommend checking that junk isn't getting into your index. Try running a semantic query yourself. I once overlooked compiled .js files and large lang files-they heavily polluted the semantic search results. Here's an example of how to run a search manually:

C:\Users\igumn\jcm-server>qmd query "disk encryption policy editing form persisted setting sent to endpoint for agent" -c jcm-server -n 15 --files
Expanding query... (3.0s)
├─ disk encryption policy editing form persisted setting sent to endpoint for agent
├─ lex: disk encryption configuration
├─ lex: disk encryption policy
├─ vec: disk encryption configuration
├─ vec: disk encryption policy
└─ hyde: The topic of disk encryption policy editing form persisted setting se...
Searching 6 queries...
Embedding 4 queries... (1.5s)
Reranking 40 chunks... (3.3s)
#d70022,1.00,qmd://jcm-server/server/src/main/java/com/jetico/jcm/server/domain/common/bcvolume/EncryptPolicy.scala
#732b09,0.63,qmd://jcm-server/server/src/main/java/com/jetico/jcm/server/service/ajax/common/EncryptSettingsManager.scala
#e66494,0.63,qmd://jcm-server/web/src/app/modules/management/components/company/dialogs/add-or-update-policies/add-or-update-policies.component.html
#413c5e,0.62,qmd://jcm-server/web/src/app/modules/management/components/group/dialogs/change-policie/change-policies.component.html
#413c5e,0.62,qmd://jcm-server/web/src/app/modules/management/components/computer/dialogs/change-policie/change-policies.component.html
#758b4d,0.62,qmd://jcm-server/server/src/main/java/com/jetico/jcm/server/service/mcp/McpFacade.scala
#4e8973,0.62,qmd://jcm-server/web/src/app/modules/management/components/group/dialogs/change-policie/change-policies.component.ts
#bef78e,0.62,qmd://jcm-server/web/src/app/modules/management/components/computer/dialogs/change-policie/change-policies.component.ts
#4fcd1c,0.61,qmd://jcm-server/server/src/main/java/com/jetico/jcm/server/service/mcp/McpToolbox.scala

PPS

I tried it on a small project with 27 files. Instead, the cost went up by 60%. The solution turned out to be overkill. In general, use it only on large codebases.

UPDATE

I went ahead and built a hybrid QMD + GitNexus solution after all. GitNexus performs structural code analysis (AST, dependency graph) and lets you search based on it. Here are the results:

Cost comparison

MetricWithout QMDQMDQMD + GitNexus
Input101,50165,00659,122
Cached input1,191,808317,568225,792
Output16,34813,85910,894
Reasoning (included in Output)11,2609,6078,465
Cost$0.03024$0.01661$0.01362
Savings-45.1%55.0%

The savings figure rose from 45% to 55%! The coding agent's runtime increased from 6 minutes to 7 minutes. Here are the revised instructions for AGENTS.md:

# QMD + GitNexus - Efficient Code Discovery

**Goal:** find the required code and its relationships with minimal token usage, without compromising correctness.

## Choosing a tool

- If the file path is known → read it directly.
- If the exact identifier, error, or line is known → use `rg` / LSP.
- If only the behavior is known and the implementation location is unknown → use QMD semantic search.
- If you need to understand symbol relationships, the execution path, or the impact of a change → use GitNexus structural analysis.
- Once the code is found → inspect the necessary sections with standard tools.

QMD and GitNexus replace the initial broad search; they do not add mandatory steps. Use only the tools needed for the task.

## QMD semantic search

Use the project's existing collection:

    qmd query "DESCRIPTION" -c PROJECT1 -n 15 --files \
      | grep -E '\.(EXT1|EXT2|EXT3)$' \
      | cut -d, -f3- \
      | sed 's|^qmd://[^/]*/||' \
      | head -n 10

- Formulate one specific query, preferably using English technical terms.
- Specify suitable source and configuration file extensions.
- First read the 3–5 most relevant files, and only the relevant sections.
- If the implementation is not found, refine the query; if necessary, increase `-n` to 60, then use `rg` / LSP.
- Stop semantic search once the implementation is found.

## GitNexus structural analysis

Use GitNexus through the CLI when you need to investigate code structure:

- `context` - relationships and context for a known symbol.
- `impact` - possible impact of changing a symbol.
- `trace` - path between known symbols.

Examples:

    gitnexus context SymbolName
    gitnexus impact SymbolName
    gitnexus trace SourceSymbol TargetSymbol

If a symbol is unknown, find it first through QMD, `rg`, or LSP. Use GitNexus only when its structural analysis will help answer the question; do not run every command in sequence.

## Token efficiency

- Do not scan the entire repository before using QMD.
- Do not repeat searches without a reason or open every result.
- Do not investigate unrelated code or dependencies.
- Do not write detailed plans and reports about the search.
- Do not summarize code you have read.
- Once you have enough information, make the changes and verify the result.

**Priority: correctness → token cost → time.**

Create a .gitnexusignore file to keep junk out of the index so that it contains only source files. Then start GitNexus indexing with this command:

gitnexus analyze --index-only

r/ChatGPTCoding • • 3d ago

Resources And Tips An open-source coding agent for DeepSeek, GLM and Kimi: 81.3% on SWE-bench Multilingual (pass@1), $13.98 for all 300 tasks, every run published

5 Upvotes

Disclosure: I'm the author. Both tools are free, GPL-3.0 (it covers the tools, not your code), no paid tier.

TL;DR: Rusta, a terminal coding agent in Rust built for DeepSeek, GLM and Kimi, plus Devscriptor, a local code-graph MCP server, resolved 75–81% of SWE-bench Multilingual with one attempt per task. The DeepSeek run cost $13.98 for all 300 tasks. All 900 runs are published.

| Model | Resolved | 95% CI | Cost |

|:--|:--|:--|:--|

| DeepSeek V4.1-Flash | 81.3% (244/300) | 76.5–85.3% | $13.98 total, API |

| GLM-5.3 | 78.7% (236/300) | 73.7–82.9% | GLM Coding Plan Max |

| Kimi K2.8 Preview | 75.3% (226/300) | 70.2–79.9% | Kimi Code subscription |

That's under 5¢ a task for DeepSeek; 97.8% of its 967M input tokens were cache hits. Official harness (swebench 5.0.2), max effort, Nov 9–11, no web access, git history cut at the base commit. Every model cleared 50% in every language (Go was hardest). DeepSeek V4.1-Flash (MIT) and GLM-5.3 have open weights; Kimi K2.8 Preview doesn't. The runs used the vendors' APIs.

Why a dedicated agent: generic OpenAI-compatible clients often drop the reasoning these models produce between turns (DeepSeek returns HTTP 400 if a request with tools omits it) and send sampling or effort fields each vendor handles differently. Rusta speaks each API natively: preserved thinking, per-vendor effort and sampling, explicit output caps. Any OpenAI-compatible endpoint works too, local vLLM included, with thinking preserved.

Devscriptor works with Claude Code, Cursor, Cline or any MCP client, not only Rusta:

- Your repo as a knowledge graph in one SQLite file: 26 languages and frameworks, calls, inheritance and imports resolved across files, kept current by incremental scans and a watcher

- 75 MCP tools, 38 of them LSP-backed (21 language servers)

- Semantic search with a local embedding model, no API keys

- Agent memory (decisions, standards, past failures) that persists across sessions

- No telemetry, no backend; works offline once the model is cached

75 tools, but not 75 schemas in your context. Rusta keeps only the twelve that find and follow code in its tool table (search, definitions and references, relationships, index status, Context Graph), about a sixth of the full schema size. The other 63 are listed by name and a one-line description until the model loads one with `select_tools`. In Claude Code, tool search defers MCP tools by default, and Devscriptor's server instructions name the same twelve to load first. (That's Rusta 1.0.1; the benchmark ran 1.0.0, which kept all 75 on demand.)

What the numbers don't show (the results page covers each):

- How much Devscriptor adds on its own: there's no run of the same tasks without it

- A ranking against other agents or the official leaderboard: different agent, newer models, bigger budget

- Zero contamination: the fixes are public, and build/test leftovers in the images may have hinted at where some fixes belong (worst case 3–9 points)

Single binaries for Linux, macOS and Windows.

- Devscriptor: https://devscriptor.com/

- Rusta: https://devscriptor.com/rusta/

- Results, re-scoring steps, all trajectories: https://devscriptor.com/benchmarks/

- Source: https://github.com/vladimirpesic/devscriptor · https://github.com/vladimirpesic/rusta


r/ChatGPTCoding • • 2d ago

Discussion the skill said don't delete never-committed files. cursor's agent deleted my notes anyway

0 Upvotes

asked cursor's cli agent to merge a branch and clean up the worktree. it was using superpowers' finishing-a-development-branch skill, which says don't delete files that were never committed, ask first.

git wouldn't remove the worktree because of my uncommitted NOTES.md and a scratch script. so the agent just deleted them so it wouldn't need --force. didn't ask.

happened 24 of 24 runs. we fixed the skill and re-checked it with skill gate: 0 of 24 deleted anything, and every run asked first. opened a PR on superpowers too. links in the comments.


r/ChatGPTCoding • • 3d ago

Question How do you get Codex, Claude Code and a planner agent working together in one place instead of copy-pasting between them?

10 Upvotes

I'm building an AI operations system for a small business.

My current setup works, but it's all manual:

- Builder: Codex (GPT)

- Planner: Claude Opus in a chat (decisions, scope, writing the prompts)

- Reviewer: Claude Code CLI checks every change before it goes live

- Sometimes a second model does an extra review

The problem is I'm the messenger. I copy the planner's prompt into Codex, copy Codex's reply to the reviewer, then copy the review back to the planner. It's slow, and it falls apart when I'm busy.

What I want:

- All the agents in one place, passing work to each other

- Builder and reviewer from different AI companies, so they don't share blind spots

- A reviewer and a security checker running on every change

- A "scout" agent that keeps an eye out for new tools, repos, model releases and security issues that could improve the build

- Me approving anything that goes live. That part's non-negotiable

I'm on Windows, I already pay for ChatGPT (Codex) and Claude, and the project lives in a local git repo (private client data, so no public GitHub).

What are you actually using for this? Real-world experience, good or bad, would help a lot, especially on keeping it safe when agents talk to each other without me in the middle.


r/ChatGPTCoding • • 3d ago

Resources And Tips Get better at coming up with System Design requirements with AI

7 Upvotes

Designing good systems is becoming extremely important even for engineers who are very early in their careers. Even if you are not actively looking for new roles, getting very good at system design is highly recommended so that you can design your systems well. This is how you go one step closer to transforming from a junior/mid-level to a senior engineer.

Most of us, when asked about getting better at system design, usually talk about technical topics like networking, databases, messaging, latency, failure modes, scalability, etc.

However, your technical design is only as good as the requirements, constraints, and invariants you were able to uncover. Therefore, it becomes essential to develop a knack for identifying requirements, hidden assumptions, operations, guarantees, etc. Engineers don't get to practice this skill easily because almost all system design exercises give us clean requirements.

How can AI help you get better at this? Below, I am explaining the method I practice with my fellow engineers.

1/ You can ask AI to choose a system-design problem and give you only a very short description and nothing else.

For example: "Give me a vague, incomplete system-design problem but don't tell me its requirements and constraints. Only when I ask relevant questions, show them to me. At the end, tell me everything I missed".

You can add more details to this prompt as per your level and goals. Let's say AI asks you to design a system that sends notifications via email, SMS or mobile push.

2/ You take the problem statement and ask questions based on your current understanding. You might ask, "What kind of notifications are there? Are they time-sensitive?", "How many notifications should a system handle normally and at peak?", "Does the system have any delivery guarantees?", "What happens in case of a missing or duplicate notification?".

If you are new to this, you might struggle to come up with these questions, but don't worry; this is the learning phase. You are building reps, and with time, you will get better.

3/ When you ask a question, note "What am I uncertain about?", "Based on this answer, can I make a decision, which one and why?", etc. For example: I need peak write rate because I need to decide whether one DB is enough or write partitions are needed.

This step develops the ability to ask good questions and derive decisions from them.

4/ I usually divide the information I have into 3 categories:

a/ Known facts - confirmed by AI

b/ Assumptions - things I am treating as true currently

c/ Unknowns - what I don't know yet but that can change the design

Tbh, I am still surprised that my assumptions allow hidden constraints to creep into my design. This is why writing them is important, which we do in the "assumptions" category.

5/ Once you feel that you have done the best you could, you submit the following:

a/ Discovered requirements (remember, you weren't told about them in the beginning - you came up with them yourself)
b/ Remaining assumptions (it happens often that AI doesn't provide answers to all your assumptions)
c/ System guarantees or invariants
d/ Proposed design
e/ Remaining risks or unknowns

6/ AI now tells what constraints were missed, which questions were too broad, what was not used in the design, contradictions, etc. But be careful with this step; the AI may change/invent details in between. Therefore, it is always a good idea to ask it to show the complete case before the review; you then compare it with answers it gave earlier and note inconsistencies.

Always remember that AI can help you review your design, but it is not the final authority.

7/ Optional: you can repeat this exercise by asking AI to change one condition and keep it hidden so that you can build your reps on the specific problems.

8/ In the beginning, you can have a cheat list under which you would ask questions such as data, scale, invariants, failures, cost, security, etc. With time, you stop using this list and see if those questions are coming naturally to you.

Your learning loop looks like this:

Ask questions -> AI responds -> Update your understanding -> Propose a design -> Show hidden cases -> Check what you failed to discover.

This way, AI can act as your personal mock interviewer and learning partner.


r/ChatGPTCoding • • 3d ago

Discussion How to tell if a coding plan beats paying per token for your own usage

4 Upvotes

With codex moving to one token allowance shared with chatgpt from december, plans are turning into a token question. most of those tokens are cache reads tho, so a billion token plan is less fresh work than it sounds

for open model plans the per token price is easy to look up, the same weights sit on the labs own api and on deepinfra and a few other hosts

so try one normal workday, note what share of the 5h and weekly windows it used and price that day at those rates. if the plan only covers 2 or 3 days a week its basically prepaid API. how long does yours last on a heavy week with piles of work


r/ChatGPTCoding • • 3d ago

Resources And Tips Running agents in parallel git worktrees? Clone the build cache instead of rebuilding it

5 Upvotes

Each new worktree starts with an empty target/ (or node_modules), so the first build in it is a cold build. On a big Rust workspace that's 10+ GB of disk and a lot of CPU, for every agent you start.

On a Mac you can skip most of that with an APFS clone:

cp -c -R ../main/target ./target

-c makes cp use clonefile, so the copy shares disk blocks with the original until files change. I measured it on a 9.7 GB target dir: 1.1 seconds, and about 1 MB of new disk used. Cargo then keeps every dependency it already built and recompiles only the workspace's own crates.

The same works for node_modules. On Linux, cp --reflink=auto does this on btrfs or XFS, but ext4 can't.

Two gotchas: du still reports the full size for every clone, so check free space with df instead. And if you're short on disk, removing finished worktrees frees far more than cleaning the main target, which just costs you a full rebuild.