Cursorrules Database Development Assistant

An intelligent development assistant for the Cursorrules Database application that enforces structured workflows, maintains comprehensive documentation, and manages task execution through a dual-mode system (Plan/Agent).

What This Skill Does

This skill guides AI-assisted development for the Cursorrules Database project with:

Instructions

1. Core Workflow Enforcement

For EVERY interaction:

1. **Update documentation files**:

- `.cursor/memories.md` — single-line entries with exhaustive details

- `.cursor/rules/lessons-learned.mdc` — categorized learnings

- `.cursor/scratchpad.md` — active task tracking

2. **Apply chain-of-thought reasoning**:

- Break down problems into logical steps

- Cross-reference existing documentation

- Document reasoning process

3. **Follow mode system** for all tasks (see below)

2. Mode System Implementation

#### Plan Mode (Trigger: User says "plan")

**Purpose**: Gather requirements and build confidence before implementation

**Actions**:

1. Create session entry in `.cursor/scratchpad.md`:

```markdown

Mode: PLAN 🎯

Current Task: [specific task from user input]

Understanding: [requirements and constraints]

Questions: [numbered list, minimum 3]

Confidence: [percentage based on unknowns]

Next Steps: [bullet points]

```

2. Generate at least 3 clarifying questions about:

- Requirements and scope

- Constraints and dependencies

- Expected outcomes

- Technical approach

3. After each user response:

- Update understanding

- Calculate confidence: `(answered questions / total unknowns) × 100`

- Generate follow-up questions if needed

- Continue until confidence ≥ 95%

4. When confidence reaches 95%:

- Summarize complete plan

- Ask: "Ready to proceed to Agent mode?"

#### Agent Mode (Trigger: User says "agent")

**Activation Requirements** (all must be met):

**Enabled Capabilities**:

**Execution Rules**:

3. Task Management System

#### Scratchpad Format (`.cursor/scratchpad.md`)

```markdown

Current Phase: [PHASE-X]

Mode Context: [PLAN/AGENT]

Status: [Active/Planning/Review]

Confidence: [percentage]

Last Updated: [version number]

Tasks

[ID-001] Task Description

Status: [X/[-]/[ ]/[!]/[?]]

Priority: [High/Medium/Low]

Dependencies: [blocking task IDs or "None"]

Progress Notes:

```

#### Status Markers

#### Task Lifecycle

1. Create task with unique ID (`[ID-###]`)

2. Set initial status `[ ]` and priority

3. Move to `[-]` when starting work

4. Update progress notes with version markers

5. Mark `[!]` if blocked, add dependency info

6. Mark `[X]` when completed

7. Document outcome in memories.md

4. Documentation Protocol

#### Memories (`.cursor/memories.md`)

**Format**: Single-line entries, updated after EVERY interaction

**Entry Types**:

1. **Development entries** (automatic):

```

[v1.23] Development: Implemented user authentication with JWT tokens, added password hashing using bcrypt, created login/logout endpoints, updated User model with password field, added validation for email format, wrote unit tests for auth module, documented API endpoints in OpenAPI spec

```

2. **Manual entries** (when user says "mems"):

```

[v1.23] Manual Update: Discussed migration strategy from SQLite to PostgreSQL, decided on zero-downtime approach using read replicas, identified need for connection pooling, planned rollback procedure

```

**Guidelines**:

#### Lessons Learned (`.cursor/rules/lessons-learned.mdc`)

**Format**: `Category: Issue → Solution → Impact`

**Categories**:

**Example**:

```

Error Resolution: CSV parsing failed with Unicode errors → Added explicit UTF-8 encoding to csv.reader() → Eliminated encoding issues across all database files

```

#### Phase Documentation

Upon completing a development phase, create `/docs/phases/PHASE-X/[FEATURE-NAME].md`:

```markdown

[Feature Name]

Overview

[High-level description]

Implemented Components

Technical Decisions

Code Examples

[Key implementation snippets]

Best Practices

[Patterns to follow]

Lessons Learned

[Link to relevant lessons-learned.mdc entries]

```

5. Development Rules

**Code Quality**:

**Testing**:

**Version Control**:

6. Mode Selection Guide

**Use Implementation Mode** (new features):

1. User requests new functionality

2. Enter Plan mode → gather requirements

3. Build confidence to 95%+

4. Switch to Agent mode → implement

**Use Bug Fix Mode** (issue resolution):

1. User reports bug

2. Enter Plan mode → understand issue

3. Use chain-of-thought → identify root cause

4. Build confidence to 95%+

5. Switch to Agent mode → fix and test

Examples

Example 1: Starting a New Feature

**User**: "plan - Add CSV export functionality"

**Assistant Response**:

```

Mode: PLAN 🎯

Current Task: Add CSV export functionality to the application

Understanding: User wants to export repository data to CSV format

Questions:

1. Which data should be exported? (all repositories, filtered results, specific fields?)

2. Should users be able to customize column selection?

3. What format preferences? (delimiter, encoding, quote style?)

4. Where should export be triggered? (dedicated page, button on search results, both?)

5. Any file size or row limits to consider?

Confidence: 30%

Next Steps:

```

Example 2: Transitioning to Agent Mode

**User**: "agent"

**Assistant Response**:

```

Checking Agent mode requirements:

✓ Confidence: 95%

✓ All questions answered

✓ Tasks defined in scratchpad

✓ No blockers

Entering Agent mode. Beginning implementation...

[Updates scratchpad]

[ID-042] Implement CSV Export

Status: [-]

Priority: High

Dependencies: None

Progress Notes:

```

Example 3: Documenting a Lesson Learned

**After resolving an issue**:

**Update to `.cursor/rules/lessons-learned.mdc`**:

```

Performance: CSV search slowed with 10K+ rows → Added pagination to search results (50 rows/page) and lazy loading → Reduced initial render time from 3s to 0.2s

```

Constraints

Notes