Windsurf + SkillBoss

Windsurf + SkillBoss = Superpowers

Windsurf by Codeium is the world's first agentic IDE. It thinks ahead, understands your codebase deeply, and writes code autonomously.

Add SkillBoss and Windsurf gains:

• 679+ AI models (not just one)
• Built-in payments, databases, hosting
• Data scraping (LinkedIn, Twitter, web)
• Cost optimization (70%+ savings)

It's like giving Windsurf a credit card and letting it shop for services autonomously.

Quick Start

One-command setup: Tell your agent set up skillboss.co/skill.md to auto-configure SkillBoss with 687+ APIs.

Step 1: Get SkillBoss API Key

1. Sign up: skillboss.co
2. Copy your API key: sk-YOUR_KEY

Step 2: Add to Windsurf

Option A: Global Settings

1. Open Windsurf Settings (Cmd/Ctrl + ,)
2. Search for "Custom Instructions"
3. Add:

# SkillBoss Integration

You have access to SkillBoss API (https://api.skillboss.co/v1).

API Key: sk-YOUR_KEY (use as env var SKILLBOSS_API_KEY)

## Services Available
- 679+ AI models (Claude, GPT, Gemini, DeepSeek)
- Stripe payments
- SendGrid email
- MongoDB database
- Website hosting
- LinkedIn/Twitter/web scraping

## Model Selection
- Simple tasks → Gemini Flash ($0.075/1M)
- Reasoning → DeepSeek R1 ($0.14/1M)
- Premium → Claude 4.5 ($15/1M)

Always prefer cheaper models unless quality critical.

Option B: Project-Specific

Create .windsurfrules in project root:

# SkillBoss Integration for [Project Name]

SKILLBOSS_API_KEY=sk-YOUR_KEY

## Available via SkillBoss
✓ AI models (50+)
✓ Payments (Stripe)
✓ Email (SendGrid)
✓ Hosting
✓ Database (MongoDB)
✓ Scraping (LinkedIn, Twitter, web)

## Cost-First Approach
Try Gemini Flash first, upgrade to Claude only if needed.

Windsurf Flow Mode + SkillBoss

Flow Mode is Windsurf's autonomous coding mode. Combined with SkillBoss, it can:

1. Build Full-Stack Apps Autonomously

You: "Build a SaaS for tracking habits with payments"

Windsurf (Flow Mode) + SkillBoss:

🌊 Entering Flow Mode...

Step 1/7: Planning architecture
✓ Next.js frontend
✓ MongoDB database (via SkillBoss)
✓ Stripe payments (via SkillBoss)
✓ Email notifications (via SkillBoss)

Step 2/7: Creating project structure
✓ Created 15 files

Step 3/7: Implementing auth system
✓ JWT authentication
✓ Password hashing with bcrypt

Step 4/7: Building habit tracking features
✓ CRUD operations for habits
✓ Streak calculation
✓ Progress visualization

Step 5/7: Integrating Stripe payments via SkillBoss
✓ Checkout flow
✓ Webhook handling
✓ Subscription management

Step 6/7: Setting up email notifications via SkillBoss
✓ Daily reminder emails
✓ Streak milestone congratulations

Step 7/7: Deploying to SkillBoss hosting
✓ Production build
✓ Environment variables configured
✓ Custom domain setup

✅ Complete SaaS deployed: https://habittracker.app
💰 Used SkillBoss for database, payments, email, hosting
📊 Total cost: $0.50 (vs $50 setting up each service separately)

All autonomous. You didn't write a single line of code.

Real-World Examples

Example 1: AI Content Pipeline

Prompt: "Create a pipeline that researches a topic, writes an article, generates an image, and publishes it"

Windsurf + SkillBoss builds:

# research_and_publish.py
import os
from openai import OpenAI
import requests

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

def create_article(topic: str):
    """Autonomous content creation pipeline"""

    print(f"🔍 Researching: {topic}")

    # Step 1: Research with Perplexity Sonar
    research = client.chat.completions.create(
        model="perplexity/sonar-pro",
        messages=[{
            "role": "user",
            "content": f"Research latest trends and data about: {topic}"
        }]
    )

    print(f"📝 Writing article...")

    # Step 2: Write with Claude (high quality needed)
    article = client.chat.completions.create(
        model="claude-4-5-sonnet",
        messages=[{
            "role": "user",
            "content": f"Write a 1000-word article about {topic} using this research:\n\n{research.choices[0].message.content}"
        }]
    )

    print(f"🎨 Generating image...")

    # Step 3: Generate featured image with Flux (cheap)
    image = client.images.generate(
        model="flux/flux-schnell",
        prompt=f"Professional blog header about {topic}, minimalist, modern",
        size="1792x1024"
    )

    print(f"🚀 Publishing...")

    # Step 4: Deploy via SkillBoss hosting
    response = requests.post(
        "https://api.skillboss.co/v1/hosting/deploy",
        headers={"Authorization": f"Bearer {os.getenv('SKILLBOSS_API_KEY')}"},
        json={
            "content": {
                "index.html": f"""
                <!DOCTYPE html>
                <html>
                <head>
                    <title>{topic}</title>
                    <meta charset="UTF-8">
                </head>
                <body>
                    <img src="{image.data[0].url}" alt="{topic}" />
                    <article>{article.choices[0].message.content}</article>
                </body>
                </html>
                """
            },
            "path": f"/blog/{topic.lower().replace(' ', '-')}"
        }
    )

    url = response.json()["url"]
    print(f"✅ Published: {url}")

    return {
        "url": url,
        "cost": 0.05 + 0.30 + 0.01  # Research + Writing + Image = $0.36
    }

# Run it
result = create_article("AI Agents in 2026")
print(f"\n💰 Total cost: ${result['cost']}")

Windsurf writes this entire pipeline autonomously in Flow Mode.

Example 2: Data Scraping + Analysis

Prompt: "Scrape 100 LinkedIn profiles of AI engineers and analyze hiring trends"

Windsurf + SkillBoss builds:

import requests
import os
from openai import OpenAI

SKILLBOSS_KEY = os.getenv("SKILLBOSS_API_KEY")

def analyze_linkedin_trends():
    """Scrape and analyze LinkedIn profiles"""

    # Search for AI engineers on LinkedIn
    search_results = requests.post(
        "https://api.skillboss.co/v1/linkedin/search",
        headers={"Authorization": f"Bearer {SKILLBOSS_KEY}"},
        json={
            "query": "AI Engineer",
            "filters": {
                "location": "San Francisco Bay Area",
                "company_size": ["51-200", "201-500"]
            },
            "limit": 100
        }
    )

    profile_urls = [p["url"] for p in search_results.json()["results"]]

    print(f"Found {len(profile_urls)} profiles. Scraping...")

    # Scrape profiles
    profiles = []
    for url in profile_urls:
        profile = requests.post(
            "https://api.skillboss.co/v1/linkedin/profile",
            headers={"Authorization": f"Bearer {SKILLBOSS_KEY}"},
            json={"url": url}
        ).json()

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

    # Analyze with DeepSeek (good for analysis, cheap)
    client = OpenAI(
        api_key=SKILLBOSS_KEY,
        base_url="https://api.skillboss.co/v1"
    )

    analysis = client.chat.completions.create(
        model="deepseek/deepseek-r1",
        messages=[{
            "role": "user",
            "content": f"""Analyze these 100 AI engineer profiles.

Identify:
1. Most common skills
2. Typical career progression
3. Salary ranges (if available)
4. Companies hiring most
5. Education backgrounds

Profiles: {profiles}
"""
        }]
    )

    print("\n📊 Analysis:\n")
    print(analysis.choices[0].message.content)

    # Cost: 100 profiles × $0.02 + analysis $0.70 = $2.70
    print(f"\n💰 Total cost: $2.70")

analyze_linkedin_trends()

Windsurf builds this in minutes, fully autonomous.

Windsurf Cascade + SkillBoss

Cascade is Windsurf's deep codebase understanding. When you add SkillBoss:

Before: Limited Capabilities

You: "Add payments to this app"

Windsurf Cascade:

I can help you integrate Stripe. You'll need to:
1. Sign up for Stripe
2. Get API keys
3. Install stripe package
4. Create checkout session
5. Handle webhooks
...

You have to do most of it manually.

After: Full Autonomy with SkillBoss

You: "Add payments to this app using SkillBoss"

Windsurf Cascade + SkillBoss:

✓ Analyzed your codebase
✓ Added SkillBoss payment integration
✓ Created checkout API endpoint
✓ Set up webhook handler
✓ Updated frontend with payment button
✓ Tested payment flow
✓ Deployed to production

Ready to accept payments. No Stripe account needed.

Windsurf does everything autonomously through SkillBoss.

Cost Comparison

Typical Month (Building a SaaS)

Without SkillBoss:

• Windsurf Pro: $15/mo
• OpenAI API: $80/mo
• Anthropic: $50/mo
• Stripe fees: $29/mo
• Hosting (Vercel): $20/mo
• Database (MongoDB Atlas): $25/mo
• Email (SendGrid): $15/mo
• Total: $234/mo

With SkillBoss:

• Windsurf Pro: $15/mo
• SkillBoss (all services): $45/mo
  • AI models (multi-model routing): $12
  • Payments: $8
  • Hosting: $15
  • Database: $5
  • Email: $5
• Total: $60/mo

Savings: $174/mo (74%)

Windsurf-Specific Features

1. Supercomplete + SkillBoss

Supercomplete suggests entire implementations. Tell it about SkillBoss:

// Start typing...
async function createPayment

// Windsurf Supercomplete suggests:
async function createPaymentViaSkillBoss(amount: number, email: string) {
  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, customer_email: email })
  })

  return response.json()
}

