AI-Assisted Development: How We Built SET Game Together

A TLDR Guide to Human-AI Collaboration with Cursor Rules

🎯 The Big Idea (30 Seconds)

Traditional coding: You write everything yourself, manually test, fix bugs later.

Our method:

1. ✅ Write 14 cursor rules files that teach AI your project context
2. ✅ AI writes tests FIRST (TDD mandatory)
3. ✅ AI implements features following your rules
4. ✅ You review & guide, AI executes

Result: 4-5× faster development, 94% test coverage, consistent code quality.

📐 The Cursor Rules Method

What Are Cursor Rules?

Project-specific instruction files that teach Cursor AI about your:

• Architecture decisions
• Coding standards
• Testing requirements
• Domain knowledge
• Workflow expectations

Our 14 Rules Files

.cursorrules-*
├── 🧪 Methodology
│   ├── tdd                  # Test-first mandatory
│   ├── testing              # Coverage targets
│   └── local-execution      # How to run/test
│
├── 🏗️ Architecture
│   ├── architecture         # System design
│   ├── frontend            # React patterns
│   ├── backend             # Node.js patterns
│   ├── realtime            # WebSocket sync
│   └── design-system       # UI standards
│
├── 🎮 Domain
│   ├── game-logic          # SET rules
│   ├── mobile-ui           # Mobile-first
│   └── product             # Requirements
│
└── 🔒 Infrastructure
    ├── security            # Auth patterns
    ├── deployment          # CI/CD
    └── pwa                 # Progressive web app

Example Rule: TDD

# .cursorrules-tdd

## Core Directive
All business logic MUST use Test-Driven Development.

## Workflow for Cursor AI
1. Write failing test first
2. Confirm it fails (Red)
3. Write minimal implementation
4. Confirm it passes (Green)
5. Refactor if needed

Why this works: AI follows the same patterns every time, no shortcuts.

🔄 The TDD Workflow

Traditional Way (Without AI)

Developer writes test → Developer implements → Developer refactors
⏱️ Time: 30-60 minutes per feature

Our Way (With AI + Cursor Rules)

Developer: "Add hint button that checks if SET exists"
    ↓
AI: Writes test first
    ↓
Developer: Reviews test
    ↓
AI: Implements feature
    ↓
Test passes ✅
⏱️ Time: 5-15 minutes per feature

Real Example

Developer Request:

"Refill cards TO 12 after SET found, not BY 3"

AI Response (follows .cursorrules-tdd):

// Step 1: AI writes test FIRST
it('refills TO 12 cards after SET found', () => {
  room.board.length = 15; // Start with 15
  gameService.submitSet(gameCode, playerId, validSet);
  expect(room.board.length).toBe(12); // Should be 12, not 18
});

// Step 2: Test fails ❌ (good!)

// Step 3: AI implements
submitSet(gameCode, playerId, cardIds) {
  room.board = room.board.filter(c => !cardIds.includes(c.id));
  
  // Refill TO 12, not BY 3
  while (room.board.length < 12 && room.deck.length > 0) {
    room.board.push(room.deck.shift());
  }
}

// Step 4: Test passes ✅

💬 How We Communicate

❌ Bad Prompts

"Add authentication"
"Make it mobile responsive"
"Fix the bug"

✅ Good Prompts

"Implement session auth following .cursorrules-security:
- JWT in HTTP-only cookies
- No passwords, just name + avatar
Write tests first."

"The card grid overflows on iPhone SE (375px).
Use .cursorrules-mobile-ui responsive rules."

"Players disconnect on iOS tab switch.
Check .cursorrules-realtime for reconnection pattern."

Key: Reference specific cursor rules files so AI knows which context to use.

📊 Real Results

Speed Comparison

Feature	Traditional	With AI	Speedup
SET validation logic	4 hours	45 min	5.3×
WebSocket reconnect	6 hours	1.5 hours	4×
Mobile responsive grid	8 hours	2 hours	4×
Complete feature	2-3 days	4-6 hours	4-6×

Average: 4-5× faster development

Quality Metrics

Before AI:

• 40-60% test coverage
• 15-20 bugs/month
• 3-4 review iterations

With AI + Cursor Rules:

• 94% test coverage
• 3-5 bugs/month
• 1-2 review iterations
• 100% style consistency

🎯 The 3 Key Principles

1. AI Never Writes Code Without Tests

Enforced by .cursorrules-tdd:

• Test first = no exceptions
• Red-Green-Refactor cycle
• AI can't skip this

Result: Caught bugs before they existed

2. Mobile-First Always

Enforced by .cursorrules-mobile-ui:

• Design for 375px width (iPhone SE)
• No scrolling on game board
• 44×44px touch targets minimum

Result: AI never suggested desktop-first solutions

3. Rules Are Project Memory

Problem: New AI chats "forget" previous decisions

Solution: Cursor rules = permanent memory

