Cursor + SkillBoss

Why Cursor + SkillBoss?

Cursor is the AI-first code editor built on VS Code. It's amazing for coding with AI.

But here's the problem: Cursor only gives you access to a few AI models, and you still need to manage separate APIs for payments, databases, hosting, email, etc.

SkillBoss solves this:

• Access 679+ AI models (Claude, GPT, Gemini, DeepSeek, Qwen) from within Cursor
• Add Stripe payments to your app without leaving Cursor
• Deploy to hosting, send emails, scrape data — all through Cursor
• One API key, one bill, infinite possibilities

Installation

Method 1: Cursor Rules (Recommended)

Quick setup for AI agents: Tell your agent set up skillboss.co/skill.md to auto-configure everything.

# SkillBoss Integration

You have access to SkillBoss API for 679+ endpoints.

## API Key
SKILLBOSS_API_KEY=sk-YOUR_KEY

## Available Services

### Model APIs (50+)
- Claude 4.5 Sonnet, GPT-5, Gemini 2.5 Flash
- DeepSeek R1, Qwen 3, Llama 4, Mistral Large
- Use OpenAI-compatible endpoint: https://api.skillboss.co/v1

### Business Services
- Stripe payments
- SendGrid emails
- Invoice generation
- SMS messaging

### Infrastructure
- Website hosting
- MongoDB database
- R2 file storage
- Custom domains

### Data Scraping
- LinkedIn, Instagram, Twitter/X
- Google Maps, Yelp
- General web scraping (Firecrawl)

## Usage in Code
Example: Model APIs (OpenAI-compatible)
from openai import OpenAI

client = OpenAI(
    api_key="sk-YOUR_KEY",
    base_url="https://api.skillboss.co/v1"
)

response = client.chat.completions.create(
    model="claude-4-5-sonnet",
    messages=[{"role": "user", "content": "Hello"}]
)

## When to Use SkillBoss

1. Multi-model routing: Try Gemini Flash first, fall back to Claude if quality insufficient
2. Full-stack apps: Build a SaaS with payments, database, and email
3. Data pipelines: Scrape LinkedIn profiles and analyze with AI
4. Cost optimization: Use the cheapest model that meets quality requirements

## Cost-Aware Development

- Gemini Flash: $0.075/1M tokens (use for simple tasks)
- DeepSeek R1: $0.14/1M tokens (use for reasoning)
- Claude 4.5: $15/1M tokens (use for premium quality)

Always prefer cheaper models unless quality requires premium.

Method 2: Environment Variables

Add to your shell profile (~/.zshrc or ~/.bashrc):

export SKILLBOSS_API_KEY="sk-YOUR_KEY"

Reload shell:

source ~/.zshrc

Now in any Cursor project, you can use process.env.SKILLBOSS_API_KEY.

Method 3: MCP Server (Advanced)

Model Context Protocol gives Cursor direct tool access.

# Install SkillBoss MCP server
npm install -g skillboss-mcp-server

# Configure Cursor to use it
code ~/.config/cursor/mcp.json

Add:

{
  "mcpServers": {
    "skillboss": {
      "command": "skillboss-mcp",
      "args": ["--api-key", "sk-YOUR_KEY"]
    }
  }
}

Restart Cursor. Now Cursor has native access to all SkillBoss tools.

Real-World Examples

Example 1: Build a Landing Page with Payments

You: "Build a landing page with email capture and Stripe payment"

Cursor with SkillBoss:

// 1. Cursor generates Next.js app
// app/page.tsx

'use client'
import { useState } from 'react'

export default function Home() {
  const [email, setEmail] = useState('')

  async function handleSubmit(e: React.FormEvent) {
    e.preventDefault()

    // Cursor uses SkillBoss Stripe integration
    const response = await fetch('/api/checkout', {
      method: 'POST',
      body: JSON.stringify({ email }),
    })

    const { url } = await response.json()
    window.location.href = url
  }

  return (
    <div className="min-h-screen flex items-center justify-center">
      <form onSubmit={handleSubmit}>
        <input
          type="email"
          value={email}
          onChange={(e) => setEmail(e.target.value)}
          placeholder="Enter your email"
        />
        <button type="submit">Get Early Access - $49</button>
      </form>
    </div>
  )
}

// app/api/checkout/route.ts
import { NextResponse } from 'next/server'