Windsurf auto-completes using SkillBoss patterns.

2. Terminal Integration

Windsurf's integrated terminal knows about SkillBoss:

You type: deploy to skillboss

Windsurf suggests:

curl -X POST https://api.skillboss.co/v1/hosting/deploy \
  -H "Authorization: Bearer $SKILLBOSS_API_KEY" \
  -F "files=@./dist.zip"

3. Chat + Code Context

Windsurf Chat understands your entire codebase AND SkillBoss:

You: "How much would it cost to generate 1000 product images?"

Windsurf:

Based on SkillBoss pricing:

DALL-E 3: 1000 × $0.10 = $100
Flux Schnell: 1000 × $0.01 = $10 ← Recommended
Flux Pro: 1000 × $0.05 = $50

Recommendation: Use Flux Schnell via SkillBoss.
Estimated cost: $10
Estimated time: 30 minutes

Would you like me to implement this?

Best Practices for Windsurf + SkillBoss

✅ Do This

1. Use Flow Mode for complex tasks: Let Windsurf build autonomously
2. Set cost preferences: "Prefer cheap models unless quality critical"
3. Let Cascade analyze first: It understands your codebase + SkillBoss capabilities
4. Use Supercomplete: It learns your SkillBoss patterns

❌ Avoid This

1. Don't micromanage: Flow Mode works best with minimal interruption
2. Don't hardcode keys: Use environment variables
3. Don't skip testing: Always test SkillBoss integrations locally first
4. Don't ignore costs: Check SkillBoss dashboard weekly

