I have been giving some thought to ways that an AI IDE like Cursor could be used to streamline and de-noise development process, using currently available technology. I would like to see some features that allow me to put a little more trust in the AI to be doing its part correctly, and let me focus on the task at hand. This could potentially be and interface where we don’t look at the actual code at all, but just pseudo-code or some other simplification or abstraction. That would be a big leap from where we are right now though, so some baby-steps in that direction would be nice. This idea has a few parts, all of them seem reasonably achievable within the VSCode fork and with current fast models.
Context Aware File Explorer
When I am working on a feature I am usually only concerned with a handful of files to complete this feature. When navigating between files, I don’t need to see the full directory all the time, and it would be nice to have it narrowed down to just those files that are relevant to my current task.
A section in the File Explorer could be added to allow a “Context Aware” view. This could show just the files that are related to the task that you are working on. It could be controlled by a prompt, files could be added automatically when you make changes in the current commit, or the context of the current Chat or Composer could be used to add to the view. You could potentially add files to this view manually by ‘pinning’ them, or remove files from this view manually.
In this example, I am working on adding tests to a function in app.py. I am only concerned with the test file and the source file at this time.
Relevant files can be determined in real time. A fast model can be monitoring the diff, or changes made on the branch and add files to the explorer view as they become relevant. Either that or ‘greyed-out’ file suggestions can appear in the Context File Explorer as the AI determines that the changes you’ve made will impact another file. The next file in the ‘flow’ could be suggested in the view automatically.
Potential benefits would be a small reduction in noise and distractions while completing a feature, and there are potential upsides for Chat context. The context window could be ‘included’ in a Chat so that only the files you have vetted as relevant are used as additional context.
Auto-Collapsing Code Blocks
A step along the road to abstracting the code with AI would be auto-collapsing code blocks that are not relevant to the current task. I want the code that is not relevant to what I am currently working on to be hidden by default, and only exposed if they become relevant or if I manually expand them. It would be possible without AI to have code-blocks default to collapsed, but this would be annoying and more of a hinderance than a help. I would like to see a fast model AI working to determine what is relevant and what is not in the files that I’m viewing, and updating the visibility in real time. The “current task” could be set manually with a prompt or determined by the context of the current Chat or Composer or Notepad or just determined by the actions of the user.
In this example, I have asked the Chat to create a new test for me. I don’t need to see the contents of the other tests, the function names are enough.
If I CMD+Click on a function name and jump to its use in another file, I’m only concerned with how that function is being used. If there are other functions in the file (lets say its a utils.py file), then I don’t need to see them at all, they are irrelevant to the task at hand. Jumping to the use of a function or variable in another file could collapse other functions without AI potentially, but I think we would need something a bit smarter to determine if there are secondary links to the use of that function, or associated code that wouldn’t be captured by just a text-match.
When making changes with Chat or Composer, collapsed portions of the code should expand automatically if changes are suggested within them.
(Note: This is needed already)
Unrelated or unchanged portions of the code can remain collapsed.
Relevant Code can be determined in real time. A fast model can be monitoring the diff, or changes made to a file and expand collapsed code if other parts of the code in the file become relevant as you work.
Hit me up with any feedback on these feature requests!