WARNING TO ALL WHEN USING GIT AI CODEX !!

[longdaukhac]

🏷️ Discussion Type

Question

💬 Feature/Topic Area

Code quality

Discussion Details

BE CAREFUL WHEN USING GIT'S AI CODEX.

It can seriously damage your codebase as the context size grows larger. This appears to be a major flaw that the development team does not currently have the technical capability to properly address.

And when users encounter these problems, the support team stays silent instead of providing real assistance.

This is a serious lack of professional ethics and responsibility toward developers.

[miladrezanezhad]

Thanks for the warning. Can you share more details about what actually happened?

I've seen some issues with AI coding assistants before, but "seriously damage your codebase" is pretty broad. What exactly did Git AI Codex do? Did it delete code, introduce bugs, overwrite files it shouldn't have, or something else?

Also, what do you mean by "context size grows larger"? Are you talking about a large codebase, a long chat history, or something specific to how the tool works?

I'm not defending the team here, but without concrete examples it's hard to know if this is a real flaw in the tool, a misuse case, or something else entirely.

If you have logs, screenshots, or a step-by-step of what happened, that would help everyone else avoid the same issue.

And yeah, support going silent is frustrating. Been there. But calling it a "lack of professional ethics" is a strong claim. Do you have any response from them at all, or just no reply yet?

[devnavodhimsara]

Hi @longdaukhac,

I completely understand your frustration. It is incredibly stressful when an automated tool behaves unpredictably on a large codebase, and waiting for support while things are broken only adds to that stress.

To echo @miladrezanezhad's excellent questions above, having concrete examples or logs would really help the community understand the exact bug you are hitting.

Regarding the issue of the AI making mistakes as the "context size grows larger": this is actually a well-known limitation across almost all current Large Language Models (LLMs), not just this specific tool. It's often referred to as "context degradation" or "hallucination." When the context window gets completely filled, the AI struggles to maintain the correct state of the entire codebase and might overwrite things incorrectly, forget earlier instructions, or introduce logical errors. It is a fundamental limitation of current AI architectures.

A quick safety reminder for everyone using AI coding assistants:
The absolute best defense against AI hallucinations is relying on your version control. AI tools are "co-pilots," not autonomous developers yet.

Never skip the review: Always check the diffs carefully before accepting large AI-generated changes.

Commit frequently: Commit your working, stable state before asking the AI to do a massive refactor or generate a lot of code.

Rollback: Because you are using Git, an AI cannot permanently "damage" your codebase. If it messes up, a simple git reset --hard or discarding the changes in your IDE will revert the damage instantly.

If you are able to share the specific nature of the corruption (e.g., did it silently delete functions, mess up imports, or change core logic?), it would be highly valuable for the rest of us so we know what specific behaviors to watch out for!

[TheZitroX]

I was about to say. Who lets random typed things in a not backedup environment?
You even are on GIT-Hub, a place to backup your history...

[haruiquynhon-arch]

Let me explain clearly so you can understand how lazy and careless it is.

When a project has many different features, and you ask it to work on one specific feature, it gets lazy about properly limiting the scope of the changes. It searches too broadly, accidentally touches files that belong to other features, and then modifies them very recklessly.

Why is this such a disaster? Let me explain it like this:

When you are focused on developing one feature, you usually cannot notice that it has already introduced bugs into other features. That is the real problem. Over time, your project slowly accumulates a lot of garbage and hidden issues that you have to clean up little by little.

My advice is that it is only suitable for projects with a single simple feature. If your project is complex, then it is better not to touch it at all.

[haruiquynhon-arch]

This is visual evidence showing that it made incorrect changes, and I caught it and forced it to roll everything back for me.

You can translate the content that I highlighted in red with arrows — it will make the issue much clearer.

[longdaukhac]

I am a very fair person. I never falsely accuse or intentionally harm anyone. At the same time, I am also a very straightforward person.

I am sharing this because I genuinely want what is best for the developer community.

To put it simply in one final sentence: it is something that causes more harm than good.

[longdaukhac]

I’m going to clearly point out the fatal weakness of Git’s AI CODEX system.

I have used many different providers, and I have come to one common conclusion: any AI CODEX system that relies on one AI receiving information and then passing that information to a main coordinating AI ends up causing more destruction than actually completing the work.

The reason is simple: information passed to the coordinating AI can easily become noisy, distorted, misunderstood, or inaccurate when it goes through an intermediate AI layer.

What is even worse is that Git’s development team does not seem to recognize this problem in order to fix it. That is the most concerning part for such a large development team.

I honestly think that system should be hidden or removed to avoid causing trouble for users. The only reason new users still use it is because they do not yet understand how problematic it is.

[xoxoxo-af]

install​

[longdaukhac]

CHATGPT CODEX & AMAZON Q
the best choice for safe first

[shahid-afrid07]

AI coding tools can definitely make mistakes, especially in large or complex codebases with long context windows. That’s why it’s important to review generated changes carefully before merging them into production.

In my experience, these tools work best as assistants rather than fully autonomous developers. Using smaller prompts, limiting context size, testing frequently, and reviewing diffs manually can help avoid major issues.

I also understand the frustration when support responses feel slow or unclear. Hopefully the tooling and communication improve as these systems continue to evolve.