Make Your Own AI Coding Assistant In Less Than 5 minutes

Kill The Editor

AI-powered coding assistants are multiplying faster than you can say “debugging nightmare,” turning the programming landscape into a crowded racetrack. They do deliver much-needed help to code and even flashes of brilliance. But here’s the problem: they all follow the same outdated playbook.

They suggest snippets, flag errors, and generate useful functions, but there is a feeling that you’re spending too much time communicating to the AI in your editor while being occasionally told off by it for no good reason. The editor has become an overbearing teacher, hovering over your shoulder, dictating how you should write, correcting mistakes with an unshakable confidence (sometimes misplaced), and now, with AI integrations, doubling as an overeager but ultimately unoriginal mentor.

And therein, lies the outdated approach of interaction with AI: AI-powered editor is basically just a glorified editor and coding in it is like investing into a new steering wheel when you can have a self-driving car that will take you places you only dreamt about.

If you are someone like me, who wants to have their AI to shine in its full coding potential, I am afraid the editor needs to be bypassed entirely.

I know this sounds heretical. The code editor has been our sanctuary for decades—the holy grail of programming. But in my opinion, its days might be numbered.

I’ve been using AI to help me code for a year now. It was as simple as chatting with a model and copy-pasting some code. I tried AI assistants but didn’t start using them since I didn’t want to be micro-managed by the editor nor I enjoyed its hyperactive coding assistant. A growing itch of wanting to escape the confines of it and take full control finally resulted in an idea. I realized I wanted an autonomous system where I conducted and it executed its own perfectly reliable code. No syntax babysitting, no autocomplete training wheels—just raw, evolving intelligence.

Build It Yourself

Rather than embedding AI into an editor and bending to its constraints, what if AI was the development environment? Instead of highlighting code and asking for suggestions, imagine simply describing what you need—like explaining an idea to a fellow developer—and watching as your assistant generates and refines the code in real time. For now, you’d have to type out your instructions—but in the near future, you’ll be speaking out your needs and ideas, and the assistant will listen, understand, and build.

I was toying with this idea since the beginning of the year. As it happens, I’ve recently come across Andrej Karpathy’s tweet¹, from February, describing a loosely similar process of AI coding as vibe coding. Incidentally, my version has a key characteristic. It doesn't let AI have free rein, where it would inevitably go astray or become bloated without enough architecture. Instead, it allows a visionary programmer to direct it in small increments, fine-tuning and moving forward with carefully curated outputs.

I've been using this process for a month now, and it has completely transformed my productivity, helping me code possibly ten times faster.

I haven’t found anyone sharing their recipes online yet, so here is the paradigm with code, fresh out of the oven, for anyone who wants to try it BIY: a dead-simple way to create your own AI coding assistant, one that doesn’t need an editor, improves itself over time, customizes to your workflow, and most importantly, keeps you in control. No subscriptions. No restrictions. No corporate overlords deciding what’s “helpful.” Just you, your AI, and the limitless potential of code.

Let’s dive in.

Understanding The Seed Architecture

First things first, I am going to use Markdown as the pivot format because it is structured enough for a script to parse but is close to human language and textual enough that AI can easily read it. Plus, it makes input-output formatting a breeze.

The minimum we need is these 5 things:

1. Accept one or more file paths as input.

2. Package the code into one big Markdown text.

3. Allow questions about the code and/or about giving a new version of one or several of these files.

4. Have AI models (like Gemini, Claude, or GPT) generate responses.

5. Make possible recognizing the new file version (if present) and saving them instead of the original version.

Basically, the core concept is creating a conversation about your code rather than embedding AI directly into your editor.

This setup creates an ongoing dialogue with your AI assistant, making it more of a coding collaborator than a mere autocomplete on steroids.

Bootstrapping The Minimum Viable Version

To begin, I need a minimal viable version of our future assistant. Let’s create one.

Since our assistant doesn't exist yet, I'll need to bootstrap it. Once the basic framework is operational, we can leverage it to iteratively build upon itself, creating a virtuous cycle of improvement.

While you might enhance its complexity later, this foundation will serve as a platform that can expand through self-modification—essentially asking your assistant to improve itself.

I'll use JavaScript for this example due to its accessibility and ubiquity, but you might substitute with Python, Rust, Go, or whichever language aligns with your comfort zone. The core concepts and architecture remain consistent regardless of your chosen language—select whatever best complements your workflow and expertise.