export async function POST(request: Request) {
  const { email } = await request.json()

  // Cursor uses SkillBoss Stripe API
  const response = await fetch('https://api.skillboss.co/v1/stripe/checkout', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.SKILLBOSS_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      amount: 4900,
      currency: 'usd',
      customer_email: email,
      success_url: 'https://yoursite.com/success',
      cancel_url: 'https://yoursite.com/cancel'
    })
  })

  const { checkout_url } = await response.json()
  return NextResponse.json({ url: checkout_url })
}

Result: Complete payment flow without setting up Stripe directly.

Example 2: AI Content Generator

You: "Generate 10 blog posts with images and save them"

Cursor with SkillBoss:

from openai import OpenAI
import requests
import os

# Cursor uses SkillBoss for multiple models
client = OpenAI(
    api_key=os.getenv("SKILLBOSS_API_KEY"),
    base_url="https://api.skillboss.co/v1"
)

topics = [
    "AI in healthcare", "Future of work", "Climate tech",
    "Web3 explained", "Quantum computing basics",
    "Startup funding 2026", "Remote work trends", "AI ethics",
    "Sustainable energy", "Space exploration"
]

for i, topic in enumerate(topics):
    print(f"Generating post {i+1}/{len(topics)}: {topic}")

    # Generate blog post with cheap model
    article = client.chat.completions.create(
        model="gemini/gemini-2.5-flash",  # $0.075/1M tokens
        messages=[{
            "role": "user",
            "content": f"Write a 500-word blog post about {topic}"
        }]
    )

    # Generate featured image
    image = client.images.generate(
        model="flux/flux-schnell",  # $0.01 per image
        prompt=f"Professional blog header about {topic}",
        size="1792x1024"
    )

    # Save
    with open(f"posts/post_{i+1}.md", "w") as f:
        f.write(f"# {topic}\n\n")
        f.write(f"![{topic}]({image.data[0].url})\n\n")
        f.write(article.choices[0].message.content)

    print(f"✓ Saved post_{i+1}.md")

print(f"\n✓ Generated 10 blog posts")
print(f"Cost: ~$0.20 (Gemini Flash + Flux Schnell)")

Result: 10 blog posts with images for $0.20 (vs $15 with Claude + DALL-E).

Example 3: Data Analysis Pipeline

You: "Scrape 50 LinkedIn profiles and analyze them"

Cursor with SkillBoss:

import requests
import os

SKILLBOSS_KEY = os.getenv("SKILLBOSS_API_KEY")
headers = {"Authorization": f"Bearer {SKILLBOSS_KEY}"}

# LinkedIn profiles to scrape
linkedin_urls = [
    "https://linkedin.com/in/johndoe",
    "https://linkedin.com/in/janedoe",
    # ... 48 more
]

profiles = []

for url in linkedin_urls:
    # Use SkillBoss LinkedIn scraper
    response = requests.post(
        "https://api.skillboss.co/v1/linkedin/profile",
        headers=headers,
        json={"url": url}
    )

    profile = response.json()
    profiles.append(profile)
    print(f"✓ Scraped {profile['name']}")

# Analyze with AI
from openai import OpenAI

client = OpenAI(
    api_key=SKILLBOSS_KEY,
    base_url="https://api.skillboss.co/v1"
)

analysis = client.chat.completions.create(
    model="deepseek/deepseek-r1",  # Good for analysis
    messages=[{
        "role": "user",
        "content": f"Analyze these 50 LinkedIn profiles and identify trends:\n\n{profiles}"
    }]
)

print("\nAnalysis:")
print(analysis.choices[0].message.content)

# Cost: 50 profiles × $0.02 = $1.00 + analysis $0.50 = $1.50 total

Cost Comparison

Cursor Alone

Monthly costs for typical usage:

• Cursor Pro: $20/mo
• OpenAI API: $50/mo (for additional calls)
• Stripe: $15/mo
• Hosting: $20/mo
• Email: $15/mo
• Total: $120/mo

Cursor + SkillBoss

Same usage:

• Cursor Pro: $20/mo
• SkillBoss (all services): $35/mo
  • AI models (Gemini Flash mostly): $5
  • Payments: $5
  • Hosting: $15
  • Email: $5
  • Other: $5
• Total: $55/mo

Savings: $65/mo (54%)

Cursor-Specific Tips

1. Use Cursor Composer with SkillBoss