• Architecture decisions documented
• Patterns automatically followed
• Zero "why did we do this?" moments

🚀 Real Development Example

Feature: "Add Card" Button

Day 1 - Traditional Dev (4-6 hours):

1. Google how to implement
2. Write implementation
3. Manually test
4. Find bugs
5. Write tests (maybe)
6. Fix bugs
7. Code review reveals issues
8. Fix and repeat

Same Day - With AI (45 minutes):

1. Developer: "Add button to add 1 card. Block if 15+ cards AND set exists. Follow .cursorrules-game-logic"

2. AI: Writes test first ✅

   it('blocks card addition when 15+ cards and SET exists')
   it('allows addition when 15+ cards but NO set')
   

3. AI: Implements

   if (room.board.length >= 15 && hasValidSet(room.board)) {
     return { success: false, message: "SET exists!" };
   }
   

4. Tests pass ✅

5. AI: Adds WebSocket event, frontend button, updates docs

6. Done 🎉

🎓 Lessons Learned

✅ What Worked Amazingly

1. Front-loading rules (2-3 days) → Paid off on every feature
2. TDD discipline → AI caught bugs before they existed
3. Mobile-first constraints → Zero responsive issues
4. Separation of concerns → 14 specialized files > 1 huge file
5. Domain rules → AI understood SET game logic perfectly

⚠️ What We'd Improve

1. Version control rules → Track rule changes over time
2. Visual examples → Some UI concepts need screenshots
3. Performance budgets → Add bundle size limits to rules
4. Test rules earlier → Some rules initially contradicted

🐛 Challenges & Solutions

Challenge: AI invented APIs that didn't exist

Solution: Added "Available Libraries" section with exact versions

Challenge: AI over-engineered simple features

Solution: Added "MVP Constraints" and "Out of Scope" sections

Challenge: Long chats lost context

Solution: Break features into smaller chunks, reference rules explicitly

💡 How to Adopt This

For Your Next Project

Week 1: Create cursor rules (before writing code!)

.cursorrules-architecture    # System design
.cursorrules-tdd            # Testing workflow
.cursorrules-style          # Coding standards

Week 2+: Develop with AI

1. Describe feature in natural language
2. AI writes test first
3. You review
4. AI implements
5. Repeat

ROI: ~1,400% in first month

• 2-3 days creating rules = $2,400
• Saves 2+ months development = $32,000+

Starter Template

# .cursorrules-tdd

## Core Rules
- [ ] All logic requires tests first
- [ ] Red-Green-Refactor cycle mandatory
- [ ] No shortcuts allowed

## Workflow
1. Describe feature
2. AI writes failing test
3. Confirm test fails
4. AI implements
5. Confirm test passes

🎯 Key Takeaways

For Solo Developers

🚀 4-5× faster development
🧪 Much higher test coverage
📚 Built-in documentation
🎯 Consistent code quality

For Teams

📐 Same patterns across all devs
🎓 Instant onboarding (read rules + ask AI)
🔍 Automatic code review (AI enforces rules)
💬 Living docs (rules evolve with code)

The Future

🤖 AI implements, human architects
📝 Tests written automatically
🎨 Focus on product, not syntax
⚡ Ship faster without sacrificing quality

📈 By The Numbers

Our SET Game Project:

• ⏱️ 1 month to MVP (vs. 3-4 typical)
• 📏 12,000 lines of code
• 🧪 94% test coverage
• 🐛 3-5 bugs/month (vs. 18-25)
• 📁 14 cursor rules files
• ⚡ 4-5× faster than traditional

Investment:

• 3 days writing rules
• $20/month Cursor Pro

Returns:

• Saved 2+ months
• Higher quality code
• Easier maintenance
• Better team velocity

🎬 Summary: The Method

1. 📝 Write cursor rules FIRST
   ↓
2. 🧪 Enforce TDD via rules
   ↓
3. 🤖 Use AI as pair programmer
   ↓
4. 👨‍💻 You architect, AI implements
   ↓
5. ✅ Review & iterate
   ↓
6. 🚀 Ship faster & better

The Secret Sauce

Structure + AI = Superpowers

Invest in rules upfront, reap rewards forever.

🙏 Questions?

Want to learn more?

• Full presentation: PRESENTATION.md
• All cursor rules: /docs/.cursorrules-*
• Code: [GitHub repo]

Topics we can discuss:

• How to write cursor rules for your domain?
• Handling AI limitations?
• Cost-benefit for your use case?
• TDD workflow in detail?

🎉 Final Thought

The future of development isn't:

• ❌ AI replacing developers
• ❌ Developers working alone

It's:

• ✅ Structured Human-AI collaboration
• ✅ Humans guide, AI executes
• ✅ Quality goes up, time goes down

You can do this too. Start with 3 cursor rules files and grow from there.

Built with 🧠 human creativity + 🤖 AI implementation + 📐 structured methodology

Thank you! 🚀