Cursor Local Dev Loop

Establish a productive daily development workflow using Cursor's AI features at each stage of the code-write-test-commit cycle.

The AI-Augmented Development Loop

┌─────────────────────────────────────────────────────────────┐
│  1. PLAN        →  Chat (Cmd+L) with @Codebase, @Docs      │
│  2. SCAFFOLD    →  Composer (Cmd+I) for new files           │
│  3. IMPLEMENT   →  Tab completion for line-by-line coding   │
│  4. REFINE      →  Inline Edit (Cmd+K) for targeted fixes  │
│  5. TEST        →  Chat to generate tests, terminal to run  │
│  6. COMMIT      →  AI-generated commit messages             │
│  7. REVIEW      →  @Git for branch diff review              │
└─────────────────────────────────────────────────────────────┘

Stage 1: Plan (Chat)

Start each task by discussing architecture with Chat:

@Codebase @Docs Prisma

I need to add a "favorites" feature where users can bookmark products.
What's the best approach given our current data model and API structure?
Consider: database schema, API endpoints, and frontend hooks.

Chat excels at:

• Architecture decisions before writing code
• Evaluating trade-offs (SQL join table vs JSON array, REST vs GraphQL)
• Understanding existing patterns via @Codebase

Stage 2: Scaffold (Composer)

Once the plan is clear, use Composer for multi-file generation:

@src/api/users/route.ts @prisma/schema.prisma

Create the favorites feature:
1. prisma/schema.prisma: Favorite model (userId, productId, createdAt)
2. src/api/favorites/route.ts: GET (list user favorites), POST (add), DELETE (remove)
3. src/services/favorite.service.ts: FavoriteService with Prisma operations
4. src/hooks/useFavorites.ts: React hook with optimistic updates
Follow existing patterns from the users API.

Tip: Reference existing files with @ so Composer replicates your patterns instead of inventing new ones.

Stage 3: Implement (Tab Completion)

With scaffolded files open, use Tab for implementation details:

// Open favorite.service.ts and start typing:
async toggleFavorite(userId: string, productId: string

// Tab completes the full method:
async toggleFavorite(userId: string, productId: string): Promise<Favorite | null> {
  const existing = await this.prisma.favorite.findUnique({
    where: { userId_productId: { userId, productId } },
  });
  if (existing) {
    await this.prisma.favorite.delete({ where: { id: existing.id } });
    return null;
  }
  return this.prisma.favorite.create({ data: { userId, productId } });
}

Workflow tips for Tab:

• Open related files in tabs (service, types, API route) -- Tab reads open tabs for context
• Write type signatures first -- Tab generates better bodies when types are explicit
• Accept partially with Cmd+→ when the suggestion is 80% right

Stage 4: Refine (Inline Edit)

For targeted improvements, select code and use Cmd+K:

Select the toggleFavorite method → Cmd+K:
"Add input validation: userId and productId must be non-empty strings.
 Add error handling for database connection failures.
 Return a Result type instead of throwing."

Other common Cmd+K workflows:

• "Add JSDoc comments" on a function
• "Convert to async/await" on a Promise chain
• "Add null checks" on a code block
• "Optimize this query" on a database call

Stage 5: Test (Chat + Terminal)

Generate tests via Chat:

@src/services/favorite.service.ts @tests/services/user.service.test.ts

Generate vitest tests for FavoriteService following the same patterns as
user.service.test.ts. Cover: addFavorite, removeFavorite, toggleFavorite,
getFavorites with pagination. Mock Prisma client.

Run tests in the integrated terminal:

# Cmd+` to open terminal
npm test -- --watch src/services/favorite.service.test.ts

If tests fail, paste the error into Chat:

@src/services/favorite.service.ts
This test is failing with: "Expected null but received undefined"
[paste test output]
What's wrong?

Stage 6: Commit (AI Messages)

Use Cursor's Source Control panel (Cmd+Shift+G):

1. Stage changed files
2. Click the sparkle icon (AI) next to the commit message input
3. Cursor generates a commit message from the diff:

feat: add favorites feature with toggle, pagination, and optimistic updates

- Add Favorite model to Prisma schema with userId/productId unique constraint
- Create REST API endpoints (GET, POST, DELETE) for /api/favorites
- Implement FavoriteService with toggleFavorite and paginated listing
- Add useFavorites React hook with optimistic UI updates

Stage 7: Review (@Git)

Before pushing, review your full branch diff:

@Git

Review all changes in this branch compared to main.
Check for:
- Missing error handling
- Type safety issues
- Potential N+1 query problems
- Any hardcoded values that should be environment variables

@Git includes the branch diff in context, giving the AI a complete view of all your changes.

Daily Efficiency Tips

Session Management

Morning startup:
1. cursor .                          # Open project
2. Wait for "Indexed" in status bar  # Indexing complete
3. Cmd+Shift+G → git pull           # Sync with team
4. Cmd+L → "What changed yesterday? @Git"

Task switching:
- Start a new Chat (Cmd+N) for each task
- Do NOT continue a 20-turn conversation on a new topic

Keyboard-Driven Flow

Minimize mouse usage:

Cmd+P          →  Open any file by name
Cmd+Shift+P    →  Run any command
Cmd+L          →  Ask AI anything
Cmd+K          →  Edit selected code
Cmd+I          →  Multi-file changes
Cmd+`          →  Toggle terminal
Cmd+B          →  Toggle sidebar
Cmd+Shift+G    →  Git panel

Project Rules for Consistency

Create .cursor/rules/dev-standards.mdc:

---
description: "Development standards for all code"
globs: ""
alwaysApply: true
---
- Run `npm test` before committing
- All new functions need JSDoc comments
- Use Conventional Commits format
- No console.log in committed code (use proper logger)

Enterprise Considerations

• Reproducible workflows: Document the AI-augmented workflow in team runbooks
• Code review: AI-generated code still needs human review -- Composer output is a first draft
• Onboarding: New team members can use Chat with @Codebase to explore unfamiliar code
• Metrics: Track time-to-feature before and after Cursor adoption to quantify ROI

Resources

• Cursor Feature Overview
• Keyboard Shortcuts
• Context Management