Now, fire up your terminal and let’s get our hands dirty:

Step 1: Project Setup

Create a new directory for your project and initialize it:

mkdir my-code-assistant
cd my-code-assistant
npm init -y

Install the necessary dependencies: (I’m going to use Anthropic Claude because it’s the best one in March 2025).

npm install dotenv @anthropic-ai/sdk

Step 2: Bootstrap the main script using a LLM web chat interface

As the classic chicken-and-egg situation goes, at the moment, I don't have an assistant to make the assistant code, because I don't have anything. First, I am going to use an LLM to make a script, then I’ll simply copy-paste it as a file. This is the only time we’ll be copy-pasting anything. After, we’ll have a minimal viable assistant to which I can ask a question to modify itself.

Run the following prompt on Claude or Grok or any model of your chosing. I used Claude 3.7 because its high success rate suited best for creating a functional JavaScript script.

I need help creating a minimal code assistant in one monolithic Nodejs script that can analyze source files and answer questions about them.

The assistant should:

1. Read one or more files provided as command-line arguments
2. Create a preprompt with the file contents formatted in proper Markdown code blocks to preserve syntax, with each file path clearly labeled as a level 2 heading before its content
3. Allow the user to ask a question about the code via the terminal
4. Include a specific post-prompt instructions to the LLM that when suggesting file changes, it must:
  - Output COMPLETE file contents (not just the changed parts)
  - Format each file replacement in a consistent, parseable pattern (markdown code blocks with the filename as a level 2 heading)
5. Use the Anthropic Claude API (model claude-3-7-sonnet-latest) to generate responses based on the code and user question
6. Parse the LLM's answer to detect new file versions by looking for specific patterns in the Markdown format
7. When one or more new file versions are detected save the updated version without user confirmation (but copy the original with the suffix .orig)
8. Implement minimal error handling for file operations, API calls, and user input

Please provide a complete implementation using ES modules with:
  - A simple terminal-based interface with clear user prompts
  - Environment variable configuration ANTHROPIC_API_KEY for the API key
  - No external dependencies besides dotenv and the Anthropic SDK (@anthropic-ai/sdk)

Ensure the code follows modern JavaScript practices including async/await for asynchronous operations and proper command-line argument parsing.

Manually copy the resulting script into src/index.js

Step 3: Running Your Code Assistant

Create a.env file to store your API keys:

ANTHROPIC_API_KEY=<your_anthropic_api_key>

Step 3: Running Your Code Assistant

Now you should be able to run your assistant with:

nodejs src/index.js -- path/to/file1.js path/to/file2.js

If the command fails, it means the code generated by the prompt was not correct. It can certainly happen sometimes. I ran the prompt above with Claude 3.7 quite many times, and I ended up with a working script 8 times out of 10 (you can check the test runner in this repository).

The Power of Self-Modification

Now you have your very own coding assistant that is ready to constantly evolve.

nodejs src/index.js -- src/index.js

Indeed, the beauty of this approach is that once you have the basic framework, you can ask your assistant for self-improvement in your natural language.

For example:

• "Add support for handling Markdown files as input"

• "Implement a function to display diff before applying code changes"

This approach favors conversation and collaboration over integration, making the interaction more natural. Your AI assistant becomes its own evolution partner, demonstrating the power of conversation-based co-programming. It also gives you an eerie glimpse into the future of programming, where the line between human and AI collaborators is blurred. By starting with this minimal implementation and growing it through self-modification, you'll gain insights into both AI capabilities and your own codebase that wouldn't be possible with commercial tools alone.

I will experiment with the new coding assistant in my future Substack posts to improve features and the UX.

And here is the roadmap to enhancing the assistant through self-modification:

1. File Analysis: Add support for parsing code structure, dependencies, and relationships

2. Git Integration: closer relationship between changes and commits

3. Multiple AI Providers: Integrate with Claude/Anthropic, Gemini, etc.

4. Prompts Template: Create specialized templates for different types of context, programming language and questions

5. Enhanced UI: Improve the terminal interface

In the meantime, I will be publishing a version of this minimal coding assistant on npm if you don’t want to repeat the seeding process: https://www.npmjs.com/package/vybe

1. https://x.com/karpathy/status/1886192184808149383