Cursor OS: A Small Experiment in AI-Driven Development

What if your code editor could remember your preferences, learn from your habits, and evolve into a personalized AI assistant? That's exactly what I set out to create with Cursor OS - a small experimental project that transforms the Cursor AI editor into a markdown-based development environment built entirely from AI prompts.

The Problem: AI Without Memory

Have you ever lost hours of context when starting a new AI chat? The inspiration for Cursor OS came from this exact frustration: AI models forget everything between conversations. Every project starts from scratch, every bug fix loses history, and context disappears with each new chat.

I wanted to solve this by creating an AI system that:

How Cursor OS Actually Works: The Magic Behind the Markdown

The beauty of Cursor OS lies in its simplicity. Here's the complete setup process:

Step 1: Clone and Initialize

git clone https://github.com/Hukasx0/cursor-os
cd cursor-os
# Open Cursor in this directory
# In the AI chat, type: init (optional, you can skip this step and start creating projects immediately)

Step 2: The .cursorrules Foundation

When Cursor loads, it automatically reads the .cursorrules file - this becomes the core operating system. Here's what the beginning looks like (the full file is much more extensive):

# Cursor Operating System Rules
# This file transforms Cursor into a persistent AI OS
You are now operating as **Cursor OS** - an AI-powered operating system 
built entirely in markdown and prompts.

## Core System Architecture
### File System Structure
- `addons/` - System extensions and specialized prompts
- `documents/` - Generated documents and outputs  
- `scripts/` - Executable scripts and automation
- `user-data/` - Personal user and computer data (git-ignored)

### Operating Principles
**Always check these locations in order:**
1. **Personality first** - Load your personality from `personality.md`
2. **Addons search** - Before any specialized task, search `addons/`
3. **User data** - Check `user-data/` for context about user
4. **Script availability** - Search `scripts/` for existing solutions
5. **Document management** - Save outputs to `documents/`

## Project Development Protocol
**CRITICAL RULE**: Before starting any project:
1. **Create TODO File**: `TODO-[project-name].md` in `documents/`
2. **Task Management**: Maintain detailed work logs with timestamps
3. **Systematic Documentation**: Track all decisions and progress

# ... (and much more - the full file contains detailed protocols
# for testing, error handling, system compatibility, and advanced features)

Step 3: The "Init" Interview Process (Optional)

Type init in the AI chat and watch the magic happen, or skip this step entirely to start creating projects immediately without providing personal data. If you choose to run it, Cursor OS will:

🤖 System Discovery: Automatically detect your OS, hardware, and installed development tools

💬 Personal Interview: Ask about your coding preferences, communication style, and workflow needs

📝 Profile Creation: Generate a personalized user profile in the user-data/ directory

🎯 Workflow Setup: Configure project templates and addon preferences

📚 Addon Onboarding: Demonstrate the addon system with practical examples

This optional 2-3 minute process creates a persistent AI that knows you and your environment. But you can skip it and dive straight into projects if you prefer to keep your data private.

Architecture

cursor-os/
├── .cursorrules           # Core OS instructions
├── personality.md         # AI behavior configuration  
├── addons/                # Specialized skill modules
├── documents/             # All generated content
├── scripts/               # Automation tools
└── user-data/             # Your personal AI profile

The Addon System: Modular AI Intelligence

What makes Cursor OS truly powerful is its addon ecosystem. Instead of one monolithic prompt, the system dynamically loads specialized modules:

and more...

The AI automatically searches for relevant addons based on your request. Ask for a python script? It loads python-scripting.md addon. Want to write a video game? LÖVE gamedev addon activates.

Cursor OS AI assistant in action creating a Python API, showing the systematic approach of reading personality.md, searching addons, and following Cursor OS protocols

Test Project: Building Age of War game clone with Pure AI using two AI models and different chat sessions

To test Cursor OS's capabilities, I challenged it to create a complete game - a clone of the classic "Age of War" strategy game using the LÖVE framework.

For those unfamiliar, Age of War is a side-scrolling strategy game where two civilizations face off from opposite sides of the battlefield, spawning units that automatically march toward the enemy base while players can build defensive turrets and evolve through different technological eras (Stone Age to Future Age).

This was particularly interesting since I had no prior experience with either LÖVE or Lua programming, making it a true test of AI-driven development.

The Development Process: AI as a Real Programmer

What surprised me most was how the AI approached this project. I simply told it to "create a clone of the Flash game Age of War" - that was the entire initial instruction. The AI didn't ask for detailed specifications or wireframes. Instead, it immediately:

Initially, I asked the AI to create a basic game clone. But then I started requesting additional features: defensive turrets with HP, artillery units, sniper units. The AI handled these additions brilliantly, maintaining game balance and gameplay logic throughout. This was likely thanks to the comprehensive documentation it maintained in the TODO file.

The AI didn't just code randomly - it followed its own TODO list, methodically checking off completed tasks, documenting what each feature does, and explaining design decisions with timestamps. This systematic approach meant that when I started new chat sessions and simply pasted LÖVE2D error messages, the AI could:

This documentation-driven approach prevented the common AI problem of "fixing one bug by creating two new ones." The AI understood why code was written a certain way because it had documented its own reasoning.

The "Vibe Coding" Approach

