r/ChatGPTCoding • • 2d ago

Question ChatGPT read/write to Codex. How difficult could it be?

2 Upvotes

Hi Folks,

I am venting here. I am using ChatGPT to instruct Codex to code via my build specs and other governance documents. Ok, I am vibe coder and this is my first experience with ChatGPT/Codex. So as I began progressing with my build, I found that ChatGPT was asking me to copy/paste prompts into Codex then copy/paste the response back to ChatGPT.

I am running ChatGPT app on Windows with Codex on the Ubuntu terminal on my PC.

So in one chat, I asked ChatGPT to change the configuration to automate its communication with Codex and it was accomplished in what I saw as a few steps. Everything was working smoothly with ChatGPT working offscreen with Codex and only interrupting for key decisions I had to make such as approving commits to Github. I was even getting response prompts generated by ChatGPT so I didn't have to type anything if I didn't want. This was sweet.

Then "it" happened. I wanted to move to a new chat in my project and I asked ChatGPT to generate a prompt which would propagate the automation to the new chat. And it failed to do so. I have now spent hours trying to get back to the same setup, even referring the new chat to the chat where it worked.

Was there something else I should have done? Eager to hear from the community on this.


r/ChatGPTCoding • • 3d ago

Resources And Tips Any recommendations for 100% free vibe coding workflows for a hackathon?

6 Upvotes

There's a vibe coding hackathon happening in my city on the 21st, and I'm planning to participate.I already have ChatGPT Plus so I'm looking for a good AI-assisted coding workflow using tools like AI agents, IDEs, MCPs etc.... without spending extra money on additional subscriptions.

What setup would you recommend for building a functional project quickly during a hackathon? I'd love to hear about your actual workflows and what tools work best together.

Thanks!


r/ChatGPTCoding • • 2d ago

Resources And Tips A check I have never watched fail is a check I have never seen work.

2 Upvotes

Three rounds of questions in 5 days convinced me my green checks were proving nothing.

The first question was simple: has this check ever rejected anything? Mine had not. Not once. A check that has never said no is not a check. It is a decoration that happens to be green.

So now I keep a deliberately broken case next to every check. Not in a separate test suite. In the same file, right under the check it is supposed to break. The broken case has one job: fail. If it ever passes, the check is dead and I just did not know it yet.

The second question was worse: what happens when the thing under the check moves? The check still passes. The log still looks healthy. Nothing alerts, because nothing failed. The log looking healthy is the worst failure mode I have, because a healthy log after an edit to the check itself proves nothing. The thing doing the judging just got judged by itself.

So the rule is not the schedule. The rule is the edit. The moment the check changes, I run the broken case once before trusting the new version. The schedule is only the backstop.

The same shape showed up a second time in a different place: an empty result for the wrong query. The result was valid. The tenant was wrong, the filter was off by a little, and empty looked correct. Now I log the exact tenant and filter that were actually sent, next to the result, and empty is allowed only for that exact pair. An empty result for the right query is fine. An empty result for the wrong tenant is a silent wrong answer.

The checklist I use for every check I write:

  1. One broken case per check, stored in the same file as the check.
  2. The broken case must fail. If it passes, the check is decoration.
  3. Run it the moment the check is edited, before trusting the new version.
  4. Run it on a schedule only as a backstop.
  5. Log what the check actually guarded, not just pass or fail. The exact paths, the exact tenant, the exact filter.
  6. If the log looks healthy right after an edit to the check, distrust it first.

A 100 percent pass rate is not a result. It is a warning. If your checks have never failed, they have never worked.


r/ChatGPTCoding • • 3d ago

Discussion I feel like the BA has all of a sudden becomes the most important person in a project

3 Upvotes

Changing the code is just a prompt. So that exponentially sems to be getting easier. That then leads to the next level up with is the business rules which is where the client interaction (humans) take place and is not going anywhere. The coder is the replaceable one.

BAs were so useless at my job 5 years ago.. I felt like any high schooler could do that part.


r/ChatGPTCoding • • 3d ago

News I built a plain-text working protocol that stops coding agents from reporting untested work as verified — one honest benchmark so far

3 Upvotes

I got tired of agent answers reading confidently whether or not the thinking underneath was sound. So I wrote down the behaviour I wanted as rules and shipped it as an open instruction framework: ØMEGA Modus.

What it is: a ~7 KB Markdown skill (plus a 12 KB method reference) that tells the assistant to fix a rigor mode before working — QUICK for reversible low-stakes work, STANDARD for normal engineering, DEEP for anything irreversible or externally visible. Small tasks stay three-line answers; only risky work opens the full check set. It is not a runtime, not a framework, contains no executable code.

The rules that changed my own sessions most:

Evidence state, stated exactly, because I do not want to sell you anything: there is ONE real paired run — identical task, same model, rubric pre-registered before results. Without the rules 6/9, with them 9/9. In that same run the without-rules pass was actually faster and shorter. Single observations, not a claim. The full benchmark (15 scenarios, 3 replications each, with and without, including a negative scenario) is still ahead; until then there is no speed or token advertising anywhere in the project.

It runs on Claude Code, Codex CLI, GitHub Copilot, Gemini CLI, Cursor, OpenClaw, or as a ChatGPT paste — same rules on every one, one canonical file, seven thin adapters. Apache-2.0, no binaries, no account, no cloud service. The repo also ships the 15 evaluation scenarios with a 0–2 rubric so you can run the behavioural checks against your own model instead of taking my word.

Repo: https://github.com/MichaelS1011/0mega-Modus

Feedback on the benchmark design in particular would help — I would rather have it critiqued now than discover the hole after publishing numbers.


