Getting Started

Set up ULPI Skills and start generating consistent code in 10 minutes

Your AI Will Follow Your Patterns in 10 Minutes

No complex configuration. No long setup process. Just 3 simple steps.

Time estimate: 10 minutes

Prerequisites:

• ULPI account (sign up free)
• Repository with code
• AI assistant with MCP support (Claude Desktop, Cursor, etc.)

---

Step 1: Connect Your Repository

1. Navigate to Repositories

   Dashboard → Repositories → Click Connect Repository

   Pro tip: Connect your most active repository first

2. Choose Your Git Provider

   • GitHub (most common)
   • GitLab (cloud or self-hosted)
   • Bitbucket (cloud or server)
   • Gitea (self-hosted)

   Read-only access: ULPI only needs read permissions to detect your tech stack

3. Authorize ULPI

   Grant ULPI access to:

   • ✅ Read repository contents
   • ✅ Detect technologies (package.json, composer.json, etc.)
   • ❌ No write access required

   We DO NOT:

   • Write to your repositories
   • Execute code
   • Store your source code
4. Tech Stack Auto-Detection

   ULPI automatically detects your technologies:

   Scans:

   • package.json → Node.js, React, Next.js
   • composer.json → PHP, Laravel
   • requirements.txt → Python, Django, FastAPI
   • pom.xml → Java, Spring Boot
   • File extensions → Languages, frameworks

   Result:

   ✅ Detected Technologies:
   - PHP 8.2
   - Laravel 11
   - MySQL 8.0
   - Redis 7.0
   - Docker
   
   Skills matched: 8 public skills
   

⏱️ Time: 2 minutes

---

Step 2: Configure Your AI Assistant

Claude Desktop

Add ULPI Skills MCP server:

1. Open Claude Desktop settings
2. Navigate to Developer → MCP Servers
3. Click Add Server
4. Use these settings:

{
  "ulpi-skills": {
    "command": "npx",
    "args": [
      "@ulpi/mcp-client",
      "skills"
    ],
    "env": {
      "ULPI_API_KEY": "your-api-key-here",
      "ULPI_PROJECT_ID": "your-project-id"
    }
  }
}

5. Get your API key:

   • Dashboard → Settings → API Keys → Create Key
   • Select scope: Skills

6. Get your Project ID:

   • Dashboard → Select project → URL shows /projects/123 (123 is your ID)

7. Restart Claude Desktop

Verify: Start a new chat. Ask: “What skills are available?”

Claude should list your matched skills.

Cursor

Add ULPI Skills to Cursor:

1. Open Cursor settings (Cmd+, or Ctrl+,)
2. Go to Features → MCP
3. Add new MCP server:

{
  "name": "ULPI Skills",
  "command": "npx",
  "args": [
    "@ulpi/mcp-client",
    "skills"
  ],
  "env": {
    "ULPI_API_KEY": "your-api-key-here",
    "ULPI_PROJECT_ID": "your-project-id"
  }
}

4. Reload Cursor (Cmd+Shift+P → “Reload Window”)

Get credentials: Dashboard → Settings → API Keys (create new key + copy project ID from URL)

Windsurf

Connect Windsurf to ULPI Skills:

1. Open Windsurf settings
2. Navigate to Extensions → MCP Configuration
3. Add ULPI Skills:

{
  "mcpServers": {
    "ulpi-skills": {
      "command": "npx",
      "args": ["@ulpi/mcp-client", "skills"],
      "env": {
        "ULPI_API_KEY": "your-api-key-here",
        "ULPI_PROJECT_ID": "your-project-id"
      }
    }
  }
}

4. Restart Windsurf

Other AI Tools (29+)

ULPI Skills works with any MCP-compatible AI assistant:

• Claude Code
• VSCode Copilot
• Zed
• Cline
• Continue
• Aider
• And 24+ more…

Generic setup:

1. Find MCP configuration in your AI tool’s settings
2. Add ULPI Skills MCP server with command:
   npx @ulpi/mcp-client skills
   
3. Set environment variables:
   • ULPI_API_KEY (from Dashboard → Settings → API Keys)
   • ULPI_PROJECT_ID (from project URL)

Need help? Check our MCP setup guide or email [e-mail]

⏱️ Time: 5 minutes

---

Step 3: Use Your First Skill

