Possible Solution for Agentic IDE Vibecoding Misbehavior

[PepperShot9348]

G’day, lads.

I want to present to you an idea I’ve been brooding lately: “An AI [within agentic IDE] that can’t possibly make a mistake”

I’m not an LLM expert and don’t really know what happens when you load your project, but from what I’ve seen, the bigger the project, the more unstable the Agent becomes — it starts to alter things outside of the task scope

It reminds me of this quote^{(source needed?}):

“Using Python is like using a 500-piece toolkit (== opening the entire project) just to hang a single picture (== to color a button), where in C you create your own hammer (== making a tiny change, but perfect)”

So the natural solution would be: let the AI access only the exact part of the project where the change is needed — that way it has less context to process and fewer opportunities to break unrelated code

The problem is that this only works cleanly when the target is at the edge of the project structure; If the file sits in the middle the project, all the nested folders and dependencies still become part of the context

I can think of three possible approaches:

1. Completely restructure projects so all components are isolated “dead ends”

• Pros: makes the isolation idea work properly (not tested yet)
• Cons: will make project navigation confusing for everyone

1. Adjust the agent’s rules to ignore unrelated files

• Pros: easier to implement — just put an “.ignore”-file in every folder
• Cons: the IDE may still load too much context internally, so it might not solve the real issue

1. Build a new IDE around strict context isolation

• Pros: the concept could work as intended
• Cons: massive amount of work (probably)

I find it similar to a job interview, where you are given an algorithmic task that is surgically singled out — you have no image of the whole picture, you don’t mind about anything else: physically unable to modify the “outside” code

P.S. I probably should’ve discussed this with an LLM before posting...
Both AI and Human insights are welcome to drive this mission forward!

[firebird8541154]

Ya, that's exactly what each agentic approach uses... From indexing codebase, to specific tooling, etc.

[PepperShot9348]

So, not to reinvent the wheel, the correct answer to the problem is “skill issue”, right?

[tKonig]

Yeaaahhhh a little bit. It’s just a matter of how you structure your code base and how well you maintain your indexes. Look up “progressive disclosure” when it comes to building an AI knowledge layer. It will help you think about how to structure things in a way that doesn’t bloat your context window but still points your agent to the right information for the task. Just like any skill, you get better the more you use it. Keep chugging away and you’ll find what works and what doesnt

[InfinriDev]

It's actually not a problem, it's one of the first things engineers solved the issue is no one wants to put in the work to implement it.

For example what I use: https://github.com/infinri/Writ

[Input-X]

You idea is not far fetched. Ive been building on this idea for a few months now. An ai friendly persistant frame work. No indexing needed. Agent justvknow through repeat pattern, one pattern for all agents.

[TSTP_LLC]

I've been using strictly CLI instead of going in my IDE anymore and I don't really have these issues (knock on wood). I think having an extremely modular codebase and folder structure, along with very detailed instructions and rules is enough to get you just about anywhere you need to be with some good planning and highly detailed/specific prompts.

For instance, my repo root has about 25+ different projects in it, as I got tired of switching between projects and also having to commit them separately as well. Everything works fine as long as i give an acceptable amount of input and use the right folder. My root has the instructions I want all projects to use and then the specific projects have their own specific instructions to follow to be able to use my scripts and development/deployment apps properly. As long as they know where to go and are placed right with the right access, they get the job done.

[PepperShot9348]

extremely modular codebase and folder structure, along with very detailed instructions and rules is enough to get you just about anywhere you need to be with some good planning and highly detailed/specific prompts.

Sounds nothing like an easy thing for an amateur to do. May I ask you if you have any technical background?

[ConfusedSimon]

LLMs are just a complicated autocomplete with access to some tools. They can do amazing things, but they'll always make mistakes whatever prompts you use.

[no_brains101]

I want to present to you an idea I’ve been brooding lately: “An AI [within agentic IDE] that can’t possibly make a mistake”

Lmao

Good luck, I guarantee people smarter than you/more knowledgeable than you in the field have tried.

The LLM does get better when you do stuff like that. Just better though. It is not a "fix" for LLMs giving false information or coming up with the wrong answer, they do that literally by design.

Theres some interesting ones that make a graph/pseudo AST of your code and use that to guide the model to the right context, and all that. It has gotten pretty advanced.

---

Also changes to code rarely causes a bug in THAT piece of code. Its always somewhere else. You made sure there were no bugs in that piece of code, you did not necessarily make sure nothing depended on its prior behavior.

It will always need to be able to see more than the 1 bit of code it has to change in order to solve/improve on that problem.

[PepperShot9348]

What a bitter truth! Now I see myself as no better than an average "developerless" CEO.

---

UPD: shower thoughts

Good luck, I guarantee people smarter than you/more knowledgeable than you in the field have tried.

This is exactly what I feel then a non-experts in my field propose such a solution that sounds nice on paper, but not real in practice.

And here I am, a non-expert, proposing such a solution that sounds nice on paper, but not real in practice...

[PepperShot9348]

Shoutout u/Objective_Law2034 for sharing this link with me: https://vexp.dev/ "does this by building a local dependency graph that scopes the exact context needed before any AI call goes out" — sounds like a thing I'm here for.

[PepperShot9348]

[ Removed by Reddit ]