Introduction

Custom AI coding workflows matched to your tech stack. Stop re-explaining best practices. Start shipping consistent code.

Before ULPI Skills

Your AI keeps reinventing the wheel:

• AI generates different code structure every time
• You explain best practices repeatedly
• Code reviews find the same issues
• New team members don’t know company patterns
• AI forgets testing, documentation, edge cases
• 2 hours lost per feature on rework and review

Sound familiar?

“I asked Claude to create an API endpoint. It forgot validation, didn’t add tests, and used a different pattern than our other 40 endpoints. I spent an hour fixing it to match our standards.”

— Every developer using AI assistants

After ULPI Skills

Your AI follows your exact patterns:

• ✅ Consistent code structure every time
• ✅ Best practices encoded in reusable workflows
• ✅ Testing, documentation, edge cases included
• ✅ Team patterns followed automatically
• ✅ New team members generate compliant code instantly
• ✅ Zero time spent on rework

Results from our customers:

• 78% reduction in code review iterations
• 2 hours saved per feature (no rework)
• 100% consistency across team
• 3x faster onboarding for new developers

---

Why ULPI Skills?

Traditional prompts fail because AI assistants have no memory. You explain your patterns once, but the next conversation, you start from scratch.

Skills solve this: Step-by-step workflows that encode your best practices, matched to your tech stack.

Consistent Patterns

Same workflow = same code structure

Every time, guaranteed

No more variations

Built-In Best Practices

Industry standards encoded

Testing included by default

Edge cases handled

Tech Stack Aware

Only see relevant skills

Matched to your frameworks

288+ technologies supported

Team Knowledge

Custom skills for your team

Company patterns encoded

Instant onboarding

---

How It Works

1. Ask Your AI to Use a Skill

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

   That’s it. Your AI knows exactly what to do.

2. AI Follows Step-by-Step Workflow

   AI: Following Create Laravel API Endpoint skill...
   
       ✅ Step 1: Creating FormRequest validation
       ✅ Step 2: Building API Resource transformation
       ✅ Step 3: Implementing Service layer logic
       ✅ Step 4: Creating API Controller
       ✅ Step 5: Adding routes with rate limiting
       ✅ Step 6: Writing feature tests
   
       Complete! Generated 6 files, all tested.
   

   Every step executed. Nothing forgotten.

3. Review Consistent, Production-Ready Code

   All code follows your patterns:

   • ✅ Validation rules complete
   • ✅ Tests included
   • ✅ Documentation added
   • ✅ Edge cases handled
   • ✅ Security best practices

   Zero rework needed.

---

10 Public Skills Included

Every subscription includes 10 production-ready skills for common development tasks:

🔌 Create Laravel API Endpoint

Build complete RESTful API endpoints in Laravel

What it generates:

• FormRequest validation (with custom rules)
• API Resource transformation (JSON formatting)
• Service layer business logic
• Controller with CRUD operations
• Routes with rate limiting
• Feature tests (100% coverage)

Example:

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

AI generates:
✅ app/Http/Requests/StorePostRequest.php
✅ app/Http/Resources/PostResource.php
✅ app/Services/PostService.php
✅ app/Http/Controllers/API/PostController.php
✅ routes/api.php (5 routes)
✅ tests/Feature/PostControllerTest.php (12 tests)

Best For: Backend developers, API development

Tech Stack: PHP, Laravel

⚛️ Create React Component

Build production-ready React components

What it generates:

• TypeScript prop definitions
• State management with hooks
• CSS modules styling
• Component tests (Jest/RTL)
• Barrel exports
• Accessibility (ARIA attributes)

Example:

You: "Use Create React Component skill for UserProfile"

AI generates:
✅ components/UserProfile/UserProfile.tsx
✅ components/UserProfile/UserProfile.module.css
✅ components/UserProfile/UserProfile.test.tsx
✅ components/UserProfile/index.ts (barrel export)
✅ components/UserProfile/UserProfile.stories.tsx

Best For: Frontend developers, UI development

Tech Stack: JavaScript, TypeScript, React, Next.js