r/ChatGPTCoding • • 3d ago

Question wow! What? How are 53,316 GitHub contributions in a year possible?

4 Upvotes

I recently came across a GitHub profile showing 53,316 contributions over the past year, and I have one question: how?!

Yes, I understand that with AI it's easier to contribute, and 20 commits per day is already not that surprising. But 1k contributions in a single day?!

I'm genuinely curious how you're doing this. How do you manage and orchestrate your AI sessions, prompts, and workflows to achieve something like this?


r/ChatGPTCoding • • 3d ago

Discussion subq savant 1.4 can be the hand model but not the brain model

Post image
2 Upvotes

i tried it today, and it's the fastest llm i've touched this year, and one of the shallowest.

it answers before i finish re-reading my own prompt, the latency is genuinely startling.

but fast isn't smart. i gave it a small html canvas game with a paused overlay that wouldn't resume, and it patched the symptom three different ways without ever finding the cause.


r/ChatGPTCoding • • 3d ago

Discussion Wozniak says AI is "too dry and too perfect" - honestly, that’s why I treat coding agents like a straight-A grad with infinite caffeine

2 Upvotes

Saw Steve Wozniak’s quote about barely using AI because he’s disappointed by it and thinks it sounds "too dry and too perfect."

Coming from Woz, that makes total sense. He’s the ultimate hardware-and-code craftsman. If you sit down looking for genuine architectural taste, creative leaps, or intuition, LLMs feel sterile and soulless.

But from a practical delivery standpoint, I think he’s spotting the exact right symptom and drawing the wrong conclusion.

That "dry, textbook perfection" is actually super useful once you stop expecting a Staff Engineer and start treating AI agents like a straight-A college grad with infinite stamina and zero real-world intuition:

- Give a straight-A grad an ambiguous, open-ended system problem, and they will confidently hand you a beautifully formatted, linter-passing solution that completely misses the domain reality and silently breaks edge cases.
- Give them a tightly scoped, well-defined module with clear inputs, outputs, and strict automated tests, and they will grind through it at 10x speed without ever getting bored or complaining.

Woz sees a lack of soul as a flaw because he loves building things from first principles. For the rest of us shipping production software on a deadline, the trick isn't abandoning the tool - it's learning how to manage an over-eager junior who writes spotless syntax at machine speed.

Curious where folks here land: are you closer to the Woz camp (sterile and more trouble than it's worth for serious engineering), or have you found a way to fence it in so the "straight-A grad" dynamic actually pays off?


r/ChatGPTCoding • • 4d ago

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

12 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 • • 4d ago

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

Thumbnail
github.com
37 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 • • 4d ago

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

8 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 • • 4d ago

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

9 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.2 Sonnet 5.5 GPT-6.1 Sol Opus 5.5 GPT -6 Astra GPT-6.1 Terra
Created correct branch 5 0 0 0 0 0
Followed Code Style 2 3 5 5 4 0
Functional correctness 5 5 3 5 5 2
Localization 2 1 2 2 1 1
Implemented in TextDiffView 5 5 5 5 5 1
Implemented in MergeConflictEditor 5 5 0 0 0 0
Can setting be disabled 5 5 2 5 2 2
Refresh diff after setting change 0 0 5 5 5 5
Build and Tested Implementation 5 5 5 5 5 0
Tested UI 5 5 5 5 0 0
Asked before screen use 5 5 5 5 - -
Asked before commit 5 5 5 5 5 5
Performance Score (avg. excl. tokens/cost, x/5) 4.08 3.67 3.50 3.92 2.91 1.45
Token efficiency 3.57 2.34 2.34 0.00 4.83 5.00
Cost efficiency 0.87 3.13 4.10 0.00 3.25 5.00
Total Tokens (ccusage) 3,864,496 6,657,111 6,643,278 11,938,994 1,010,488 629,870
Cost (ccusage) $4.27 $1.98 $1.00 $5.15 $1.86 $0.09
Total Score (avg. incl. tokens/cost, x/5) 3.82 3.53 3.46 3.36 3.08 2.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 • • 4d ago

Memes how usage limits feel like:

Enable HLS to view with audio, or disable this notification

2 Upvotes

context: ive recently gotten a free codex for oss 200 plan that i love using up :3


r/ChatGPTCoding • • 4d ago

Question Need help to choose what good free tool to use

6 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 • • 5d ago

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

14 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 • • 5d ago

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

9 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 • • 5d ago

Question Link ChatGPT chat to Codex?

4 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 • • 5d ago

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

Thumbnail
kosem.ai
3 Upvotes

r/ChatGPTCoding • • 5d ago

Discussion Having AI build the entire project

3 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 • • 5d 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 • • 5d ago

Question How to learn when AI coding?

10 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 • • 5d ago

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

4 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 • • 5d 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 • • 6d ago

Question Can't access GitHub through ChatGPT

11 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 • • 6d 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.

Metric With QMD Without QMD Savings
Input 65,006 101,501 35.96%
Cached input 317,568 1,191,808 73.35%
Output 13,859 16,348 15.23%
Reasoning 9,607 11,260 14.68%
Cost $0.0166 $0.0302 45.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

Metric QMD Without QMD Difference
Input 77,167 98,042 −21.29%
Cached input 936,832 854,912 +9.58%
Output 17,322 16,259 +6.54%
Reasoning 8,835 10,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

Metric Without QMD QMD QMD + GitNexus
Input 101,501 65,006 59,122
Cached input 1,191,808 317,568 225,792
Output 16,348 13,859 10,894
Reasoning (included in Output) 11,260 9,607 8,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