I'm a slow typist, so when programming I really need the autocomplete feature, to avoid typing a lot and making typos. When applying AI to my work, a major limitation is that the prompt input box of agent software lacks an autocomplete feature. That means when I want the assistant to fix this function or that function, I have to type out the full function or variable names, or copy them from elsewhere, instead of just typing the first 2-3 characters and pressing Tab as I do when working purely in a code editor. That's why I've always looked for a way to bring the code editor into my AI agent workflow, leveraging the editor's advantages, and I've found a workable approach.

Before discussing this method, I should reveal that the autocomplete need has already been partially solved by some command-line agents. For example, in Crush, Crush lets you call an external text editor to enter the prompt (with the shortcut Ctrl + o):

Then I just need to configure the code editor as Helix to leverage its autocomplete of previously typed words, saving typing effort. In this case, Helix is detached from the project's source code context, so it can only suggest previously typed words, not functions or variables in the source code.

Besides Crush, Toad and Kimi CLI (the Python version) also let you call an external editor to write the prompt.

But the approach I really want to present in this article is to write instructions directly in the source code!

When I ask the AI assistant to build a somewhat large feature that involves modifying code in many places and files, I find that instructing the assistant to jump to a specific file, line, or function is also laborious. So instead of describing it in the prompt box, I write a TODO comment right at the spot in the source code that needs changing. For example:

In this TODO comment block, instead of a usual brief note, I write a bit more detail so the AI assistant understands what's wanted and how to do it. When writing in a comment, you only get the previously-typed-word suggestion; there's no autocomplete for operators (like the dot "." for accessing a field). But it's still better than not using an editor, because you can use the editor's jump and quick-select features to copy nearby function and variable names. If the feature requires changes in many places in the source code, I also add TODO comment blocks at those spots.

The basis of this method is: after writing the TODO comments, if you run git diff, you get an overview of all the places that need source code changes—which file, which line, and what the corresponding instruction is.

Based on that, the prompt you enter into the agent only needs to be: "Do git diff to see the TODO implement."

That's it. After looking at the output of git diff, the AI assistant can read the requirements, gather enough context, start thinking, and produce a list of tasks to do along with the code:

The work is done.

In the screenshot, the AI assistant took 17 minutes because several times it paused to ask permission to write a file or run a command, but I was busy with other things and didn't notice to grant permission.

That's the way to instruct for code changes. But what about review instructions, for a lazy typist? The approach is to pre-write a .agents/REVIEW.md file in the project folder, with content like this:

Check for:

- Potential wrong logic.
- Missed code path.
- Code convention violation (rules in .github/instructions/ folder).

Then in the prompt box, I just need to give the command: "Review uncommitted changes per @.agents/REVIEW.md" (the "@" leverages the agent's file-path autocomplete).

Just this short prompt, yet the AI assistant does a real job, catching this and that error.

Regarding the file mentioned in this article, I've established a convention that files for the AI assistant to read (like skills) live in the project's ".agents" subfolder. I don't name them after the agent (like .crush, .kimi) because developers have different agent preferences, so I chose .agents as a neutral name. The file name REVIEW.md is because I noticed Goose automatically looks for a file with this name when running the goose review command.

Before wrapping up, a small note: Helix v25.7 doesn't yet have the previously-typed-word autocomplete feature, and the new version hasn't been released. To use this feature, I compile Helix from the source code in Git.

You might wonder: I often say I'm a slow typist, yet in this article I use the Terminal and command-line mode throughout. The agent is a command-line agent, and the code editor is Helix too. That's because the command-line environment also has powerful autocomplete, so I don't need to type much at all. Even to select a block of source code to copy and paste, I use Helix's "m a ..." shortcut rather than using the mouse to sweep, select, hold, and drag—which is tiring for the shoulder.

If you're about to suggest I use this or that [skill] pack from the internet, I've tried them and wasn't satisfied—those skill packs are too verbose. I feel they're written in a roundabout way, with all sorts of sections just to "intimidate" the reader. Such wordy skills waste a lot of tokens and make the AI assistant redo duplicate work, wasting time and CPU (calling tools repeatedly), which then burns even more tokens. I prefer concise wording, so... I pass and look for other ways.