Discover Available Skills

Ask your AI:

You: "What skills are available for this project?"

AI response:

I have access to 8 ULPI Skills for your Laravel project:

1. Create Laravel API Endpoint
   Build RESTful APIs with validation, resources, tests

2. Laravel Database Migration
   Design schemas with proper types, indexes

3. Write PHPUnit Tests
   Create feature and unit tests with mocks

4. Implement Laravel Queue Job
   Build async jobs with retry logic

5. Database Query Optimization
   Fix slow queries, add indexes, prevent N+1

6. Git Commit Best Practices
   Write professional commit messages

7. API Documentation with OpenAPI
   Document REST APIs with OpenAPI 3.0

8. Setup Docker Container
   Containerize your Laravel application

Would you like me to use one?

Use a Skill

Ask your AI to use a skill:

You: "Use the Create Laravel API Endpoint skill to build /api/posts"

AI executes the skill:

Following the Create Laravel API Endpoint skill...

✅ Step 1: Creating FormRequest validation
   Created: app/Http/Requests/StorePostRequest.php

✅ Step 2: Building API Resource transformation
   Created: app/Http/Resources/PostResource.php

✅ Step 3: Implementing Service layer logic
   Created: app/Services/PostService.php

✅ Step 4: Creating API Controller
   Created: app/Http/Controllers/API/PostController.php

✅ Step 5: Adding routes with rate limiting
   Updated: routes/api.php (5 new routes)

✅ Step 6: Writing feature tests
   Created: tests/Feature/PostControllerTest.php (12 tests)

Complete! Generated 6 files, all tests passing.

Result: Production-ready code in 2 minutes, zero rework needed

Review Generated Code

Check what was created:

# Validation
app/Http/Requests/StorePostRequest.php
- Title required, max 255 chars
- Content required
- Published_at date format validation

# Transformation
app/Http/Resources/PostResource.php
- Consistent JSON formatting
- Related data included
- Timestamps formatted

# Business Logic
app/Services/PostService.php
- CRUD operations
- Transaction support
- Error handling

# Controller
app/Http/Controllers/API/PostController.php
- index(), store(), show(), update(), destroy()
- Proper HTTP status codes
- Resource responses

# Routes
routes/api.php
- GET /api/posts
- POST /api/posts
- GET /api/posts/{id}
- PUT /api/posts/{id}
- DELETE /api/posts/{id}
- Rate limiting: 60 requests/minute

# Tests
tests/Feature/PostControllerTest.php
- 12 tests covering all endpoints
- Database factories used
- Edge cases tested

All code follows Laravel best practices ✅

⏱️ Time: 2 minutes

---

✅ You’re Done! What’s Next?

Try More Skills

"Use the Write PHPUnit Tests skill to add tests for UserController"

"Use the Laravel Database Migration skill to add posts table"

"Use the Git Commit Best Practices skill to commit these changes"

Explore all 8 skills matched to your project

Create Custom Skill

Encode your team’s patterns:

• Your deployment workflow
• Company coding standards
• Code review checklist
• Security scanning process

Learn How to Create Custom Skills →

View in Dashboard

Dashboard → Your Project → Skills

• See all available skills
• View skill details
• Check usage statistics
• Manage active skills

Integrate with Workflow

Combine skills for complete workflows:

1. "Use Laravel API Endpoint skill for /api/users"
2. "Use Write PHPUnit Tests skill for UserController"
3. "Use API Documentation skill to document /api/users"
4. "Use Git Commit Best Practices skill to commit"

See Common Workflows →

---

Common Workflows

🔌 API Development Workflow

Complete API feature in 10 minutes:

Step 1: Create endpoint

"Use Create Laravel API Endpoint skill for /api/posts"

→ Generates controller, validation, resource, service, routes, tests

Step 2: Add tests

"Use Write PHPUnit Tests skill to add edge case tests"

→ Adds authorization tests, validation tests, error handling

Step 3: Document API

"Use API Documentation with OpenAPI skill for /api/posts"

→ Generates OpenAPI spec, example requests/responses

Step 4: Commit

"Use Git Commit Best Practices skill to commit these changes"

→ Creates proper commit message following Conventional Commits

Result:

• Complete API endpoint
• 100% test coverage
• Full documentation
• Professional commit message
• Time: 10 minutes (vs. 2 hours manually)