🗄️ Laravel Database Migration

Design and manage database schemas

What it generates:

• Schema design with proper types
• Foreign key constraints
• Composite indexes (performance)
• Data transformations
• Rollback support
• Migration tests

Best For: Database design, schema changes

Tech Stack: PHP, Laravel, MySQL, PostgreSQL

📝 Git Commit Best Practices

Write professional commit messages

Follows: Conventional Commits standard

Format:

type(scope): subject

body (optional)

footer (optional)

Benefits:

• Semantic versioning compatible
• Auto-changelog generation
• Clear commit history

Best For: All developers, version control

Tech Stack: Universal (all projects)

📖 API Documentation with OpenAPI

Document REST APIs with OpenAPI 3.0

What it generates:

• OpenAPI 3.0 specification
• Reusable schema components
• Authentication flows
• Request/response examples
• Error handling documentation
• Auto-generated Swagger UI

Best For: API documentation, developer experience

Tech Stack: Universal (all REST APIs)

🧪 Write PHPUnit Tests

Create comprehensive tests for Laravel

What it generates:

• Feature tests for endpoints
• Unit tests for services
• Database testing with factories
• Queue job testing
• Mock external services
• Code coverage reports

Best For: Testing, quality assurance

Tech Stack: PHP, Laravel, PHPUnit, Pest

🐳 Setup Docker Container

Containerize your application

What it generates:

• Multi-stage Dockerfile
• docker-compose.yml setup
• Service dependencies (DB, cache)
• Volume management
• Health checks
• Production optimization

Best For: DevOps, deployment

Tech Stack: Docker, Docker Compose

⚡ Database Query Optimization

Identify and fix slow queries

What it does:

• Analyze queries with EXPLAIN
• Recommend index creation
• Fix N+1 query problems
• Add eager loading
• Implement query caching
• Batch processing patterns

Best For: Performance optimization

Tech Stack: MySQL, PostgreSQL, Laravel

⏰ Implement Laravel Queue Job

Build asynchronous background jobs

What it generates:

• Queue job implementation
• Retry logic with exponential backoff
• Job middleware (rate limiting)
• Batch processing
• Supervisor configuration
• Job tests

Best For: Background processing, async tasks

Tech Stack: PHP, Laravel, Redis

🔌 Create REST API Client

Build robust HTTP API clients

What it generates:

• TypeScript HTTP client
• Retry logic (exponential backoff)
• Authentication handling
• Error normalization
• Request/response logging
• Fully typed API methods

Best For: API integration, external services

Tech Stack: JavaScript, TypeScript, Node.js

---

Tech Stack Matching

Skills automatically filter based on your repository’s detected technologies.

Laravel Project

Technologies detected:

• PHP 8.2
• Laravel 11
• MySQL 8.0
• Redis

Skills you see:

• ✅ Create Laravel API Endpoint
• ✅ Laravel Database Migration
• ✅ Write PHPUnit Tests
• ✅ Laravel Queue Job
• ✅ Database Query Optimization
• ✅ Git Commit Best Practices
• ✅ API Documentation
• ✅ Setup Docker Container

Skills hidden:

• ❌ Create React Component (not relevant)
• ❌ REST API Client (frontend tool)

React/Next.js Project

Technologies detected:

• TypeScript 5.0
• React 18
• Next.js 14
• Node.js 20

Skills you see:

• ✅ Create React Component
• ✅ REST API Client
• ✅ Git Commit Best Practices
• ✅ API Documentation
• ✅ Setup Docker Container

Skills hidden:

• ❌ Create Laravel API Endpoint (backend only)
• ❌ Laravel Database Migration (Laravel only)
• ❌ Write PHPUnit Tests (PHP only)

Full-Stack Project

Technologies detected:

• Laravel (backend)
• React (frontend)
• MySQL
• Redis
• Docker

Skills you see:

• ✅ All 10 public skills (both backend and frontend)

288+ Technologies Supported:

• Frameworks: Laravel, React, Next.js, Vue, Angular, NestJS, Express, Django, FastAPI, Spring Boot
• Languages: PHP, JavaScript, TypeScript, Python, Java, Go, Ruby, C#, Rust
• Databases: MySQL, PostgreSQL, MongoDB, Redis, DynamoDB, Cassandra

Learn About Tech Stack Matching →

---

Custom Skills: Encode Your Team Patterns

Beyond the 10 public skills, create unlimited custom skills for your team’s specific workflows.

Use Case: Deployment

Problem: Every developer deploys differently

Solution: Create “Deploy to Staging” skill

# Deploy to Staging

1. Run test suite
   ```bash
   npm test

2. Build production assets

   npm run build
   

3. Create deployment branch

   git checkout -b deploy/staging-$(date +%Y%m%d)
   

4. Push to staging

   git push staging main
   

5. Run database migrations

   ssh staging "cd /app && php artisan migrate --force"
   

6. Verify deployment

   curl https://staging.example.com/health
   

7. Notify team Post to Slack #deployments channel

**Result:** Every developer deploys the same way, zero mistakes
</Tab>

<Tab title="Use Case: Code Review">
**Problem:** Code reviews miss common issues

**Solution:** Create "Pre-Review Checklist" skill

```markdown
# Pre-Review Checklist

Before creating PR, verify:

1. **Tests Pass**
   - All tests green
   - Coverage > 80%

2. **Code Quality**
   - Linter passing
   - No console.logs
   - No commented code

3. **Security**
   - No hardcoded secrets
   - SQL injection prevention
   - XSS protection

4. **Documentation**
   - README updated
   - API docs current
   - Changelog entry

5. **Performance**
   - No N+1 queries
   - Images optimized
   - Bundle size acceptable

Result: 78% reduction in code review iterations

Use Case: Onboarding

Problem: New developers don’t know company patterns

Solution: Create company-specific skills

• “Create Feature Following Company Standards”
• “Set Up Local Development Environment”
• “Deploy to Our Infrastructure”
• “Write Docs in Our Format”

Result: New developers productive on day 1

Common Custom Skills:

• Deployment workflows (staging, production, rollback)
• Code review checklists
• Security scanning procedures
• Company API integration patterns
• Testing standards
• Infrastructure provisioning
• Monitoring setup

Learn How to Create Custom Skills →

---

Before & After: Real Impact

Without Skills

Task: “Create /api/posts endpoint”

Developer experience:

You: "Create a REST API endpoint for /api/posts"

AI: [generates code]

You review:
❌ Missing validation
❌ No tests
❌ Different pattern than other endpoints
❌ Forgot rate limiting
❌ No API documentation

You: "Add validation, tests, follow our pattern..."

AI: [generates more code]

You review again:
❌ Tests incomplete
❌ Still different pattern

You: "Use our PostService pattern, add missing tests..."

[45 minutes later, 3 iterations]

✅ Finally acceptable code

Time: 45 minutes of back-and-forth

With Skills

Task: “Create /api/posts endpoint”

Developer experience:

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

AI: Following the skill...
    ✅ Created StorePostRequest.php (validation)
    ✅ Created PostResource.php (transformation)
    ✅ Created PostService.php (business logic)
    ✅ Created PostController.php (endpoints)
    ✅ Added routes with rate limiting
    ✅ Created PostControllerTest.php (12 tests)

    Complete! All tests passing.

You review:
✅ Validation complete
✅ Tests comprehensive (100% coverage)
✅ Matches our pattern exactly
✅ Rate limiting included
✅ Documentation added

[Code ready to merge]

Time: 2 minutes total

Savings: 43 minutes (96% faster)

---

Pricing

Starter

$19/month

• 5 active skills
• 1,000 skill runs/month
• 50,000 tokens included
• 10 public skills
• Unlimited custom skills (create)
• MCP integration
• 14-day free trial

Best for: Solo developers, small projects

Overage: $0.05 per additional run

Pro

$69/month

• 25 active skills
• 10,000 skill runs/month
• 300,000 tokens included
• 10 public skills
• Unlimited custom skills (create)
• MCP integration
• Priority support
• 14-day free trial

