Using Skills
Skills are production-ready code patterns that you can instantly apply to your project. Instead of writing common functionality from scratch, use skills to get battle-tested implementations.
What Are Skills?#
Skills are reusable code templates for common development tasks:
- Authentication flows - OAuth, JWT, sessions
- API endpoints - CRUD operations, validation
- Database patterns - Queries, migrations, transactions
- UI components - Forms, modals, tables
- Payment integration - Stripe, subscriptions
- Testing patterns - Unit, integration, E2E
Each skill includes:
- Complete, working code
- TypeScript types
- Best practices baked in
- Customization options
Using Skills#
Natural Language#
Ask your AI assistant:
Use the api-endpoint skill to create a GET /api/users endpoint with pagination.
Use the prisma-crud skill to create CRUD operations for a Product model.
Use the react-component skill to create a sortable data table.
CLI#
1# List all skills
2bootspring skill list
3
4# Search skills
5bootspring skill search "authentication"
6
7# Show a specific skill
8bootspring skill show auth/clerkMCP Tool#
Use the bootspring_skill tool with query="stripe subscriptions" to find payment patterns.
Skill Categories#
Authentication (auth/)#
| Skill | Description |
|---|---|
auth/clerk | Clerk authentication setup |
auth/nextauth | NextAuth.js configuration |
auth/oauth | OAuth provider integration |
auth/jwt | JWT token implementation |
auth/session | Session management |
auth/mfa | Multi-factor authentication |
auth/rbac | Role-based access control |
Example:
Use the auth/clerk skill to set up Clerk authentication with
protected routes and user profile pages.
Database (database/)#
| Skill | Description |
|---|---|
database/prisma-crud | Prisma CRUD operations |
database/queries | Optimized query patterns |
database/migrations | Migration strategies |
database/transactions | Transaction handling |
database/soft-delete | Soft delete implementation |
database/multi-tenant | Multi-tenancy patterns |
database/full-text-search | Search implementation |
Example:
Use the database/transactions skill to implement a money transfer
operation that updates multiple accounts atomically.
API (api/)#
| Skill | Description |
|---|---|
api/route-handler | Next.js route handlers |
api/server-action | Server actions patterns |
api/validation | Input validation with Zod |
api/rate-limiting | Rate limiting implementation |
api/pagination | Cursor and offset pagination |
api/error-handling | Error handling patterns |
api/middleware | Middleware patterns |
api/versioning | API versioning strategies |
Example:
Use the api/validation skill to add Zod validation to the
/api/users POST endpoint with proper error messages.
Payments (payments/)#
| Skill | Description |
|---|---|
payments/stripe | Stripe setup |
payments/checkout | Checkout flow |
payments/subscriptions | Recurring billing |
payments/webhooks | Webhook handling |
payments/usage-billing | Metered billing |
payments/invoicing | Invoice generation |
Example:
Use the payments/subscriptions skill to implement monthly and
yearly subscription plans with Stripe.
UI (ui/)#
| Skill | Description |
|---|---|
ui/forms | Form patterns with validation |
ui/modals | Modal dialogs |
ui/tables | Data tables with sorting |
ui/navigation | Navigation components |
ui/dropdowns | Dropdown menus |
ui/tabs | Tab interfaces |
ui/file-upload | File upload handling |
ui/command-palette | Command palette (Cmd+K) |
Example:
Use the ui/command-palette skill to add a searchable command
palette triggered by Cmd+K.
Testing (testing/)#
| Skill | Description |
|---|---|
testing/unit | Unit test patterns |
testing/integration | Integration testing |
testing/e2e | End-to-end with Playwright |
testing/mocking | Mocking strategies |
testing/fixtures | Test data fixtures |
testing/coverage | Coverage configuration |
Example:
Use the testing/e2e skill to write Playwright tests for the
checkout flow from cart to confirmation.
Security (security/)#
| Skill | Description |
|---|---|
security/validation | Input sanitization |
security/rate-limiting | Brute force protection |
security/csrf | CSRF protection |
security/headers | Security headers |
security/audit-logging | Audit trail |
security/encryption | Data encryption |
Example:
Use the security/audit-logging skill to log all admin actions
with user, action, and timestamp.
AI (ai/)#
| Skill | Description |
|---|---|
ai/streaming | Streaming AI responses |
ai/embeddings | Vector embeddings |
ai/rag | Retrieval-augmented generation |
ai/function-calling | Tool use patterns |
ai/prompt-engineering | Prompt patterns |
Example:
Use the ai/streaming skill to implement streaming chat responses
from Claude in a Next.js app.
Performance (performance/)#
| Skill | Description |
|---|---|
performance/caching | Caching strategies |
performance/lazy-loading | Lazy loading patterns |
performance/optimization | Performance optimization |
performance/profiling | Profiling setup |
Example:
Use the performance/caching skill to add Redis caching to the
product listing API.
State (state/)#
| Skill | Description |
|---|---|
state/zustand | Zustand state management |
state/react-query | React Query patterns |
state/url-state | URL-based state |
state/context | React Context patterns |
Example:
Use the state/zustand skill to create a shopping cart store
with add, remove, and clear actions.
Deployment (deployment/)#
| Skill | Description |
|---|---|
deployment/docker | Docker configuration |
deployment/ci-cd | CI/CD pipelines |
deployment/monitoring | Monitoring setup |
deployment/environments | Environment management |
Example:
Use the deployment/docker skill to create a multi-stage Dockerfile
for this Next.js application.
Email (email/)#
| Skill | Description |
|---|---|
email/templates | Email templates |
email/transactional | Transactional emails |
email/queues | Email queue handling |
email/tracking | Email analytics |
Example:
Use the email/transactional skill to send welcome emails
with React Email and Resend.
Skill Output Example#
When you use a skill, you get production-ready code. Here's an example:
Request:
Use the api/route-handler skill to create a POST /api/posts endpoint
that creates a blog post with title, content, and author validation.
Generated Code:
1// app/api/posts/route.ts
2
3import { NextRequest, NextResponse } from 'next/server';
4import { z } from 'zod';
5import { prisma } from '@/lib/db';
6import { getAuth } from '@/lib/auth';
7
8// Validation schema
9const createPostSchema = z.object({
10 title: z
11 .string()
12 .min(1, 'Title is required')
13 .max(200, 'Title must be 200 characters or less'),
14 content: z
15 .string()
16 .min(1, 'Content is required')
17 .max(50000, 'Content must be 50000 characters or less'),
18 published: z.boolean().default(false),
19 tags: z.array(z.string()).max(10, 'Maximum 10 tags allowed').optional(),
20});
21
22// Type inference from schema
23type CreatePostInput = z.infer<typeof createPostSchema>;
24
25export async function POST(request: NextRequest) {
26 try {
27 // Authenticate user
28 const { userId } = await getAuth(request);
29 if (!userId) {
30 return NextResponse.json(
31 { error: 'Unauthorized' },
32 { status: 401 }
33 );
34 }
35
36 // Parse and validate body
37 const body = await request.json();
38 const validatedData = createPostSchema.parse(body);
39
40 // Create post
41 const post = await prisma.post.create({
42 data: {
43 title: validatedData.title,
44 content: validatedData.content,
45 published: validatedData.published,
46 tags: validatedData.tags ?? [],
47 authorId: userId,
48 },
49 select: {
50 id: true,
51 title: true,
52 content: true,
53 published: true,
54 tags: true,
55 createdAt: true,
56 author: {
57 select: {
58 id: true,
59 name: true,
60 },
61 },
62 },
63 });
64
65 return NextResponse.json(post, { status: 201 });
66 } catch (error) {
67 // Handle validation errors
68 if (error instanceof z.ZodError) {
69 return NextResponse.json(
70 {
71 error: 'Validation failed',
72 details: error.errors.map((e) => ({
73 field: e.path.join('.'),
74 message: e.message,
75 })),
76 },
77 { status: 400 }
78 );
79 }
80
81 // Log unexpected errors
82 console.error('Create post error:', error);
83
84 return NextResponse.json(
85 { error: 'Internal server error' },
86 { status: 500 }
87 );
88 }
89}Customizing Skills#
Skill Preferences#
Set default preferences in bootspring.config.js:
1// bootspring.config.js
2module.exports = {
3 skills: {
4 preferred: {
5 // Component style
6 components: 'functional', // functional, class
7
8 // Styling approach
9 styling: 'tailwind', // tailwind, css-modules, styled-components
10
11 // State management
12 state: 'zustand', // zustand, redux, context
13
14 // API style
15 api: 'rest', // rest, graphql, trpc
16
17 // Testing framework
18 testing: 'vitest', // vitest, jest
19
20 // Validation library
21 validation: 'zod', // zod, yup, joi
22 },
23 },
24};Custom Skill Templates#
Create your own skill templates:
1// bootspring.config.js
2module.exports = {
3 skills: {
4 templates: {
5 'api-endpoint': './templates/api-endpoint.ts',
6 'react-component': './templates/component.tsx',
7 'prisma-model': './templates/prisma-model.prisma',
8 },
9 },
10};Combining Skills#
Skills work great together. Combine them for complete features:
Example: User Management Feature#
Step 1: Database schema
Use the database/prisma-crud skill for a User model with email,
name, and role fields.
Step 2: API endpoints
Use the api/route-handler skill to create CRUD endpoints for users.
Step 3: Validation
Use the api/validation skill to add input validation to user endpoints.
Step 4: UI
Use the ui/tables skill to create a user management table with
search and pagination.
Step 5: Testing
Use the testing/integration skill to test the user CRUD operations.
Searching Skills#
By Keyword#
bootspring skill search "authentication"
bootspring skill search "stripe"
bootspring skill search "table"By Category#
bootspring skill list --category auth
bootspring skill list --category payments
bootspring skill list --category uiIn Your AI Assistant#
Search Bootspring skills for payment integration options.
What skills are available for implementing real-time features?
Skill Tiers#
| Tier | Available Skills |
|---|---|
| Free | Built-in patterns (55+) |
| Pro | All built-in + External skills catalog |
| Team | All Pro + Custom team skill library |
External Skills (Pro)#
Pro users get access to external skills:
stripe-automation- Advanced Stripe patternsgithub-automation- GitHub API integrationslack-automation- Slack bot patternsposthog-automation- Analytics integrationvercel-automation- Deployment automation- And more...
Best Practices#
1. Check Before Writing#
Before implementing common features, check for a skill:
Search Bootspring skills for [your feature].
2. Customize After Generating#
Skills provide a starting point. Customize for your needs:
Use the auth/clerk skill for setup, then modify the user
profile page to include avatar upload.
3. Combine with Agents#
Use skills for code, agents for guidance:
Use the database-expert agent to help me understand the
prisma-crud skill output and optimize the queries.
4. Keep Skills Updated#
Skills are versioned. Check for updates:
bootspring skill check-updatesTroubleshooting#
"Skill not found"#
Check available skills:
bootspring skill list | grep [keyword]"Generated code doesn't match my project"#
Update your preferences:
1// bootspring.config.js
2module.exports = {
3 skills: {
4 preferred: {
5 styling: 'css-modules', // if not using Tailwind
6 testing: 'jest', // if using Jest
7 },
8 },
9};"Need a skill that doesn't exist"#
Request it or use an agent:
Use the frontend-expert agent to create a custom date picker
component since there's no skill for it.
Next Steps#
- Workflows Introduction - Automate multi-step processes
- Skills Reference - Complete skill documentation
- Patterns Library - Browse all patterns