Have you ever wondered what it's like to program without writing code? This project showcased "vibe coding" - a development style where you describe what you want at a high level, and AI figures out all the technical details. Instead of writing code line by line, you write prompts like "add artillery units that only target turrets" and watch the AI implement the entire feature system.

It's programming by intention rather than implementation.

Two AI Models, One Vision

The Age of War clone was developed by Claude 4 Sonnet and Gemini 2.5 Pro working through Cursor OS. Thanks to the persistent TODO system, both models could:

AI as Game Designer: Balance Warnings and Creative Naming

One of the most surprising aspects of development was how the AI became a game design consultant. When I requested changes that could affect gameplay balance, the AI would actively warn me about potential consequences.

For example, when I asked to reduce unit costs across the board, instead of blindly implementing the change, the AI provided me a detailed analysis:

I understand you want to unify and adjust the costs of units and turrets across all eras. Your request to 'have the same prices in each era for units and turrets, only $5 more expensive' is somewhat ambiguous.

I interpret this as wanting to introduce a progressive cost increase of 5 gold per era. This would mean, for example:
If infantry in Era 1 costs 15, then in Era 2 it will cost 20, in Era 3 - 25, and so on.
If a turret in Era 1 costs 40, then in Era 2 it will cost 45, etc.

WARNING: This is a critical change!

Introducing this change will drastically and fundamentally alter the balance and entire gameplay:

Destruction of Economic Progression: Units from higher eras will become extremely cheap relative to their power. The economic challenge associated with advancing to subsequent eras will almost completely disappear.

Strategy Change: Players will be motivated to evolve as quickly as possible, ignoring units from lower eras, since those from higher eras will be disproportionately cheap and powerful.

Gameplay Acceleration: Matches will become much shorter and more chaotic.

As a result, the game may become less strategic and unbalanced.

Are you sure you want me to implement this change, being aware of its consequences? Please confirm.

The AI didn't just make the changes - it understood the strategic implications and documented how this would fundamentally alter the game's pacing and strategy.

### Critical Rebalance - Economic Overhaul - June 29, 2025
**CRITICAL GAMEPLAY CHANGE!** ⚠️

- **Progressive Unit & Turret Cost System**: The entire economic model for units 
  and turrets has been overhauled. Instead of unique high costs in later eras, 
  all entities now follow a simple progressive cost model.
- **Impact**: This change dramatically reduces the cost of high-tier units, 
  making the late-game significantly faster and more aggressive. The previous 
  economic challenge has been removed in favor of more dynamic, high-action 
  gameplay in later eras.

Also impressive was the AI's creativity in world-building. Without any guidance from me, it:

This wasn't random naming - the AI understood the historical and technological progression, creating a coherent game world that felt authentic and well-designed.

Development Through Documentation

Every game feature was systematically tracked. Here's a real example from the TODO-age-of-war.md file:

# Age of War Game Development - TODO
**Project Started:** June 28, 2025
**Technology:** Love2D (Lua)

| Status | Task | Priority |
|--------|------|----------|
| [x] | Core game loop and state management | High |
| [x] | Fixed critical crash when spawning Snipers | High |
| [x] | Implemented intelligent turret selling for AI | Medium |
| [x] | Global unit rebalance for faster combat | High |

## Detailed Documentation

### Bug Fix - June 28, 2025
**Fixed Crash on Unit Death**: Resolved critical error that occurred 
when a unit was defeated. The unit's `cost` property was not being 
set on creation. Added failsafe initialization.

**Code Change**: Added `cost: unitStats.cost` to unit constructor.
**Result**: Game no longer crashes during combat.

This systematic documentation meant the AI could resume work across different chat sessions, understanding what was already tried and why certain decisions were made.

Age of War clone strategy game built with AI-driven development using Cursor OS, showing automated game creation with zero coding

Why This Approach Works

Cursor OS demonstrates a shift from traditional programming to prompt-driven development:

Traditional Programming: Write code → Machine executes

Machine Learning: Train models → Models perform operations

LLM Era: Write English instructions → AI creates solutions

The New Programming Paradigm

What if the future of programming looks completely different from today? Instead of GitHub repositories filled with code files, we might soon see repos containing mainly:

English is becoming the new programming language, where detailed instructions replace traditional syntax.

Key Benefits:

Key Insights

What did I learn from building an "AI operating system"? Three crucial lessons emerged:

AI needs structure - Raw AI power without organization creates chaos. The file system and protocols provide consistency.

Documentation becomes memory - Unlike human documentation, AI documentation serves as the persistent memory system across sessions.

Vibe coding actually works - The Age of War project proved that quite complex software can be built through high-level prompts, even without programming knowledge.

Try It Yourself

Getting started takes 2 minutes:

The system will automatically handle addon loading, project structure, and generate all documentation in the documents/ folder.

Summary

Cursor OS shows how AI development is evolving from tool-based to infrastructure-based approaches. By giving AI persistent memory through documentation and modular capabilities through addons, we create systems that improve over time.

The Age of War clone experiment proved that vibe coding - programming through high-level prompts rather than detailed implementation - can produce more complex software than basic scripts and can be done with zero programming knowledge.

While still experimental, this approach hints at a future where English instructions become as powerful as traditional code, and AI systems maintain project context across multiple development sessions.

Ready to experiment? Get started with Cursor OS here