Forem: Sreenath

How to Generate Code in Vim Without Leaving Your Editor (llmswap Tutorial)

Sreenath — Wed, 10 Sep 2025 17:54:01 +0000

Complete step-by-step guide to AI-powered code generation directly in vim

If you're a vim user who's tired of constantly switching to ChatGPT, Claude, or other AI tools just to generate a quick function or command, this tutorial is for you.

By the end of this guide, you'll be generating code directly in your vim buffer without ever leaving your editor.

What We're Building

Instead of this workflow:

Get stuck on a function
Alt-tab to ChatGPT
Ask for help
Copy the response
Alt-tab back to vim
Paste and fix formatting

You'll do this:

Type :r !llmswap generate "what you need"
Code appears at your cursor
Keep coding

Prerequisites

Vim installed (obviously!)
Python 3.7+
An API key for any LLM provider (OpenAI, Anthropic, Google, etc.)

Step 1: Install llmswap

pip install llmswap

That's it. No config files, no complex setup.

Step 2: Set Your API Key

Choose your preferred AI provider and set the environment variable:

For OpenAI (GPT-4):

export OPENAI_API_KEY="sk-your-key-here"

For Anthropic (Claude):

export ANTHROPIC_API_KEY="sk-ant-your-key-here"

For Google (Gemini):

export GEMINI_API_KEY="your-gemini-key"

For local/free option (Ollama):

# No API key needed, just install Ollama
export OLLAMA_MODEL="llama2"

Add this to your .bashrc or .zshrc to make it permanent.

Step 3: Test in Terminal First

Before using in vim, test in your terminal:

llmswap generate "Python function to read CSV file with error handling"

You should see a complete function appear. If not, check your API key setup.

Step 4: The Magic Vim Command

In vim, the :r ! command runs a shell command and inserts its output at your cursor position.

Basic syntax:

:r !llmswap generate "what you want to generate"

Step 5: Your First Code Generation

Open vim and try this:

Open a Python file: vim test.py
Position your cursor where you want the function
Type: :r !llmswap generate "function to validate email address"
Press Enter
Watch the code appear!

Real Examples You Can Try Right Now

Python Examples

Generate a class:

:r !llmswap generate "Python class for database connection with connection pooling"

Generate error handling:

:r !llmswap generate "try-catch block for file operations in Python"

Generate API call:

:r !llmswap generate "Python function to make HTTP POST request with retry logic"

JavaScript Examples

Generate React component:

:r !llmswap generate "React functional component with useState and useEffect"

Generate Express middleware:

:r !llmswap generate "Express middleware for request logging and authentication"

Generate async function:

:r !llmswap generate "JavaScript async function to fetch data from API with error handling"

Configuration Files

Generate Docker config:

:r !llmswap generate "Dockerfile for Node.js application with multi-stage build"

Generate nginx config:

:r !llmswap generate "nginx configuration for reverse proxy with SSL"

Generate systemd service:

:r !llmswap generate "systemd service file for Python web application"

Step 6: Advanced Vim Integration

Create Vim Mappings

Add these to your .vimrc for quick access:

" Generate code with <leader>g
nnoremap <leader>g :r !llmswap generate "
" Generate and explain with <leader>e
nnoremap <leader>e :r !llmswap generate "

Now you can just press <leader>g and start typing what you need.

Language-Specific Generation

Force specific language output:

:r !llmswap generate "database connection" --language python
:r !llmswap generate "API endpoint" --language javascript
:r !llmswap generate "struct definition" --language rust

Save Generated Code to File

:!llmswap generate "complete web scraper" --save scraper.py

This generates code and saves it directly to a file.

Step 7: Pro Tips and Tricks

1. Be Specific in Your Requests

Instead of:

:r !llmswap generate "function"

Try:

:r !llmswap generate "Python function to parse JSON with nested error handling and logging"

2. Generate Test Code

:r !llmswap generate "pytest unit tests for user authentication function"

3. Generate Documentation

:r !llmswap generate "docstring for this function" --context "def calculate_metrics(data, threshold):"

4. Generate Command Line Scripts

:r !llmswap generate "bash script to backup PostgreSQL database with compression"

5. Generate Regular Expressions

:r !llmswap generate "regex to extract email addresses from text"

Common Use Cases

Database Operations

MongoDB queries:

:r !llmswap generate "MongoDB aggregation pipeline to group users by signup date"

SQL operations:

:r !llmswap generate "PostgreSQL query to find duplicate records in users table"

DevOps and System Administration

Docker commands:

:r !llmswap generate "docker-compose file for Python app with Redis and PostgreSQL"

Kubernetes configs:

:r !llmswap generate "Kubernetes deployment YAML for Node.js application"

Log analysis:

:r !llmswap generate "awk command to extract error patterns from nginx logs"

Web Development

API endpoints:

:r !llmswap generate "FastAPI endpoint with request validation and error handling"

Frontend components:

:r !llmswap generate "Vue.js component with props, computed properties, and methods"

Troubleshooting

Code Doesn't Appear

Check your API key is set correctly
Test llmswap generate "hello world" in terminal first
Make sure you're using :r ! (not just :!)

Wrong Language Generated

Add --language python (or your language) to the command
Be more specific about what you want

Formatting Issues

The generated code appears at cursor position
Use vim's formatting commands (= key) to fix indentation
Position cursor at the right indentation level before generating

API Errors

Check your API key hasn't expired
Make sure you have credits/quota remaining
Try switching providers: export ANTHROPIC_API_KEY=...

Why This Changes Everything

Once you get used to this workflow, you'll realize:

No more context switching - Stay in the zone
Faster development - Generate boilerplate instantly
Learn as you go - See different approaches to problems
Multi-language support - Works with any programming language
Provider flexibility - Use OpenAI, Claude, Gemini, or local models

Taking It Further

Multiple Providers

# Use different providers for different tasks
export OPENAI_API_KEY="..."      # For general coding
export ANTHROPIC_API_KEY="..."   # For complex logic
export GEMINI_API_KEY="..."      # For fast responses

llmswap automatically uses the first available key it finds.

Local Development with Ollama

For completely offline development:

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull a model
ollama pull llama2

# Use with llmswap
export OLLAMA_MODEL="llama2"
# Now llmswap generate works offline!

Conclusion

You now have AI-powered code generation built directly into vim. No more browser tabs, no more copy-paste, no more breaking your flow.

The key command to remember:

:r !llmswap generate "exactly what you need"

Start with simple examples and gradually incorporate it into your workflow. Within a week, you'll wonder how you ever coded without it.

Quick Reference

" Basic generation
:r !llmswap generate "Python function to read CSV"

" With language specification  
:r !llmswap generate "API endpoint" --language javascript

" Save to file
:!llmswap generate "complete script" --save script.py

" Get explanation
:!llmswap generate "explain this regex: '^[a-zA-Z0-9+_.-]+@[a-zA-Z0-9.-]+$'"

Resources

GitHub: https://github.com/sreenathmmenon/llmswap
PyPI: https://pypi.org/project/llmswap/
Documentation: Full provider setup guides in the repo

Try it now: Install llmswap and generate your first function in vim. You'll never go back to the old way.

Did this tutorial help you? Give the project a ⭐ on GitHub - every star helps with continued development!

I Finally Stopped Alt-Tabbing to ChatGPT While Coding

Sreenath — Tue, 09 Sep 2025 17:01:17 +0000

TL;DR

Built a terminal command that generates code/commands using any AI provider. No more alt-tabbing to ChatGPT. Works in vim too. pip install llmswap → llmswap generate "your command"

Last Tuesday, I was debugging a Kubernetes cluster at 3 AM. Had vim open with a YAML file that refused to work, ChatGPT open in Chrome, Stack Overflow in another tab, and Claude.ai in a third. The constant alt-tabbing between terminal, ChatGPT, Stack Overflow, and AI assistants was driving me absolutely insane.

That's when it hit me - why am I leaving my terminal to get help from AI?

The Breaking Point

We've all been there. You know that one command exists, but can't remember the exact syntax. Maybe it's that Docker cleanup command, or the specific awk pattern you need, or how to properly configure nginx for reverse proxy.

The routine is always the same: switch to browser, search, scroll through results, copy command, switch back to terminal, paste, test, fail, repeat.

I realized I was doing this dozens of times per day. Every context switch was breaking my flow. Every copy-paste felt like admitting defeat.

That's when I remembered - llmswap 4.1.1 had just shipped with a generate command. What if I could get AI help without ever leaving my terminal?

The Terminal Revolution

Here's what changed everything. Instead of alt-tabbing to ChatGPT, I could just type:

llmswap generate "show me all Docker containers eating memory"

And instantly get:

docker stats --no-stream --format "table \t\t"

No browser. No tabs. No context switching. The answer appeared right where I needed it.

But it gets better. Need to save it to a file?

llmswap generate "backup script for PostgreSQL with rotation" > backup.sh
chmod +x backup.sh

Done. Script created, permissions set, ready to go.

Real Examples from This Week

Let me show you how this actually works in practice. These are real commands I generated this week:

Monday morning: Client's website was down. Needed to check nginx logs quickly.

llmswap generate "find errors in nginx logs from last hour"
# Got: tail -f /var/log/nginx/error.log | grep $(date -d '1 hour ago' '+%d/%b/%Y:%H')

Tuesday: Setting up a new Django project. Needed that docker-compose I always forget.

llmswap generate "docker compose for django postgres redis development" --language yaml

Perfect 40-line docker-compose.yml appeared. With health checks, volume mounts, everything.

