Update README.md (#34)

Author: grapeot

README.md

@@ -1,127 +1,48 @@
-# Devin.cursorrules
+# Transform your $20 Cursor into a Devin-like AI Assistant
 
-Transform your $20 Cursor/Windsurf into a Devin-like experience in one minute! This repository contains configuration files and tools that enhance your Cursor or Windsurf IDE with advanced agentic AI capabilities similar to Devin, including:
+This repository gives you everything needed to supercharge your Cursor or Windsurf IDE with **advanced** agentic AI capabilities—similar to the $500/month Devin—but at a fraction of the cost. In under a minute, you’ll gain:
 
-- Process planning and self-evolution
-- Extended tool usage (web browsing, search, LLM-powered analysis)
-- Automated execution (for Windsurf in Docker containers)
+* Automated planning and self-evolution, so your AI “thinks before it acts” and learns from mistakes
+* Extended tool usage, including web browsing, search engine queries, and LLM-driven text/image analysis
+* [Experimental] Multi-agent collaboration, with o1 doing the planning, and regular Claude/GPT-4o doing the execution.
 
-## Usage
-
-1. Copy all files from this repository to your project folder
-2. For Cursor users: The `.cursorrules` file will be automatically loaded
-3. For Windsurf users: Use both `.windsurfrules` and `scratchpad.md` for similar functionality
-
-## Update: Multi-Agent Support (Experimental)
-
-This project includes experimental support for a multi-agent system that enhances Cursor's capabilities through a two-agent architecture:
-
-### Architecture
-
-- **Planner** (powered by OpenAI's o1 model): Handles high-level analysis, task breakdown, and strategic planning
-- **Executor** (powered by Claude): Implements specific tasks, runs tests, and handles implementation details
-
-[Actual .cursorrules file](https://github.com/grapeot/devin.cursorrules/blob/multi-agent/.cursorrules#L3)
-
-### Key Benefits
-
-1. **Enhanced Task Quality**
-   - Separation of strategic planning from execution details
-   - Better cross-checking and validation of solutions
-   - Iterative refinement through Planner-Executor communication
-
-2. **Improved Problem Solving**
-   - Planner can design comprehensive test strategies
-   - Executor provides detailed feedback and implementation insights
-   - Continuous communication loop for optimization
-
-### Real-World Example
-
-A real case study of the multi-agent system debugging the DuckDuckGo search functionality:
+## Why This Matters
 
-1. **Initial Analysis**
-   - Planner designed a series of experiments to investigate intermittent search failures
-   - Executor implemented tests and collected detailed logs
+Devin impressed many by acting like an intern who writes its own plan, updates that plan as it progresses, and even evolves based on your feedback. But you don’t need Devin’s $500/month subscription to get most of that functionality. By customizing the .cursorrules file, plus a few Python scripts, you’ll unlock the same advanced features inside Cursor.
 
-2. **Iterative Investigation**
-   - Planner analyzed results and guided investigation to the library's GitHub issues
-   - Identified a bug in version 6.4 that was fixed in 7.2
+## Key Highlights
 
-3. **Solution Implementation**
-   - Planner directed version upgrade and designed comprehensive test cases
-   - Executor implemented changes and validated with diverse search scenarios
-   - Final documentation included learnings and cross-checking measures
+1.	Easy Setup
+   
+   Copy the provided config files into your project folder. Cursor users only need the .cursorrules file. It takes about a minute, and you’ll see the difference immediately.
 
-### Usage
+2.	Planner-Executor Multi-Agent (Experimental)
 
-To use the multi-agent system:
+   Our new [multi-agent branch](https://github.com/grapeot/devin.cursorrules/tree/multi-agent) introduces a high-level Planner (powered by o1) that coordinates complex tasks, and an Executor (powered by Claude/GPT) that implements step-by-step actions. This two-agent approach drastically improves solution quality, cross-checking, and iteration speed.
 
-1. Switch to the `multi-agent` branch
-2. The system will automatically coordinate between Planner and Executor roles
-3. Planner uses `tools/plan_exec_llm.py` for high-level analysis
-4. Executor implements tasks and provides feedback through the scratchpad
+3.	Extended Toolset
 
-This experimental feature transforms the development experience from working with a single assistant to having both a strategic planner and a skilled implementer, significantly improving the depth and quality of task completion.
+   Includes:
+   
+   * Web scraping (Playwright)
+   * Search engine integration (DuckDuckGo)
+   * LLM-powered analysis
 
-## Setup
+   The AI automatically decides how and when to use them (just like Devin).
 
-1. Create Python virtual environment:
-```bash
-# Create a virtual environment in ./venv
-python3 -m venv venv
+4.	Self-Evolution
 
-# Activate the virtual environment
-# On Unix/macOS:
-source venv/bin/activate
-# On Windows:
-.\venv\Scripts\activate
-```
-
-2. Configure environment variables:
-```bash
-# Copy the example environment file
-cp .env.example .env
-
-# Edit .env with your API keys and configurations
-```
-
-3. Install dependencies:
-```bash
-# Install required packages
-pip install -r requirements.txt
-
-# Install Playwright's Chromium browser (required for web scraping)
-python -m playwright install chromium
-```
-
-## Tools Included
-
-- Web scraping with JavaScript support (using Playwright)
-- Search engine integration (DuckDuckGo)
-- LLM-powered text analysis
-- Process planning and self-reflection capabilities
-
-## Testing
-
-The project includes comprehensive unit tests for all tools. To run the tests:
-
-```bash
-# Make sure you're in the virtual environment
-source venv/bin/activate  # On Windows: .\venv\Scripts\activate
-
-# Run all tests
-PYTHONPATH=. python -m unittest discover tests/
-```
-
-The test suite includes:
-- Search engine tests (DuckDuckGo integration)
-- Web scraper tests (Playwright-based scraping)
-- LLM API tests (OpenAI integration)
+   Whenever you correct the AI, it can update its “lessons learned” in .cursorrules. Over time, it accumulates project-specific knowledge and gets smarter with each iteration. It makes AI a coachable and coach-worthy partner.
+	
+## Usage
 
-## Background
+1.	Copy this repository’s contents into your Cursor or Windsurf project.
+2.	For Cursor, .cursorrules is automatically loaded. For Windsurf, add .windsurfrules plus the Scratchpad for updates.
+3.	Adjust .env with your own API keys, run pip install -r requirements.txt, and you’re all set.
+4.	Start exploring advanced tasks—such as data gathering, building quick prototypes, or cross-referencing external resources—in a fully agentic manner.
 
-For detailed information about the motivation and technical details behind this project, check out the blog post: [Turning $20 into $500 - Transforming Cursor into Devin in One Hour](https://yage.ai/cursor-to-devin-en.html)
+## Want the Details?
 
-## License
+Check out our [blog post](https://yage.ai/cursor-to-devin-en.html) on how we turned $20 into $500-level AI capabilities in just one hour. It explains the philosophy behind process planning, self-evolution, and fully automated workflows. You’ll also find side-by-side comparisons of Devin, Cursor, and Windsurf, plus a step-by-step tutorial on setting this all up from scratch.
 
-MIT License
+License: MIT