Building the AI Coding Assistant I Always Wanted: Lessons from Creating Mini Cursor

Nawin SharmaNawin Sharma
6 min read

Introduction

Have you ever wondered what it would be like to have an AI assistant that can actually write code, create files, and manage your development workflow? That's exactly what I set out to build with codexLite - an intelligent, command-line AI coding agent that acts like a mini version of Cursor IDE.

After spending weeks developing this project, I want to share my key learnings, challenges, and insights that might help other developers venturing into AI-assisted development tools.

What is codexLite?

codexLite is an interactive terminal-based AI assistant that can:

  • Generate complete applications from natural language descriptions

  • Manage files and folders

  • Run commands and servers

  • Debug issues and optimize code

  • Maintain conversation context for complex projects

Think of it as having a senior developer pair-programming with you, but one that never gets tired and can work across any technology stack.

Architecture Overview

The system is built around a simple but powerful architecture:

# Main conversation loop from main.py
while True:
    user_input = input("\n📬 User > ").strip()

    # Check if context should be summarized
    if should_summarize_context(messages):
        print("🔄 Summarizing context to improve performance...")
        messages = summarize_context(messages)

    messages.append({"role": "user", "content": user_input})

    # Get AI response and execute actions
    response = client.chat.completions.create(
        model="gpt-4o",
        response_format={"type": "json_object"},
        messages=messages,
        temperature=0.3,
        max_tokens=2000
    )

Key Learning #1: Structured JSON Responses Are Game-Changers

One of the biggest breakthroughs was implementing structured JSON responses. Instead of parsing free-form text, I force the AI to respond in a specific format:

{
  "step": "plan|action|observe|complete",
  "content": "Detailed explanation",
  "tool": "tool_name",
  "input": "tool_input"
}

This approach eliminated 90% of parsing errors and made the system much more reliable. Here's how it works in practice:

# From main.py - parsing structured responses
parsed = json.loads(reply)
step = parsed.get("step")

if step == "plan":
    print(f"🔠 PLAN: {parsed['content']}")
elif step == "action":
    tool_name = parsed.get("tool")
    tool_input = parsed.get("input")
    result = available_tools[tool_name](tool_input)
    print(f"📤 OUTPUT: {result}")

Key Learning #2: Tool Management is Critical

Creating a robust tool system was essential. I organized tools into logical categories:

# From tools/__init__.py
from .command_tools import run_command, run_server, stop_servers
from .file_tools import create_folder, write_file, read_file, list_files, find_files
from .system_tools import get_current_directory, check_port

The most important lesson here was never use run_command for server processes. This was a hard-learned lesson that caused many hanging processes:

# From command_tools.py - Critical server command detection
server_commands = ['npm start', 'npm run dev', 'yarn start', 'yarn dev', 
                  'flask run', 'python -m flask run', 'python app.py',
                  'node server.js', 'nodemon', 'serve', 'http-server']

if any(server_cmd in cmd.lower() for server_cmd in server_commands):
    return f"⚠️ This looks like a server command. Use 'run_server' tool instead"

Key Learning #3: Context Management is Everything

Long conversations quickly exhaust token limits. I implemented an intelligent context summarization system:

# From context_manager.py
def should_summarize_context(messages):
    """Check if context should be summarized"""
    total_tokens = sum(len(msg["content"]) for msg in messages)
    return total_tokens > 15000

def summarize_context(messages):
    """Summarize conversation context"""
    system_msg = messages[0]
    recent_messages = messages[-10:]  # Keep recent context
    middle_messages = messages[1:-10]  # Summarize the middle

    if middle_messages:
        summary_response = client.chat.completions.create(
            model="gpt-4o-mini",  # Use cheaper model for summarization
            messages=[
                {"role": "system", "content": summary_prompt},
                {"role": "user", "content": summary_content}
            ]
        )

        summary = summary_response.choices[0].message.content
        return [system_msg, {"role": "system", "content": f"CONTEXT SUMMARY: {summary}"}] + recent_messages

This approach maintains conversation flow while keeping costs manageable.

Key Learning #4: Error Handling and Graceful Degradation

Real-world usage taught me that error handling is crucial. The system needs to handle:

# Robust error handling example from file_tools.py
def write_file(data):
    try:
        if isinstance(data, dict):
            path = data.get("path")
            content = data.get("content")

            # Create directory if it doesn't exist
            os.makedirs(os.path.dirname(path), exist_ok=True)

            # Backup existing file
            if os.path.exists(path):
                backup_path = f"{path}.backup"
                os.rename(path, backup_path)

            with open(path, "w", encoding="utf-8") as f:
                f.write(content)
            return f"File written: {os.path.abspath(path)}"
        else:
            return "Input must be a dictionary with 'path' and 'content'."
    except Exception as e:
        return f"Error writing file: {e}"