Wednesday: Database migration day. Needed to find duplicate emails before adding a unique constraint.

llmswap generate "PostgreSQL find duplicate emails in users table"
# Got: SELECT email, COUNT(*) FROM users GROUP BY email HAVING COUNT(*) > 1;

Thursday: Had to analyze some API logs. That awk command I can never remember.

llmswap generate "extract IP addresses and count from nginx access log"
# Got: awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -nr

Friday: Client needed 100 VMs spun up in OpenStack with delays to avoid overwhelming the API.

llmswap generate "script to create 100 VMs in openstack with 30 second delays"

Got a complete bash script with proper batching and error handling.

Weekend: Emergency debugging session. Needed to grep through compressed log files.

llmswap generate "search for error patterns in gzipped log files"
# Got: zgrep -i "error\|fail\|exception" /var/log/app/*.gz | head -50

Each time, the answer appeared in seconds. No browser needed.

But Wait, It Gets Even Better

Here's where things got really interesting. I discovered you can use this inside vim too.

Working on a Node.js project, needed rate limiting middleware. Instead of googling and copy-pasting, I typed this inside vim:

:r !llmswap generate "Express rate limiting middleware"

And this appeared directly in my file:

const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // limit each IP to 100 requests per windowMs
  message: {
    error: 'Too many requests, please try again later.'
  },
  standardHeaders: true,
  legacyHeaders: false,
});

module.exports = limiter;

I just sat there staring at the screen. The code materialized exactly where my cursor was. No switching. No copying. Just… there.

The Vim Integration That Blew My Mind

The :r ! command in vim reads the output of any shell command directly into your buffer. Combine that with llmswap generate and you get instant code generation inside your editor.

Need a MongoDB schema?

:r !llmswap generate "User schema with authentication for MongoDB"

Need nginx config?

:r !llmswap generate "nginx reverse proxy config for Node.js app"

Need a bash script?

:r !llmswap generate "script to backup files older than 30 days"

Every time, the code appears right at your cursor. It's like having ChatGPT built into vim, but better - because it works with any LLM provider.

The Provider Freedom That Changes Everything

Here's what really gets me excited. While GitHub Copilot locks you into their $10/month subscription and their provider choices, llmswap gives you complete freedom.

Want to use Claude because it's better at systems programming? Set ANTHROPIC_API_KEY.

Want ultra-fast responses? Use Groq with GROQ_API_KEY.

Want to keep everything local? Run Ollama.

Already paying for Gemini API? Use that instead of another subscription.

export ANTHROPIC_API_KEY="your-key"
llmswap generate "whatever you need"

Same command, different AI behind it. Your choice.

My New Daily Workflow

This is how I work now:

Morning system check:

llmswap generate "check system health on Ubuntu server"
# Gets me: df -h; free -m; uptime; systemctl --failed

Database work:

llmswap generate "MySQL show slow queries from last hour"
# Gets me: mysqldumpslow -t 10 /var/log/mysql/slow.log

llmswap generate "MongoDB create user with read and write privileges"
# Gets me: mongo admin --eval 'db.createUser({user:"appuser",pwd:"password",roles:[{role:"readWrite",db:"myapp"}]})'

Git operations (because I always forget):

llmswap generate "git remove file from history completely"
# Gets me: git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch file.txt'

Quick scripts in vim:

:r !llmswap generate "Python function to read CSV with error handling"
:r !llmswap generate "JavaScript debounce function"
:r !llmswap generate "Bash script to rotate logs"

The Unexpected Use Cases

I started using it for everything. Literally everything.

AWS operations:

llmswap generate "AWS CLI list all EC2 instances with names and IPs"

Kubernetes debugging:

llmswap generate "kubectl commands to debug failing pod"

Performance analysis:

llmswap generate "find which process is using most CPU"

Security checks:

llmswap generate "check for failed SSH attempts in system logs"

Network debugging:

llmswap generate "test if port 443 is open on remote server"

Even configuration files. Need a systemd service?

llmswap generate "systemd service file for Python web app" > myapp.service

The answer is always there, in seconds, right in your terminal.

Why This Matters More Than You Think

Let's talk numbers. GitHub Copilot costs $10/month per developer. For a team of 10 developers, that's $1,200/year.

With llmswap:

Use Gemini: Costs 96% less than GPT-4
Use Ollama: Completely free, runs locally
Use whatever API access you already have
No subscriptions, no vendor lock-in

But it's not just about money. It's about choice. Maybe you want IBM Watson for enterprise features. Maybe you want Groq for speed. Maybe you want everything local with Ollama.

Your terminal, your AI, your choice.

The Setup (Embarrassingly Simple)

pip install llmswap

Set one environment variable for your preferred provider:

export OPENAI_API_KEY="your-key" # Or any other provider

That's it. Start generating:

llmswap generate "your first command"