🗄️ Database Schema Workflow

Add new database table:

Step 1: Create migration

"Use Laravel Database Migration skill to add posts table with:
 - title (string, required)
 - content (text)
 - published_at (timestamp, nullable)
 - user_id (foreign key to users)"

→ Generates migration with proper types, indexes, foreign keys

Step 2: Create model and relationships

"Create Post model with relationships to User"

→ Generates model with fillable, casts, relationships

Step 3: Add factory and seeder

"Create factory and seeder for Post model"

→ Generates realistic test data

Step 4: Test migration

"Use Write PHPUnit Tests skill to test Post migration"

→ Creates migration tests, relationship tests

Result:

• Production-ready schema
• Proper indexes for performance
• Test data generation
• Migration tests

⚛️ React Component Workflow

Build new UI component:

Step 1: Create component

"Use Create React Component skill for UserProfile with:
 - Props: user, onEdit, onDelete
 - Show avatar, name, email, role
 - Edit and delete buttons"

→ Generates component, TypeScript types, CSS module, tests, story

Step 2: Add to Storybook (if you have custom skill)

"Use Add Component to Storybook skill for UserProfile"

→ Creates Storybook stories with all variants

Step 3: Test accessibility

"Add accessibility tests for UserProfile component"

→ Adds ARIA label tests, keyboard navigation tests

Step 4: Commit

"Use Git Commit Best Practices skill to commit UserProfile"

Result:

• Production-ready component
• Full TypeScript types
• Component tests
• Storybook documentation
• Accessibility compliant

🚀 Deployment Workflow

Deploy to staging (custom skill example):

Prerequisites: Create custom “Deploy to Staging” skill

Usage:

"Use Deploy to Staging skill"

Skill executes:

✅ Step 1: Running test suite
   All 247 tests passing

✅ Step 2: Building production assets
   Built in 23.4s

✅ Step 3: Creating deployment branch
   Branch: deploy/staging-20250112

✅ Step 4: Pushing to staging
   Pushed to staging remote

✅ Step 5: Running database migrations
   Migrated 3 new migrations

✅ Step 6: Verifying deployment
   Health check: OK (200)

✅ Step 7: Notifying team
   Posted to #deployments channel

Deployment complete! Staging is live.

Result:

• Zero mistakes
• Every step verified
• Team notified
• Time: 3 minutes (vs. 20 minutes manually)

🔍 Code Review Workflow

Before creating PR (custom skill):

Prerequisites: Create custom “Pre-Review Checklist” skill

Usage:

"Use Pre-Review Checklist skill before creating PR"

Skill checks:

✅ Tests Pass
   247/247 tests passing
   Coverage: 87%

✅ Code Quality
   Linter: Passed
   No console.logs found
   No commented code

✅ Security
   No hardcoded secrets
   SQL injection: Protected
   XSS protection: Enabled

✅ Documentation
   README updated
   API docs current
   Changelog entry added

✅ Performance
   No N+1 queries detected
   Images optimized
   Bundle size: 234KB (under 250KB limit)

All checks passed! Ready to create PR.

Result:

• 78% reduction in code review iterations
• Faster PR approvals
• Higher code quality

---

Troubleshooting

❌ Skills Not Showing in AI Assistant

Problem: AI says “No skills available”

Diagnosis:

1. Check MCP connection:

   • Restart your AI assistant
   • Start new chat
   • Ask: “What MCP servers are connected?”

2. Verify API key:

   // Check your config
   "env": {
     "ULPI_API_KEY": "sk_..."  // Must start with sk_
   }
   
   • Dashboard → Settings → API Keys → Verify key is active

3. Verify project ID:

   "ULPI_PROJECT_ID": "123"  // Numeric ID from URL
   
   • Dashboard → Select project → Check URL

4. Check API key scope:

   • API key must have Skills scope enabled
   • Dashboard → Settings → API Keys → Check scopes

Fix:

• Correct API key or project ID in MCP config
• Restart AI assistant
• Test: “What skills are available?”

❌ Wrong Skills Showing

Problem: Seeing Laravel skills in React project (or vice versa)

Cause: Tech stack not detected correctly

Fix:

1. Check detected technologies:

   • Dashboard → Your Project → Tech Stack