Best for: Professional teams

Overage: $0.02 per additional run

Most popular: 64% of customers choose Pro

Enterprise

$199/month

• Unlimited active skills
• Unlimited skill runs
• 1,000,000 tokens included
• 10 public skills
• Unlimited custom skills (create)
• MCP integration
• Dedicated support
• SLA guarantee
• Custom integrations

Best for: Large organizations

Contact sales: [e-mail]

Save with Bundles: Subscribe to multiple ULPI products together (Documentation, Skills, Memory, Coordination, Hooks, Tasks) and save 12-20%. Choose from 33 bundle combinations.

View Complete Pricing →

---

Customer Success Story

TechCorp: 25-person development team, mixed tech stack (Laravel + React)

Before ULPI Skills:

• Every developer had their own coding style
• Code reviews took 2-3 iterations per PR
• New developers took 2 weeks to learn patterns
• API endpoints inconsistent across the app

After ULPI Skills (90 days):

• ✅ 78% reduction in code review iterations (2.8 → 0.6 per PR)
• ✅ 2 hours saved per feature (no rework)
• ✅ 3x faster onboarding (2 weeks → 3 days)
• ✅ 100% consistency across 150+ endpoints
• ✅ 487 features shipped using skills

“Skills transformed our team. New developers generate production-ready code on day 1. Code reviews are now just sanity checks instead of teaching sessions. We shipped 2 major features last month that would have taken us 6 months before.”

— Michael Rodriguez, Engineering Manager at TechCorp

---

Quick Start

Getting Started

Set up Skills in 10 minutes

Connect repos, configure IDE, use first skill

How Skills Work

Technical deep dive

Understand skill execution, token usage

Custom Skills

Create team workflows

Encode your company patterns

MCP Setup

Configure your IDE

29+ AI assistants supported

---

Frequently Asked Questions

How many custom skills can I create?

Unlimited for all plans.

You can create as many custom skills as your team needs. Plan limits only affect how many skills can be active (ready to use) at once.

Example:

• Starter plan: Create 100 skills, 5 active at a time
• Swap which skills are active anytime (instant)

Can I share skills with my team?

Yes.

Custom skills you create are available to all members of your ULPI organization. Public skills are available to everyone.

What if my tech stack isn't detected?

You can manually add technologies in the ULPI dashboard.

We support 288+ technologies and add more regularly.

Can’t find your tech? Email [e-mail] and we’ll add it within 48 hours.

How do skill runs count against my limit?

1 skill run = 1 complete execution

If your AI follows all steps in “Create Laravel API Endpoint”, that’s 1 run.

Example: If you use the skill 10 times in a month, that’s 10 runs.

What happens if I exceed my run limit?

Skills continue to work, and you’re billed for additional runs at your plan’s overage rate:

• Starter: $0.05 per run
• Pro: $0.02 per run
• Enterprise: Unlimited

You can upgrade anytime for higher limits and lower per-run costs.

Can I edit public skills?

No. Public skills are maintained by ULPI and updated regularly.

However: You can create a custom skill based on a public skill and modify it for your needs.

Do skills work without MCP?

Skills are designed for MCP-compatible AI assistants.

Without MCP:

• You can view skill content in the dashboard
• You can manually follow the steps
• Your AI can’t use them automatically

With MCP:

• AI automatically follows all steps
• Zero manual intervention

Which AI assistants support skills?

29+ MCP-compatible clients:

• Claude Desktop
• VSCode (with MCP extension)
• Cursor
• Windsurf
• Zed
• Cline
• Continue
• Aider
• And 21+ more

View Complete List →

---

What’s Next?

1. Set Up Skills

   Follow the getting started guide to connect repositories and configure your IDE in 10 minutes.

2. Use Your First Skill

   Ask your AI: “What skills are available for this project?”

3. Create Custom Skills

   Learn how to create team-specific workflows that encode your company patterns.

---

Need Help?

Documentation

Step-by-step guides

Support

Email us anytime

Community

Join our Discord