Cursor Composer is great for multi-file edits. Tell it to use SkillBoss:

You: "@Composer build a full-stack app using SkillBoss for backend services"

Cursor will:

• Generate frontend
• Use SkillBoss APIs for backend
• Create database via SkillBoss
• Set up payments via SkillBoss
• Deploy to SkillBoss hosting

All without you switching tools.

2. Cost-Aware Prompting

Poor: "Use AI to do this"

• Cursor picks default (expensive) model

Better: "Use SkillBoss Gemini Flash to do this"

• Cursor uses cheap model

Best: "Use SkillBoss's cheapest model that can handle this task"

• Cursor intelligently selects model

3. Multi-Model Workflows

// In your .cursorrules, add this pattern:

/**
 * For simple tasks: Use Gemini Flash ($0.075/1M)
 * For complex reasoning: Use DeepSeek R1 ($0.14/1M)
 * For premium quality: Use Claude 4.5 ($15/1M)
 *
 * Always try cheaper first, escalate if needed.
 */

Cursor will follow this pattern automatically.

4. Cursor Chat + SkillBoss Knowledge

You: "What models does SkillBoss support and their costs?"

Cursor (reading from .cursorrules):

• "SkillBoss supports 679+ endpoints:
  • Gemini 2.5 Flash: $0.075/1M tokens
  • DeepSeek R1: $0.14/1M tokens
  • Claude 4.5 Sonnet: $15/1M tokens
  • GPT-5: $10/1M tokens
  • ... [full list]"

Keyboard Shortcuts

Troubleshooting

Issue: "API key invalid"

Solution:

1. Check your .cursorrules file has correct key
2. Make sure key starts with sk-
3. Test key manually:

   curl https://api.skillboss.co/v1/models \
     -H "Authorization: Bearer sk-YOUR_KEY"
   

Issue: Cursor not using SkillBoss

Solution:

1. Make sure .cursorrules file is in project root
2. Restart Cursor
3. Explicitly mention SkillBoss in your prompt:
   • "Use SkillBoss to..."
   • "Via SkillBoss API..."

Issue: High costs

Solution:

1. Check which models you're using:

   curl https://api.skillboss.co/v1/usage \
     -H "Authorization: Bearer sk-YOUR_KEY"
   

2. Update .cursorrules to prefer cheaper models
3. Set daily spending limit in SkillBoss console

Best Practices

✅ Do This

1. Start with cheap models: Let Cursor try Gemini Flash first
2. Use .cursorrules: Document your SkillBoss setup
3. Environment variables: Keep API key out of code
4. Cost monitoring: Check usage weekly

❌ Avoid This

1. Don't hardcode API keys: Use environment variables
2. Don't use Claude for everything: 95% of tasks work with Gemini Flash
3. Don't ignore cost: Monitor your SkillBoss dashboard
4. Don't skip error handling: Wrap API calls in try/catch

Example .cursorrules Template

Save this as .cursorrules in your project:

# Project: My Awesome App
# AI Assistant: Cursor with SkillBoss

## SkillBoss Integration

API Key: Available in environment as SKILLBOSS_API_KEY
Base URL: https://api.skillboss.co/v1

## Model Selection Strategy

1. **Simple tasks** (summaries, drafts, simple analysis):
   - Use: `gemini/gemini-2.5-flash`
   - Cost: $0.075/1M tokens

2. **Medium tasks** (reasoning, code review, refactoring):
   - Use: `deepseek/deepseek-r1`
   - Cost: $0.14/1M tokens

3. **Complex tasks** (architecture, security, critical business logic):
   - Use: `claude-4-5-sonnet`
   - Cost: $15/1M tokens

## Available Services

- Model APIs: 50+ (Claude, GPT, Gemini, DeepSeek, etc.)
- Payments: Stripe via SkillBoss
- Email: SendGrid via SkillBoss
- Hosting: Deploy via SkillBoss
- Database: MongoDB via SkillBoss
- Scraping: LinkedIn, Instagram, Twitter, web scraping

## Code Style

- TypeScript for frontend
- Python for data pipelines
- Use SkillBoss SDK when available
- Always include error handling for API calls

## Testing

Before deploying:
1. Run type checking: `pnpm typecheck`
2. Test API calls with small requests first
3. Check SkillBoss usage dashboard for cost verification

Community

Next Steps