2. Manually add missing technologies:

   • Click Edit Tech Stack
   • Add: React, TypeScript, Node.js, etc.
   • Save

3. Reconnect repository:

   • Sometimes helps re-trigger detection
   • Dashboard → Repositories → Disconnect → Reconnect

4. Verify package files exist:

   • React projects need package.json with react dependency
   • Laravel projects need composer.json with laravel/framework

Result: Skills filtered correctly for your stack

❌ Skill Run Failed

Problem: AI says “Skill execution failed”

Common causes:

1. Missing dependencies:

Error: "Laravel not installed"

→ Skill requires Laravel, but project is not Laravel

2. Invalid parameters:

Error: "Invalid endpoint format"

→ Check skill requirements (e.g., endpoint must start with /)

3. Quota exceeded:

Error: "Skill run limit exceeded"

→ Upgrade plan or wait for monthly reset

4. File conflicts:

Error: "File already exists: PostController.php"

→ Skill tries to create existing file

Fix:

• Read error message carefully
• Check skill prerequisites
• Verify project structure
• Ask AI to retry with corrections

🔍 How to See Skill Details

In Dashboard:

1. Dashboard → Your Project → Skills
2. Click on skill name
3. View:
   • Full skill description
   • Step-by-step guide
   • Prerequisites
   • Example usage
   • Related skills

In AI Assistant:

"Explain the Create Laravel API Endpoint skill"

AI will show:

• What the skill does
• What files it creates
• Prerequisites
• Example usage

📊 Check Usage Statistics

View your usage:

1. Dashboard → Billing → Usage

Shows:

• Skill runs this month
• Runs by skill (which skills used most)
• Tokens consumed
• Remaining quota

Example:

January 2025 Usage:

Skill Runs: 247 / 1,000 (24%)
- Create Laravel API Endpoint: 89 runs
- Write PHPUnit Tests: 67 runs
- Laravel Database Migration: 45 runs
- Git Commit Best Practices: 46 runs

Tokens: 125,430 / 50,000 (exceeded, $3.78 overage)

Projected monthly cost: $19.00 + $3.78 = $22.78

Tip: Upgrade to Pro if consistently exceeding limits

---

Quick Reference

Essential Commands

# Discover skills
"What skills are available?"
"List all Laravel skills"
"Explain the [skill name] skill"

# Use skills
"Use the [skill name] skill to [task]"
"Use Create Laravel API Endpoint skill for /api/users"

# Create custom skills
"How do I create a custom skill?"
[See Custom Skills guide]

# Check usage
"How many skill runs have I used this month?"
[Check in Dashboard → Billing → Usage]

MCP Configuration

{
  "ulpi-skills": {
    "command": "npx",
    "args": ["@ulpi/mcp-client", "skills"],
    "env": {
      "ULPI_API_KEY": "sk_your_key_here",
      "ULPI_PROJECT_ID": "123"
    }
  }
}

Get credentials:

• API Key: Dashboard → Settings → API Keys → Create Key (Skills scope)
• Project ID: Dashboard → Select project → URL /projects/123

Public Skills (10)

Laravel:

1. Create Laravel API Endpoint
2. Laravel Database Migration
3. Write PHPUnit Tests
4. Implement Laravel Queue Job
5. Database Query Optimization

React: 6. Create React Component 7. Create REST API Client

Universal: 8. Git Commit Best Practices 9. API Documentation with OpenAPI 10. Setup Docker Container

288+ technologies supported

Pricing & Limits

Starter ($19/month):
- 5 active skills
- 1,000 skill runs/month
- 50,000 tokens
- $0.05 per additional run

Pro ($69/month):
- 25 active skills
- 10,000 skill runs/month
- 300,000 tokens
- $0.02 per additional run

Enterprise ($199/month):
- Unlimited skills
- Unlimited runs
- 1,000,000 tokens
- Dedicated support

---

What’s Next?

1. Explore All Skills

   Ask your AI: “Show me all available skills with examples”

2. Learn How Skills Work

   Technical deep dive into skill execution and token usage

3. Create Custom Skills

   Encode your team’s patterns into reusable workflows

4. Optimize Your Workflow

   Combine skills for end-to-end workflows (API → Tests → Docs → Commit)

---

Need Help?

Documentation

Technical guides

Support

Email us anytime

Community

Join our Discord