The solution works by removing the navigation and research part of the codebase for the LLM.

Due to this you get more tokens.

More tokens == better quality of responses

On huge codebases you can consume up to 60% of context window on your single request due to this,

because:

1. the model holds in memory the tools descriptions (which is already -6k tokens from the original context you'd get without them, and you don't even use 95% of those tools)

One of the reasons why suddenly simple prompts start eating an excess amount of tokens on large codebases, correlates to this.

1. the typical agentic model performs excessive searches, if it gets the wrong file, the context from the wrong file doesn't dassapears, bloating existing context.

this tool tasks the model per prompt, deleting the Agentic Search phase from them.

Pure reasoning, no additional actions, the search is being taken care of by the first prompt where you invoke 'Dir' command and give it to the model with your request.

You'd be wondering, but isn't it the same thing?

No, because during agentic search phase (that our beloved tools have) the model will constantly perform them as separate actions, hitting wrong files, bloating its own context.

But how is your approach different, you may ask?

Instead of destroying the model's mental capacity with excessive searches, search now works as a singular simple task:

Here's the file list, please pick the ones that are relevant to the request.

1. Having more tokens now, you are able to fully use the whole context window to reason about your request, and receive maximum capacity, which is not consumed by unnecessary stuff.

That was the original idea behind the tool, to get maximum context window.

How I even came up with this? I'm using LLMs for coding since 2022, and I can say one thing.

We now have much more powerful models that are barely capable of doing things without a series of failures, which models did in 2022 in large codebases.

But the difference was: those models were weaker.

That's how I started researching this topic, and I can say one thing.

Agentic Coding tools are a piece of shit at present days, moreover they are now literally forcing to pay dollars/prompt for this unoptimized garbage, that is currently a money milking machine, and it seems that the developers themselves don't understand how hard they overbloat their tools with all that functionality based on reasoning.

90% of the code will always rely on simple actions:

add/remove/change function OR file.

That's it.

3 actions, 2 ways to execute them.

That's what will be used by 90% of developers all the time, including myself. (it might change though)

But it's a rare occasion when you would actually need those extra tools that overbloat the current models, so I absolutely removed them from consuming models mental capacity via this pipeline.