What I Realized

I haven't opened ChatGPT in my browser for three weeks. My terminal became my AI assistant.

Think about your daily workflow. How many times do you:

Ask ChatGPT for a command you've forgotten
Search Stack Overflow for syntax
Switch to Claude for code explanations
Jump to Gemini for a different perspective
Copy-paste from documentation sites

What if you never had to leave your terminal again?

The Real Test

Last Friday, I was setting up monitoring for a client. Needed Prometheus, Grafana, alertmanager - the whole stack. Instead of hunting through documentation:

llmswap generate "docker compose for Prometheus Grafana monitoring stack" > monitoring.yml

Got a complete 80-line docker-compose file with proper networking, volumes, and health checks. Launched it, configured alerts, done.

What used to take 2 hours took 20 minutes.

Try This Right Now

If you're in your terminal, try this:

echo "The current time is: $(date)"

See how the command output appears? Now imagine that with any code you need:

llmswap generate "function to validate email addresses in Python"

Or in vim:

:r !date

See how it inserts into your file? Now try:

:r !llmswap generate "that regex you always forget"

The Future is Here

We're developers. We live in terminals. Our AI assistants should live there too.

Every alt-tab breaks focus. Every context switch costs time. Every copy-paste is friction.

This shipped in llmswap 4.1.1 last week. It's already changed how I write code.

The best part? It's not replacing your thinking - it's eliminating the friction between your thoughts and your code.

Your terminal is waiting. Your AI assistant is one pip install away.

pip install llmswap
llmswap generate "the command you always google"

Welcome to coding without context switching.

Links:

Setup: Just set one API key for your preferred provider:

export ANTHROPIC_API_KEY="sk-..." # For Claude
export OPENAI_API_KEY="sk-..." # For GPT-4
export GEMINI_API_KEY="..." # For Google Gemini
# ... or any of the 8 supported providers

⭐ Star the project on GitHub if it saves you time - every star motivates continued development! ⭐

This is part 2 of my llmswap series. Read part 1: From Hackathon to Open Source to see how llmswap was born.

What's your biggest context-switching pain point when coding? Drop your thoughts in the comments!

How a Hackathon Rejection Became 6,000+ PyPI Downloads

Sreenath — Wed, 03 Sep 2025 16:12:06 +0000

I was working on a hackathon project - an AI assistant that lets you chat with your infrastructure using RAG + MCP. Think of it as a live conversation with your entire cloud setup.

We built support for multiple LLM providers - Gemini, Watsonx, and Ollama. The switching logic was there, but embedded deep in the project code.

Then I came across this VentureBeat article where Armand Ruiz, IBM's AI VP, discussed how enterprise customers use multiple AI providers -
"the challenge is matching the LLM to the right use case." That validated what we were building.

During the hackathon, we implemented a config system where users could specify different providers and models, pass API keys through config files or environment variables, and set a default provider. It worked well for our use case.

By the hackathon submission deadline, we supported Anthropic, Gemini, Watsonx, and Ollama. Same app, different brains.

We didn't make the shortlist. But I wasn't ready to end the story there and kept improving what I had in control.

I realized we had built something valuable - this provider-switching logic buried in our codebase was solving a real problem. So I extracted it, restructured it properly, added more providers and CLI tools, and open-sourced it as llmswap.

# Instead of this mess in every project
if provider == "openai":
    from openai import OpenAI
    client = OpenAI(api_key=key)
elif provider == "anthropic":
    from anthropic import Anthropic
    client = Anthropic(api_key=key)
# ... repeat for 7 providers

# Just this
from llmswap import LLMSwap
llm = LLMSwap()  # Reads from config or env vars
response = llm.ask("Your question")

The extracted version is much cleaner than what we had in the hackathon.
Plus, I added CLI tools that became my daily workflow:

# Quick infrastructure questions
llmswap ask "Which logs should I check to debug Nova VM creation failure?"

# Interactive troubleshooting
llmswap chat

# Debug OpenStack errors
llmswap debug --error "QuotaPoolLimit:"

# Review infrastructure code
llmswap review heat_template.yaml --focus security

These CLI tools alone save us 10+ ChatGPT tab switches daily.

6,000+ downloads on PyPI in the first month.

Sometimes your best open source contributions come from recognizing the valuable pieces in larger projects. What started as embedded hackathon code became a tool helping thousands of developers.

PyPI: https://pypi.org/project/llmswap/

Update (Sept 5, 2024): v4.0.0 Released! 🚀

I just shipped v4.0.0:

What's New:

Cost Analytics - Compare real costs across OpenAI, Claude, Gemini, IBM Watsonx, and Ollama
Usage Tracking - See exactly where your AI budget goes
50-90% Savings - Intelligent caching + provider optimisation
Privacy First - Your prompts are never stored, only metadata's

The journey continues! Check out the new features