GitHub Copilot + SkillBoss

Why Add SkillBoss to GitHub Copilot?

GitHub Copilot is amazing for code completion and chat. But it has limitations:

• Only accesses GitHub's models (GPT-4, Claude)
• No built-in payment processing
• No database/hosting integration
• No data scraping capabilities
• Can't deploy your apps

Add SkillBoss = Copilot becomes a full-stack development assistant:

• Access 679+ AI models (not just 2-3)
• Add Stripe payments without leaving VS Code
• Deploy to hosting with one command
• Scrape LinkedIn, Twitter, web data
• Use MongoDB, send emails, generate images

Installation

Step 1: Get SkillBoss API Key

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

Step 2: Add to VS Code Settings

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 full-stack development.

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

## Available Services

### Model APIs (50+)
- Claude 4.5 Sonnet ($15/1M tokens)
- GPT-5 ($10/1M tokens)
- Gemini 2.5 Flash ($0.075/1M tokens) ← Use for most tasks
- DeepSeek R1 ($0.14/1M tokens)
- Qwen 3, Llama 4, Mistral Large

### Business Services
- Stripe payments (checkout, subscriptions, invoices)
- SendGrid email (transactional + marketing)
- SMS messaging

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

### Data Scraping
- LinkedIn profiles & company data
- Instagram, Twitter/X, Facebook
- Google Maps, Yelp Business
- General web scraping (Firecrawl)

## Cost-First Approach
- For simple tasks: Use Gemini Flash ($0.075/1M)
- For reasoning: Use DeepSeek R1 ($0.14/1M)
- For premium quality: Use Claude 4.5 ($15/1M)

Always try the cheapest model first unless quality is critical.

## OpenAI-Compatible Endpoint
SkillBoss uses OpenAI-compatible API:

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="gemini/gemini-2.5-flash",
    messages=[{"role": "user", "content": "Hello"}]
)

</Step>

<Step title="Add Environment Variable">
Create `.env` in project root:

```bash
SKILLBOSS_API_KEY=sk-YOUR_KEY

GitHub Copilot Chat + SkillBoss

Basic Usage

You: @workspace How can I add Stripe payments?

Copilot (without SkillBoss):

You'll need to:
1. Create Stripe account
2. Get API keys
3. Install stripe package
4. Set up checkout session
5. Create webhook endpoint
6. Handle payment success/failure
...
[Gives you generic instructions]

Copilot (with SkillBoss):

I can add Stripe payments via SkillBoss. Here's the implementation:

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

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

  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,
      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 })
}

No Stripe account needed. Uses SkillBoss payment processing.
Cost: 5 credits per checkout session (~$0.05)

Copilot gives you working code immediately.

Real-World Examples

Example 1: Add AI Image Generation

You: Cmd/Ctrl + I → "Generate product images with AI"

Copilot + SkillBoss generates:

// lib/generate-images.ts
import OpenAI from 'openai'

const client = new OpenAI({
  apiKey: process.env.SKILLBOSS_API_KEY,
  baseURL: 'https://api.skillboss.co/v1'
})

export async function generateProductImage(description: string) {
  // Use Flux Schnell for cost efficiency ($0.01/image vs DALL-E $0.10)
  const response = await client.images.generate({
    model: 'flux/flux-schnell',
    prompt: `Professional product photo: ${description}, white background, high quality`,
    size: '1024x1024'
  })

  return response.data[0].url
}

// Usage example
const imageUrl = await generateProductImage('wireless headphones')
// Cost: $0.01 (90% cheaper than DALL-E)

Example 2: Multi-Model Content Generation

You: Select this code:

function generateBlogPost(topic: string) {
  // Generate blog post content
}

Press Cmd/Ctrl + I → "Implement this using SkillBoss with cost optimization"

Copilot generates:

import OpenAI from 'openai'

const client = new OpenAI({
  apiKey: process.env.SKILLBOSS_API_KEY,
  baseURL: 'https://api.skillboss.co/v1'
})

async function generateBlogPost(topic: string) {
  // Try cheap model first
  let response = await client.chat.completions.create({
    model: 'gemini/gemini-2.5-flash', // $0.075/1M tokens
    messages: [{
      role: 'user',
      content: `Write a 500-word blog post about ${topic}`
    }]
  })

  const content = response.choices[0].message.content

  // Check quality (simple heuristic)
  const qualityScore = content.length > 400 && !content.includes('error') ? 0.9 : 0.6

  // If quality insufficient, retry with better model
  if (qualityScore < 0.8) {
    console.log('Quality insufficient, upgrading to Claude...')

    response = await client.chat.completions.create({
      model: 'claude-4-5-sonnet', // $15/1M tokens
      messages: [{
        role: 'user',
        content: `Write a high-quality 500-word blog post about ${topic}`
      }]
    })
  }

  return {
    content: response.choices[0].message.content,
    cost: qualityScore >= 0.8 ? 0.002 : 0.03 // Gemini vs Claude cost
  }
}

// Saves 90%+ by using Gemini for most posts

Example 3: LinkedIn Data Scraping

You: @workspace Help me scrape LinkedIn profiles

Copilot + SkillBoss:

import os
import requests
from typing import List, Dict

SKILLBOSS_KEY = os.getenv("SKILLBOSS_API_KEY")

def scrape_linkedin_profiles(urls: List[str]) -> List[Dict]:
    """
    Scrape LinkedIn profiles via SkillBoss.

    Cost: $0.02 per profile
    """
    profiles = []

    for url in urls:
        response = requests.post(
            "https://api.skillboss.co/v1/linkedin/profile",
            headers={"Authorization": f"Bearer {SKILLBOSS_KEY}"},
            json={"url": url}
        )

        if response.status_code == 200:
            profile = response.json()
            profiles.append({
                "name": profile["name"],
                "headline": profile["headline"],
                "location": profile["location"],
                "experience": profile["experience"],
                "education": profile["education"],
                "skills": profile["skills"]
            })
            print(f"✓ Scraped {profile['name']}")
        else:
            print(f"✗ Failed: {url}")

    return profiles

# Example usage
linkedin_urls = [
    "https://linkedin.com/in/johndoe",
    "https://linkedin.com/in/janedoe",
    # ... more URLs
]

profiles = scrape_linkedin_profiles(linkedin_urls)
print(f"\nScraped {len(profiles)} profiles")
print(f"Cost: ${len(profiles) * 0.02:.2f}")

Copilot Slash Commands + SkillBoss

Custom Slash Commands

Add to VS Code settings.json:

{
  "github.copilot.chat.commands": {
    "/skillboss-deploy": {
      "description": "Deploy to SkillBoss hosting",
      "prompt": "Deploy this project to SkillBoss hosting using the API at https://api.skillboss.co/v1/hosting/deploy. Use SKILLBOSS_API_KEY environment variable for authentication."
    },
    "/skillboss-payment": {
      "description": "Add Stripe payment via SkillBoss",
      "prompt": "Integrate Stripe payments using SkillBoss API. Use endpoint /v1/stripe/checkout with SKILLBOSS_API_KEY. Generate both frontend form and backend API route."
    },
    "/skillboss-cheap": {
      "description": "Use cheapest SkillBoss model",
      "prompt": "Implement this using SkillBoss's Gemini Flash model (cheapest option at $0.075/1M tokens). Use OpenAI-compatible endpoint at https://api.skillboss.co/v1"
    }
  }
}

Usage:

Type /skillboss-deploy in Copilot Chat → Instant deployment code

Type /skillboss-payment in Copilot Chat → Complete payment integration

Type /skillboss-cheap in Copilot Chat → Cost-optimized AI implementation

Cost Comparison

Monthly Development Costs

GitHub Copilot Alone:

• GitHub Copilot: $10/mo
• Additional OpenAI API: $50/mo (for extra calls)
• Stripe: $29/mo (monthly fee)
• Hosting: $20/mo
• Database: $25/mo
• Email service: $15/mo
• Total: $149/mo

GitHub Copilot + SkillBoss:

• GitHub Copilot: $10/mo
• SkillBoss (all services): $35/mo
  • AI models: $8
  • Payments: $7
  • Hosting: $15
  • Database: $3
  • Email: $2
• Total: $45/mo

Savings: $104/mo (70%)

GitHub Copilot Workspace + SkillBoss

Copilot Workspace (web-based) can build entire features. With SkillBoss:

Before: Limited to Code

You: "Build a user authentication system"

Copilot Workspace:

✓ Created auth components
✓ Added JWT logic
✓ Set up login/signup forms

❌ Still need to:
- Set up database manually
- Configure email service for verification
- Add payment tiers

After: Full Stack with SkillBoss

You: "Build a user authentication system with email verification and payment tiers using SkillBoss"

Copilot Workspace + SkillBoss:

✓ Created auth components
✓ Added JWT logic
✓ Set up login/signup forms
✓ Integrated SkillBoss MongoDB for user storage
✓ Added SkillBoss SendGrid for verification emails
✓ Integrated SkillBoss Stripe for payment tiers
✓ Deployed to SkillBoss hosting

Complete auth system ready to use.
No manual setup required.

Best Practices

✅ Do This

1. Add SkillBoss to Copilot Instructions: Copilot will know about it globally
2. Use environment variables: Never hardcode API keys
3. Start with cheap models: Let Copilot try Gemini Flash first
4. Create custom slash commands: Quick access to SkillBoss features
5. Test locally: Always test SkillBoss integrations before deploying

❌ Avoid This

1. Don't skip instructions: Copilot needs to know about SkillBoss
2. Don't use expensive models by default: 90% of tasks work with cheap models
3. Don't ignore costs: Monitor SkillBoss dashboard weekly
4. Don't commit API keys: Use .env files and .gitignore
5. Don't use Copilot for SkillBoss API: Copilot can write the integration code

Example VS Code Settings

Save this to .vscode/settings.json in your project:

{
  "github.copilot.enable": {
    "*": true
  },
  "github.copilot.chat.instructions": [
    "You have access to SkillBoss API for full-stack development.",
    "Base URL: https://api.skillboss.co/v1",
    "API Key: Use SKILLBOSS_API_KEY environment variable",
    "",
    "Model Selection:",
    "- Simple tasks → gemini/gemini-2.5-flash ($0.075/1M)",
    "- Reasoning → deepseek/deepseek-r1 ($0.14/1M)",
    "- Premium → claude-4-5-sonnet ($15/1M)",
    "",
    "Services Available:",
    "- AI models (50+)",
    "- Stripe payments (/v1/stripe/checkout)",
    "- SendGrid email (/v1/email/send)",
    "- Hosting (/v1/hosting/deploy)",
    "- MongoDB database",
    "- LinkedIn/Twitter/web scraping",
    "",
    "Always prefer cheaper models unless quality is critical."
  ],
  "github.copilot.chat.commands": {
    "/skillboss": {
      "description": "Use SkillBoss services",
      "prompt": "Implement this using SkillBoss API. Prefer cheap models."
    }
  }
}

Keyboard Shortcuts

Troubleshooting

Issue: Copilot doesn't know about SkillBoss

Solution:

1. Check Settings → GitHub Copilot: Instructions
2. Make sure SkillBoss config is there
3. Restart VS Code
4. Try: @workspace You have access to SkillBoss API

Issue: "API key invalid"

Solution:

# Test your API key
curl https://api.skillboss.co/v1/models \
  -H "Authorization: Bearer sk-YOUR_KEY"

# If it works, check your .env file
cat .env | grep SKILLBOSS

# Make sure VS Code can read .env
# Install "DotENV" extension if needed

Issue: Copilot generates code but doesn't use SkillBoss

Solution: Be explicit in your prompt:

• ❌ "Add payments"
• ✅ "Add payments using SkillBoss Stripe API"

Video Tutorials

Next Steps