Key Learning #5: The Power of Comprehensive System Prompts

The system prompt is the brain of the AI agent. I crafted a detailed prompt that covers:

# From prompts.py - System prompt structure
SYSTEM_PROMPT = """
You are an expert-level, intelligent full-stack development assistant...

## 🎯 **COMPREHENSIVE DEVELOPMENT CAPABILITIES**
### **Project Architecture & Design**
- **Full-Stack Application Development**: Create complete applications...
- **Microservices Architecture**: Design and implement scalable, distributed systems...
- **API-First Development**: Build robust RESTful APIs, GraphQL endpoints...

### **JSON Response Format**
All responses must follow this structured format:
{
  "step": "plan|action|observe|complete",
  "content": "Detailed explanation with reasoning and context",
  "tool": "tool_name",
  "input": "tool_input"
}
"""

Real-World Example: Building a Todo App

Here's how the system works in practice. When a user asks for a "todo app with CRUD functionality," the AI:

  1. Plans the architecture and approach

  2. Creates the project structure

  3. Writes HTML, CSS, and JavaScript files

  4. Completes with testing instructions

# The AI generates structured responses like:
{"step": "plan", "content": "Creating a basic Todo app with HTML, CSS, and JavaScript..."}
{"step": "action", "tool": "create_folder", "input": "todo-app"}
{"step": "action", "tool": "write_file", "input": {"path": "todo-app/index.html", "content": "<!DOCTYPE html>..."}}
{"step": "complete", "content": "Todo app created successfully. Open index.html to test."}

Challenges and Solutions

Challenge 1: Process Management

Problem: Server processes would hang and consume resources.

Solution: Implemented dedicated server management with proper cleanup:

# Global process tracking
running_processes = []

def run_server(cmd):
    process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    running_processes.append(process)
    return f"Server started (PID: {process.pid}): {cmd}"

def stop_servers():
    for process in running_processes:
        try:
            process.terminate()
            process.wait(timeout=5)
        except:
            process.kill()
    running_processes.clear()

Challenge 2: Context Window Limitations

Problem: Long conversations exceeded token limits.

Solution: Smart context summarization that preserves important information while reducing token usage by 70%.

Challenge 3: Reliability Issues

Problem: Network errors and API failures disrupted workflows.

Solution: Implemented retry logic with exponential backoff:

for attempt in range(3):
    try:
        response = client.chat.completions.create(...)
        break
    except Exception as e:
        if attempt == 2:
            print("❌ Failed after 3 attempts")
            break
        time.sleep(2 ** attempt)  # Exponential backoff

Performance Insights

After extensive testing, I discovered several optimization opportunities:

  1. Model Selection: Using GPT-4o for main responses and GPT-4o-mini for summarization reduced costs by 60%

  2. Token Management: Context summarization improved response speed by 40%

  3. Structured Responses: JSON format reduced parsing errors by 90%

What's Next?

The project opened my eyes to the potential of AI coding agents. Future improvements could include:

  • Plugin System: Allow developers to add custom tools

  • Multi-Agent Collaboration: Specialized agents for different tasks

  • Code Analysis: Static analysis and security scanning

  • Integration: IDE plugins and CI/CD integration

Conclusion

Building codexLite taught me that creating effective AI coding agents requires more than just connecting to an LLM. It demands:

  • Structured Communication: Clear protocols between human and AI

  • Robust Error Handling: Graceful degradation when things go wrong

  • Context Management: Intelligent handling of conversation history

  • Tool Design: Well-thought-out abstractions for system interaction

The most surprising insight was how much the system prompt matters. A well-crafted prompt can make the difference between a frustrating experience and a truly helpful assistant.

If you're building AI tools, remember: the technology is just the foundation. The real magic happens in the details of user experience, error handling, and thoughtful design.

The future of software development will likely involve AI agents as standard tools. Projects like codexLite are just the beginning of this transformation.

Want to try codexLite? Check out the full codebase and give it a spin. The journey of building with AI is just getting started, and I'm excited to see what the community creates next.

Code Repository

The complete source code for codexLite is available with detailed documentation on installation and usage. Key files include:

  • main.py - Core conversation loop and AI interaction

  • tools/ - Modular tool system for file operations, commands, and system management

  • prompts.py - Comprehensive system prompt engineering

  • context_manager.py - Intelligent conversation summarization

  • requirements.txt - All dependencies for easy setup

Get started by cloning the repository, setting up your OpenAI API key, and running python main.py to begin your AI-assisted development journey.

https://github.com/nawinsharma/codexlite

https://nawin.xyz/

0
Subscribe to my newsletter

Read articles from Nawin Sharma directly inside your inbox. Subscribe to the newsletter, and don't miss out.

mini-cursorcursorAIllmAI Coding Assistant

Written by

Nawin Sharma
Nawin Sharma