Example .windsurfrules

# Project: [Your Project]
# AI IDE: Windsurf with SkillBoss

## SkillBoss Configuration

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

## Model Selection Strategy

For code generation:
- Simple components → Gemini Flash ($0.075/1M)
- Complex logic → DeepSeek R1 ($0.14/1M)
- Critical features → Claude 4.5 ($15/1M)

For content:
- Drafts → Gemini Flash
- Final copy → GPT-5 or Claude

For images:
- Mockups → Flux Schnell ($0.01/image)
- Marketing → DALL-E 3 ($0.10/image)

## Services Integration

When I say "add payments", use:
- SkillBoss Stripe integration
- Endpoint: /v1/stripe/checkout
- No direct Stripe account needed

When I say "deploy", use:
- SkillBoss hosting
- Endpoint: /v1/hosting/deploy
- Returns live URL

When I say "send email", use:
- SkillBoss SendGrid integration
- Endpoint: /v1/email/send

## Development Workflow

1. Analyze codebase with Cascade
2. Plan implementation with cost consideration
3. Build in Flow Mode with SkillBoss integrations
4. Test locally first
5. Deploy via SkillBoss
6. Monitor costs in dashboard

## Code Style

- TypeScript for type safety
- Environment variables for secrets
- Error handling for all API calls
- Comments for complex SkillBoss integrations

Keyboard Shortcuts

Troubleshooting

Issue: Windsurf doesn't know about SkillBoss

Solution:

1. Add SkillBoss details to Settings → Custom Instructions
2. Or create .windsurfrules in project root
3. Restart Windsurf
4. In Chat, type: "You have access to SkillBoss API"

Issue: High API costs

Solution:

1. Check model usage:

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

2. Update model preferences in .windsurfrules
3. Tell Windsurf: "Prefer Gemini Flash for all tasks unless quality critical"

Issue: Flow Mode keeps getting stuck

Solution:

1. Break task into smaller pieces
2. Give Windsurf clear success criteria
3. Provide examples of desired output
4. Use Cascade to analyze codebase first

Video Tutorials

Next Steps