Cursor + AI Agent Marketplace: AI-First IDE Integration

Difficulty: Beginner-Intermediate | Prerequisites: Cursor IDE installed

TL;DR: Map marketplace rules to .cursor/rules/*.mdc files with glob patterns. Use Composer for multi-step agent workflows. Create Notepads as reusable skill templates. Auto-generate everything with marketplace generate-cursor-rules.

What is Cursor?

Cursor is a fork of VS Code built specifically for AI-assisted development. It offers tighter AI integration than traditional IDEs, with features designed for conversational coding.

Key differentiators for marketplace integration:

• Rules: project-level instructions in .cursor/rules/ (replaces .cursorrules)

• Composer: agent mode for multi-file, multi-step tasks

• Chat: conversational AI with full codebase context

• MCP Servers: Model Context Protocol support

• @-mentions: reference files, docs, or web content in prompts

• Notepads: reusable prompt templates

Scenario 1: Marketplace Rules as Cursor Rules

Situation: You want all Cursor AI suggestions to follow your org's standards.

Map marketplace rules to .cursor/rules/

Create individual rule files that reference marketplace content:

.cursor/rules/security.mdc:

---
description: Organization security rules from AI Agent Marketplace
globs: ["**/*.ts", "**/*.py", "**/*.cs", "**/*.java"]
alwaysApply: true
---

# Security Rules

Follow these security rules for ALL code suggestions:

1. Never suggest hardcoded secrets, API keys, or credentials
2. Use parameterized queries for all database operations
3. Validate all external input at system boundaries
4. Use HTTPS for all external connections
5. Never log credentials, even in debug mode
6. Use secure defaults (encrypted connections, restrictive CORS)

When reviewing code, flag as CRITICAL:
- SQL injection vectors
- Command injection vectors
- XSS opportunities
- Hardcoded credentials
- Disabled security features

.cursor/rules/coding-standards.mdc:

---
description: Organization coding standards from AI Agent Marketplace
globs: ["**/*"]
alwaysApply: true
---

# Coding Standards

- Python: snake_case, type hints required
- TypeScript: camelCase, strict mode, no `any` types
- Functions under 50 lines
- No commented-out code
- Error cases handled explicitly
- Tests for all new functionality
- Public APIs need doc comments

.cursor/rules/project-context.mdc:

---
description: Project-specific context and patterns
globs: ["**/*"]
alwaysApply: true
---

# Project Context

- Python 3.11, FastAPI framework
- PostgreSQL with SQLAlchemy ORM
- Tests: pytest with fixtures in tests/conftest.py
- Deployment: GitHub Actions to Azure Container Apps
- Auth: Azure AD JWT tokens

Auto-generate Cursor rules from marketplace

Add to your marketplace.sh:

cmd_generate_cursor_rules() {
  mkdir -p .cursor/rules

  for rule_file in .ai-marketplace/rules/*.md; do
    local name=\((basename "\)rule_file" .md)
    local output=".cursor/rules/${name}.mdc"

    cat > "$output" <<EOF
---
description: Org rule: ${name} (from AI Agent Marketplace)
globs: ["**/*"]
alwaysApply: true
---

\((cat "\)rule_file")
EOF
    echo "Generated $output"
  done
}

Scenario 2: Composer for Multi-Step Agent Workflows

Situation: You want to use the marketplace's PR review agent in Cursor's Composer mode.

Using Composer with marketplace skills

Open Composer (Cmd+I / Ctrl+I) and provide the agent workflow:

Review all files changed in my current branch. For each file:

1. Check for security issues:
   - Hardcoded secrets
   - SQL/command injection
   - XSS vulnerabilities
   - Insecure configurations

2. Check against coding standards:
   - Naming conventions
   - Function length
   - Error handling
   - Test coverage

3. Check for correctness:
   - Logic errors
   - Edge cases
   - Race conditions

Format findings as:
### [SEVERITY] file.ext:line
**Issue**: description
**Fix**: suggestion

Composer will autonomously navigate your codebase, read changed files, and produce a structured review.

Scenario 3: Notepads as Reusable Marketplace Skills

Situation: You want marketplace skills available as reusable templates in Cursor.

Create Notepads from skills

In Cursor, go to the Notepads panel and create entries that mirror marketplace skills:

Notepad: "Code Review"

Review the selected code for:
1. Security issues (OWASP top 10)
2. Coding standard violations
3. Performance concerns
4. Missing error handling
5. Missing tests

Format: [SEVERITY] file:line - issue - fix suggestion

Notepad: "Write Tests"

Generate tests for the selected code following these rules:
- Use pytest with fixtures
- One test function per behavior
- Name: test_<scenario>_<condition>_<expected_result>
- Include edge cases and error cases
- Mock external dependencies, not internal logic

Reference notepads in chat with @notepad-name.

Scenario 4: MCP Servers for Organizational Context

Situation: You want Cursor to access Azure DevOps and internal documentation.

Configure in Cursor settings

Go to Cursor Settings > MCP and add servers:

{
  "mcp": {
    "servers": {
      "ado": {
        "command": "agency",
        "args": ["mcp", "ado"]
      },
      "internal-docs": {
        "command": "agency",
        "args": ["mcp", "docs"]
      },
      "kusto": {
        "command": "agency",
        "args": ["mcp", "kusto"]
      }
    }
  }
}

Now in Cursor Chat:

What work items are in the current sprint for my team?
Search our internal docs for the retry policy guidelines
Query auth service error rates for the last hour

Scenario 5: Greenfield with Full Marketplace

mkdir new-service && cd new-service
git init

# Install marketplace
marketplace install starter-kit
marketplace install pr-review-agent

# Generate Cursor rules from marketplace
marketplace generate-cursor-rules

# Open in Cursor
cursor .

Cursor immediately picks up all the rules and your AI is org-standards-aware from the first keystroke.

Key Cursor Concepts for the Marketplace

Tips for Marketplace Authors Targeting Cursor

1. Use .mdc format for rules. This is Cursor's native format with frontmatter for globs and conditions

2. Glob patterns matter. Scope rules to relevant file types for efficiency

3. Design for Composer. Write agent workflows as step-by-step instructions that Composer can follow

4. Create Notepad templates. These are the skill equivalent in Cursor's UI

5. Keep rules concise. Cursor has context limits; prioritize high-impact rules

6. Test with @codebase. Verify rules are picked up when referencing the full codebase

Quick Setup Checklist

# 1. Initialize marketplace
cd /path/to/your/project
marketplace init

# 2. Install plugins
marketplace install pr-review-agent
marketplace install test-writer

# 3. Generate Cursor-specific rules
marketplace generate-cursor-rules

# 4. (Optional) Add MCP servers via Cursor Settings > MCP

# 5. Open in Cursor
cursor .

# 6. Commit
git add .ai-marketplace/ .cursor/
git commit -m "Add AI Agent Marketplace for Cursor"

• .cursor/rules/*.mdc files generated with org rules

• .ai-marketplace/rules/ present

• MCP servers configured in Cursor Settings (optional)

• Tested with a query in Cursor Chat

• Created Notepads for frequently-used skills (optional)