VIBE GAME TIME: A Cursor Challenge contest/game/call_to_action

[SoMaCoSF]

Would you like to play a game?

[*I am vibing through an idea that came to me walking in the park today… What do you think of the following vibing context:

Let me know what you think (this is a super cheesy Claude produced statement, but Ive been building out the project in Cursor… and I think its a nifty idea. and I’d like your inout/hate on the idea.

---

============

---

Introducing CursorX Challenge: The Future of AI-Augmented Coding Competitions

Hey Cursor community!

I’m excited to share a new competition format I’ve been developing that showcases what makes our community special - CursorX Challenge!

What is it?

CursorX Challenge is a series of coding competitions where teams solve problems by leveraging Cursor’s AI agents. Unlike traditional hackathons, these challenges specifically focus on how effectively teams can collaborate with AI to build amazing solutions.

The secret sauce? Teams must document their interactions with Cursor’s AI, sharing prompts and strategies that led to breakthroughs. It’s not just about the end product - it’s about the journey of human-AI collaboration.

How it works:

1. Challenge repos are created with specific goals across various domains (web, data science, games, etc.)
2. Teams register and get access to these repos
3. Collaborative development happens using Cursor’s AI capabilities
4. Solutions are submitted as PRs to the challenge repo
5. Public + expert judging determines winners based on functionality, innovation, and AI collaboration quality

Why this is different:

• Celebrates both technical skill AND effective AI collaboration
• Creates a library of proven AI interaction patterns
• Builds community knowledge around “AI-native” development
• Pushes the boundaries of what’s possible with current tools

First challenge coming soon!

I’m finalizing the framework and will announce our first challenge domain next week. Categories we’re considering include:

• Web app development
• Data visualization
• Game mechanics
• AI systems
• Developer tools

Who’s interested in participating? Would love to gauge interest and hear what challenge domains would excite you most!

Also looking for volunteers to help judge, provide feedback on the framework, or sponsor prizes for winning teams.

Let’s show the world what the Cursor community can build when human creativity meets AI assistance!

#CursorXChallenge #AICoderCompetition #CursorIDE

---

CursorX Challenge - Development Diary

Project Overview

This diary tracks the implementation of the CursorX Challenge repository - a framework for AI-powered coding competitions using Cursor IDE agents.

Development Log

[2023-04-04] - Project Initialization

• Created development_diary.md
• Planned SQLite database structure for challenge metrics tracking
• Designed database schema for comprehensive challenge management

Database Architecture Decision

The SQLite database will serve as the control plane for the CursorX Challenge, tracking:

• Challenges and their lifecycle
• Teams and participants
• Submissions and evaluations
• AI agent usage metrics
• Judging scores and feedback
• Timeline events

This approach allows for comprehensive metrics and analytics throughout the challenge lifecycle.

[2023-04-04] - Database and Scripts Implementation

• Created SQLite database schema with tables for:

  • Challenges: store information about each coding competition
  • Teams: participant teams and their members
  • Participants: individual competitor details
  • Challenge_Teams: many-to-many relationship between challenges and teams
  • Submissions: team solution submissions
  • Judging_Criteria: evaluation metrics for each challenge
  • Scores: judge evaluations of submissions
  • AI_Usage_Metrics: detailed tracking of AI agent usage
  • Events: timeline and activity tracking for challenges

• Implemented PowerShell scripts for database operations:

  • scripts/db/initialize_database.ps1: Sets up the SQLite database and schema
  • scripts/db/generate_metrics.ps1: Generates reports on challenge participation and AI usage
  • scripts/db/track_ai_usage.ps1: Tracks AI agent usage during challenges

• Created challenge management script:

  • scripts/setup_challenge.ps1: Sets up a new challenge with database entries and file structure

Database Schema Details

Core Tables

1. challenges: Stores information about each coding competition

   • Primary fields: challenge_id, title, description, category, start_date, end_date, status

2. teams: Records teams participating in challenges

   • Primary fields: team_id, team_name

3. participants: Stores individual competitor information

   • Primary fields: participant_id, github_username, email, display_name, team_id, role

4. submissions: Tracks solution submissions from teams

   • Primary fields: submission_id, challenge_id, team_id, repository_url, commit_hash, submission_time, status

Evaluation Tables

5. judging_criteria: Defines evaluation metrics for challenges

   • Primary fields: criteria_id, challenge_id, name, description, weight, max_score

6. scores: Records judge evaluations of submissions

   • Primary fields: score_id, submission_id, criteria_id, judge_id, score, feedback

Metrics Tables

7. ai_usage_metrics: Tracks AI agent usage during challenges

   • Primary fields: metric_id, team_id, challenge_id, timestamp, prompt_count, tokens_used, feature_used, context_size, action_taken

8. events: Timeline and activity tracking for challenges

   • Primary fields: event_id, challenge_id, team_id, event_type, description, timestamp, metadata

[2023-04-04] - Challenge Management Workflows Implementation

• Implemented team management script:

  • scripts/register_team.ps1: Registers teams for challenges and adds participants

• Created submission and evaluation scripts:

  • scripts/record_submission.ps1: Records team solution submissions
  • scripts/score_submission.ps1: Manages the scoring of submissions by judges

• Key features of workflow scripts:

  • Comprehensive logging to track all actions
  • Event-based tracking for comprehensive timeline
  • Interactive and batch modes for different usage scenarios
  • Validation to ensure data integrity
  • JSON metadata for flexible data storage

Challenge Workflow Architecture

The implemented scripts support the complete challenge lifecycle:

1. Challenge Setup

   • Create challenge in database
   • Generate directory structure and configuration files
   • Define judging criteria

2. Team Registration

   • Register teams in the system
   • Add team members with roles (leader/member)
   • Track team participation across challenges

3. Competition Phase

   • Monitor AI usage during development
   • Track prompts, tokens, and AI features utilized
   • Record events for timeline analysis

4. Submission Phase

   • Record solution submissions with metadata
   • Track repository URLs and commit hashes
   • Maintain submission status

5. Evaluation Phase

   • Support interactive judging workflow
   • Score submissions based on defined criteria
   • Provide weighted scoring with feedback
   • Generate evaluation reports

6. Analysis Phase

   • Generate comprehensive metrics
   • Analyze team performance and AI utilization
   • Create reports in various formats (Console, CSV, JSON)

[2023-04-04] - Documentation and Example Data

• Created comprehensive README documentation:

  • README.md: Main project documentation
  • control_plane/README.md: Control plane documentation

• Added example data and logs:

  • logs/setup_example.log: Example log file showing system operations
  • control_plane/metrics/ai_usage_example.json: Sample AI usage metrics
  • control_plane/metrics/scoring_example.json: Sample scoring data

• Created placeholder directories for project structure

Summary of Accomplishments

We have successfully implemented a comprehensive framework for running AI-augmented coding competitions using the CursorX Challenge system. Key accomplishments include:

1. Database Control Plane: Designed and implemented a SQLite database that serves as the central management system for the entire challenge lifecycle.

2. Script Infrastructure: Created a suite of PowerShell scripts that handle all aspects of challenge management, from setup to evaluation.

3. AI Metrics Tracking: Implemented detailed tracking of AI agent usage, allowing for comprehensive analysis of how teams leverage AI assistance.

4. Evaluation System: Developed a flexible scoring system that allows judges to evaluate submissions based on customizable criteria.

5. Reporting Capabilities: Created tools to generate detailed metrics and reports in various formats for challenge analysis.

6. Event Timeline: Implemented an event-driven system to track all activities throughout a challenge.

7. Documentation: Provided comprehensive documentation for all aspects of the system.

The CursorX Challenge framework is now ready for implementation and can be extended with additional features as needed for specific competition requirements.

Next Steps

• Create team registration and management scripts
• Implement submission tracking and evaluation system
• Develop user interface for challenge administrators
• Add visualization components for metrics and analytics
• Create documentation for all components
• Develop example challenges demonstrating the framework

---

Interactive Dashboard Challenge

Overview

Build a responsive, interactive web dashboard that visualizes and analyzes data from multiple sources. This challenge tests your ability to create a modern web application with a focus on data visualization, interactivity, and user experience.

Challenge Details

• Category: Web Development
• Difficulty: Medium
• Duration: 14 days
• Start Date: 2023-06-01
• End Date: 2023-06-15

Objectives

Create a web dashboard that:

1. Fetches data from at least two different APIs or data sources
2. Visualizes the data in at least three different chart types
3. Allows users to filter and interact with the data
4. Provides insights based on the data analysis
5. Presents a polished, responsive user interface
6. Implements proper error handling and loading states

Requirements

Functional Requirements

1. Data Retrieval

   • Fetch data from at least two public APIs or provided datasets
   • Implement error handling for API failures
   • Include loading indicators during data fetching

2. Data Visualization

   • Create at least three different types of charts (e.g., bar, line, pie, scatter plot)
   • Ensure visualizations are interactive (tooltips, zooming, filtering)
   • Include a data table view with sorting and filtering capabilities

3. User Interface

   • Design a responsive layout that works on both desktop and mobile devices
   • Create an intuitive navigation system
   • Implement theme switching (light/dark mode)
   • Ensure accessibility compliance (WCAG Level AA)

4. User Interactions

   • Enable filtering data based on multiple parameters
   • Allow saving dashboard configurations
   • Implement data export functionality (CSV, JSON)
   • Add search functionality within the dashboard

Technical Requirements

1. Use one of the following frontend frameworks:

   • React
   • Vue
   • Angular
   • Svelte

2. Implement state management using an appropriate library for your chosen framework

3. Use a modern charting library (e.g., D3.js, Chart.js, Highcharts, etc.)

4. Include comprehensive test coverage (unit and integration tests)

5. Create well-documented, modular, and maintainable code

6. Implement proper performance optimization

Constraints

• You must build the frontend application using one of the specified frameworks
• All data visualization must be implemented on the client side
• You may use CSS frameworks, but custom styling will be evaluated positively
• Your solution must be deployed to a publicly accessible URL
• The application must function without errors in the latest versions of Chrome, Firefox, and Safari

Evaluation Criteria

Criteria	Description	Weight
Functionality	Does the dashboard successfully fetch, display, and allow interaction with data?	30%
Code Quality	Is the code well-structured, documented, and maintainable?	25%
User Experience	Is the interface intuitive, responsive, and visually appealing?	25%
AI Utilization	How effectively was AI used in the development process?	20%

For detailed evaluation guidelines, see evaluation.md.

Getting Started

1. Register your team for the challenge
2. Set up your development environment:
   • Install Cursor IDE
   • Clone this repository
   • Install required dependencies
3. Read through the challenge documentation
4. Start coding!

Submission Guidelines

1. Your final submission must be pushed to this repository before 2023-06-15 at 23:59:59.
2. Ensure your repository includes:
   • Source code
   • Documentation
   • AI Collaboration Log (see below)
   • Installation/deployment instructions

AI Collaboration Log

Throughout the challenge, maintain a log (AI_COLLABORATION.md) documenting how you collaborated with AI tools. Include:

• What features of the AI you used
• Examples of effective prompts
• How AI suggestions were incorporated
• Instances where AI assistance was particularly helpful
• Challenges faced when working with AI

Resources

• Cursor IDE Documentation
• AI Prompting Best Practices
• Public APIs List
• Data Visualization Best Practices

Support

If you have questions or need assistance:

• Open an issue in this repository
• Contact the challenge administrators at [email protected]

License

This challenge and all materials are provided under the MIT License.

[SoMaCoSF]

ManimGL is a thing y’all should get to know:

@cursor Build “ManimGL Commander” Project

OBJECTIVE

Create a new GitHub repository for the “ManimGL Commander” challenge - a Cursor IDE plugin that integrates ManimGL for mathematical visualizations with an intuitive menu system and AI agent communication capabilities.

REPOSITORY SETUP

Basic Information

• Repository Name: manimgl-commander
• Visibility: Public
• Description: “CursorX Challenge: Integrate ManimGL with Cursor IDE for AI-powered mathematical visualizations”
• Initialize with README: Yes
• Add .gitignore: Python
• Add license: MIT

PROJECT STRUCTURE

Please create the following directory structure and files:

manimgl-commander/
├── README.md                    # Main documentation
├── setup.py                     # Installation script
├── requirements.txt             # Dependencies
├── src/
│   ├── __init__.py              # Package initialization
│   ├── plugin/                  # Cursor IDE plugin components
│   │   ├── __init__.py
│   │   ├── integration.py       # Cursor IDE integration
│   │   ├── menu.py              # Menu system UI
│   │   └── commands.py          # Command handling
│   ├── translator/              # NL to ManimGL translation
│   │   ├── __init__.py
│   │   ├── parser.py            # Natural language parsing
│   │   ├── generator.py         # ManimGL code generation
│   │   └── templates/           # Prompt templates
│   │       ├── __init__.py
│   │       ├── calculus.py      # Calculus visualization templates
│   │       ├── linear_algebra.py # Linear algebra visualization templates
│   │       └── geometry.py      # Geometry visualization templates
│   ├── components/              # Reusable ManimGL components
│   │   ├── __init__.py
│   │   ├── coordinate_systems.py # 2D/3D coordinate systems
│   │   ├── functions.py         # Common mathematical functions
│   │   ├── shapes.py            # Geometric shapes
│   │   └── transforms.py        # Transformation animations
│   └── output/                  # Output handling
│       ├── __init__.py
│       ├── renderer.py          # ManimGL rendering wrapper
│       └── exporter.py          # Export functions
├── examples/                    # Example visualizations
│   ├── calculus/                # Calculus examples
│   ├── linear_algebra/          # Linear algebra examples
│   └── geometry/                # Geometry examples
├── tests/                       # Test suite
│   ├── __init__.py
│   ├── test_integration.py
│   ├── test_menu.py
│   └── test_translator.py
├── docs/                        # Documentation
│   ├── installation.md          # Installation guide
│   ├── usage.md                 # Usage instructions
│   ├── menu_system.md           # Menu system documentation
│   ├── prompting.md             # AI prompting guide
│   └── examples.md              # Example walkthroughs
└── assets/                      # UI and visual assets
    ├── icons/                   # Menu icons
    ├── templates/               # UI templates
    └── demo/                    # Demo materials

KEY FILES CONTENT

README.md

Create a comprehensive README that explains:

1. The ManimGL Commander concept and value proposition
2. Installation instructions
3. Quick start guide with example commands
4. Feature overview
5. Menu system explanation
6. AI prompting examples
7. Screenshots/GIFs of example visualizations

src/plugin/integration.py

Initial code framework for integrating with Cursor IDE:

"""
ManimGL Commander - Cursor IDE Integration

This module handles the integration between Cursor IDE and the ManimGL Commander plugin.
It provides the entry points for the plugin and manages communication with the Cursor AI agent.
"""

import os
import sys
from typing import Dict, Any, Optional

class CursorIntegration:
    """Main integration class for Cursor IDE."""
    
    def __init__(self):
        """Initialize the integration with Cursor IDE."""
        self.agent_connected = False
        self.config = self._load_config()
        
    def _load_config(self) -> Dict[str, Any]:
        """Load configuration for the plugin."""
        # Configuration loading logic
        return {}
        
    def register_commands(self) -> None:
        """Register commands with Cursor IDE."""
        # Command registration logic
        pass
        
    def handle_prompt(self, prompt: str) -> Optional[str]:
        """
        Handle a natural language prompt from the Cursor AI agent.
        
        Args:
            prompt: The natural language prompt from the user/agent
            
        Returns:
            Generated ManimGL code or error message
        """
        # Prompt handling logic
        return None
        
    def execute_manimgl(self, code: str) -> bool:
        """
        Execute ManimGL code and render the visualization.
        
        Args:
            code: ManimGL Python code to execute
            
        Returns:
            Success status
        """
        # ManimGL execution logic
        return False

src/plugin/menu.py

Initial code framework for the menu system:

"""
ManimGL Commander - Menu System

This module provides the UI components for the ManimGL Commander plugin,
including the main menu, template selection, and parameter controls.
"""

from typing import Dict, Any, List, Callable

class MenuSystem:
    """Main menu system for ManimGL Commander."""
    
    def __init__(self):
        """Initialize the menu system."""
        self.templates = self._load_templates()
        self.components = self._load_components()
        
    def _load_templates(self) -> Dict[str, Any]:
        """Load visualization templates."""
        # Template loading logic
        return {}
        
    def _load_components(self) -> Dict[str, Any]:
        """Load UI components."""
        # Component loading logic
        return {}
        
    def render_main_menu(self) -> None:
        """Render the main menu UI."""
        # Menu rendering logic
        pass
        
    def handle_template_selection(self, template_id: str) -> None:
        """
        Handle selection of a visualization template.
        
        Args:
            template_id: ID of the selected template
        """
        # Template selection logic
        pass
        
    def get_parameter_values(self) -> Dict[str, Any]:
        """
        Get current values of all parameters from the UI.
        
        Returns:
            Dictionary of parameter values
        """
        # Parameter collection logic
        return {}

src/translator/parser.py

Initial code framework for natural language parsing:

"""
ManimGL Commander - Natural Language Parser

This module handles parsing natural language descriptions into structured
representations that can be used to generate ManimGL code.
"""

from typing import Dict, Any, List, Optional

class MathDescriptionParser:
    """Parser for mathematical visualization descriptions."""
    
    def __init__(self):
        """Initialize the math description parser."""
        self.domain_keywords = self._load_domain_keywords()
        
    def _load_domain_keywords(self) -> Dict[str, List[str]]:
        """Load domain-specific keywords for parsing."""
        # Keyword loading logic
        return {}
        
    def parse(self, description: str) -> Optional[Dict[str, Any]]:
        """
        Parse a natural language description into a structured representation.
        
        Args:
            description: Natural language description of desired visualization
            
        Returns:
            Structured representation of the visualization or None if parsing fails
        """
        # Parsing logic
        return None
        
    def identify_mathematical_objects(self, description: str) -> List[Dict[str, Any]]:
        """
        Identify mathematical objects mentioned in the description.
        
        Args:
            description: Natural language description
            
        Returns:
            List of identified mathematical objects with properties
        """
        # Object identification logic
        return []
        
    def identify_transformations(self, description: str) -> List[Dict[str, Any]]:
        """
        Identify transformations or animations mentioned in the description.
        
        Args:
            description: Natural language description
            
        Returns:
            List of identified transformations with properties
        """
        # Transformation identification logic
        return []

requirements.txt

# Core dependencies
manim==0.17.2
numpy>=1.20.0
scipy>=1.7.0
matplotlib>=3.5.0
pillow>=8.0.0

# Additional libraries
sympy>=1.8.0
networkx>=2.6.0
colour>=0.1.5
tqdm>=4.62.0

# Testing
pytest>=6.2.5
pytest-cov>=2.12.1

# Documentation
sphinx>=4.0.0
sphinx-rtd-theme>=1.0.0

SETUP SCRIPT

setup.py

Create a setup script that:

1. Validates system requirements
2. Installs ManimGL dependencies
3. Configures Cursor IDE integration
4. Sets up the plugin environment

ADDITIONAL REQUIREMENTS

1. Include a section in the README titled “Communicating with the Cursor AI Agent” that explains:

   • How to format prompts for mathematical visualizations
   • Examples of effective prompts
   • How to iteratively refine visualizations through conversation

2. Create a section in the README titled “Menu System Overview” with:

   • Screenshots of the proposed menu layout
   • Explanation of available controls
   • Workflow examples

3. Include an “Examples Gallery” section showing:

   • Screenshots of example visualizations
   • The prompts used to generate them
   • Brief explanations of the mathematical concepts

4. Create detailed documentation on how to extend the system with:

   • New mathematical domains
   • Custom components
   • Additional templates

Please create this repository structure with detailed, high-quality starter code that provides a solid foundation for the ManimGL Commander challenge. Focus on creating a clear architecture that supports natural language to ManimGL translation, an intuitive menu system, and smooth integration with Cursor IDE.

[SoMaCoSF]

Let the Hallucinations begin: