BuilderIO
186 verified skills8,444 total stars
booker
Public booking flow — the state machine, animations, and URL/app-state sync.
tools108
scheduling-basics
Core concepts of the scheduling package — event types, schedules, bookings, hosts, teams, and how they compose.
tools46
integrations
Calendar + video provider integrations — Google Calendar, Office 365, Zoom, built-in video, Google Meet — and how to write new ones.
development46
team-scheduling
Team event types, round-robin assignment, collective bookings, host weights, and no-show calibration.
tools46
slot-engine
The pure `computeAvailableSlots` function — inputs, outputs, invariants, and debugging guide.
development46
event-types
How event types work — fields, scheduling types, tabs in the editor, and the full set of configurable options.
tools46
routing-forms
ChiliPiper-style pre-booking forms that route prospects to the right event type based on their answers.
tools46
workflows
Trigger-based automations — reminders, follow-ups, webhooks — across the booking lifecycle.
tools46
bookings
Booking lifecycle — pending, confirmed, rescheduled, cancelled — plus attendees, references, no-shows, and reminders.
tools46
inline-embeds
How to render interactive previews of app screens inline in agent chat via sandboxed iframes. Covers the `embed` fence syntax, the `postNavigate` pop-out helper, and when to prefer an embed over prose / a static image.
tools46
embeds
Inline, popup, and floating-button embeds — snippet generation and theming.
tools46
availability
How schedules, weekly rules, date overrides, travel schedules, and out-of-office entries combine to determine when someone is bookable.
data-ai46
server-plugins
Framework server plugins and the `/_agent-native/` route namespace. Use when adding a custom server plugin, deciding whether to create an `/api/` route vs an action, or debugging auto-mounted framework routes.
tools45
ship
Commit all local changes, run prep, push, check CI, and address PR feedback
testing45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
security
Secure coding guide for agent-native apps. Covers input validation, SQL injection prevention, XSS, secrets management, auth patterns, data scoping, and A2A security. Read this when generating any code that handles user data.
development45
packages/core/src/templates/workspace-core/.agents/skills/company-policies
--- name: company-policies description: {{APP_TITLE}}-wide policies the agent must enforce for every app — data handling, PII, approval flows, compliance rules. --- # {{APP_TITLE}} Company Policies Every app in the workspace shares these policies. Read this skill before taking any action that touches customer data, external services, or deployed state. ## Data handling - **PII minimization.** Only load the fields you actually need. Never `SELECT *` on a table that contains customer records
testing45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
data-querying
General guidance on querying data sources, using existing scripts vs ad-hoc queries, filtering patterns, and generating charts for the analytics app.
data-ai45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
apollo
Enrich contacts and companies via Apollo.io for prospecting and sales intelligence. Use this skill when the user asks about contact details, company research, or finding decision-makers.
testing45
charts
Generate inline chart images (PNG) for embedding in chat responses. Use this skill when you need to create bar, line, or area charts for data visualization in chat.
data-ai45
dataforseo
Query keyword rankings, search volume, and SEO metrics via DataForSEO. Use this skill when the user asks about SEO performance, keyword rankings, or organic search data.
data-ai45
dbt
dbt (data build tool) project structure, SQL patterns, and best practices for the analytics warehouse. Use this skill when working with dbt models, testing SQL queries, or creating new analytical tables.
tools45
gcloud
Monitor Google Cloud Run services and Cloud Functions health, metrics, and logs. Use this skill when the user asks about service health, request counts, latencies, or cloud infrastructure.
development45
github
Search and read GitHub PRs, issues, and code across the YourOrg org. Use this skill when the user asks about pull requests, code reviews, or GitHub issues.
development45
grafana
Query Grafana dashboards and Prometheus metrics for service health, LLM latency, and infrastructure monitoring. Use this skill when the user asks about service health, monitoring, alerts, or performance metrics.
devops45
hubspot
Query HubSpot CRM for deals, contacts, companies, and sales metrics. Use this skill when the user asks about sales pipeline, deal status, or customer CRM data.
devops45
jira
Search and analyze Jira tickets, sprints, and project analytics. Use this skill when the user asks about tickets, bugs, sprint tracking, or engineering work.
data-ai45
learn
Extract key learnings from the current chat thread and save them to docs/learnings.md. Use this skill when the user types "/learn" or asks to save learnings from the conversation.
documentation45
sentry
Track errors and issues across your projects via Sentry. Use this skill when the user asks about errors, exceptions, error trends, or application health.
tools45
availability-booking
How the booking system works: checking availability, managing booking links, configuring availability settings, and the public booking URL pattern.
testing45
event-management
How to create, search, and list calendar events via Google Calendar. Covers the list-events, search-events, and create-event scripts, date format patterns, and the --google flag.
development45
real-time-sync
How to keep the UI in sync with agent changes via polling. Use when wiring query invalidation for new data models, debugging UI not updating, or understanding jitter prevention.
development45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
storing-data
How and where to store application data. Use when adding new data models, deciding between settings vs Drizzle tables, reading/writing app config, or working with application state.
testing45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
real-time-sync
How to keep the UI in sync with agent changes via polling. Use when wiring query invalidation for new data models, debugging UI not updating, or understanding jitter prevention.
development45
form-publishing
Form lifecycle management: draft, published, closed. Use when publishing forms, understanding public URLs, configuring captcha, or managing form branding.
tools45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, or applications. Generates creative, polished UI that avoids generic AI aesthetics.
development45
issue-transitions
How to change issue status in Jira. Use when transitioning issues between workflow states (e.g., To Do -> In Progress -> Done).
tools45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
sprint-workflow
Sprint and board management in Jira. Use when working with sprints, boards, or understanding the board-sprint-issue hierarchy.
tools45
templates/macros/.agents/skills/update-calories
# Update Macros Skill When the user sends a voice command or short message to log food, exercise, or weight: 1. Parse the intent: ADD, EDIT, or DELETE 2. Execute immediately with the appropriate action (log-meal, log-exercise, log-weight, edit-item, delete-item) 3. **ALWAYS estimate and include protein, carbs, and fat** — even if the user only provides calories or a food name 4. Respond with a single line confirmation showing macros 5. Do NOT ask for confirmation or explain reasoning 6. Do NOT
testing45
templates/mail/.agents/skills/email-drafts
# Email Drafts Create, edit, and manage email drafts. Each draft is stored as an application state entry keyed `compose-{id}`. The UI watches for changes via SSE and updates the compose panel in real time. ## Storage Drafts are stored in the `application_state` SQL table via `writeAppState("compose-{id}", draft)` from `@agent-native/core/application-state`. Each entry is one draft. Multiple drafts can exist simultaneously — they appear as tabs in the compose panel. ## Schema ```json { "id
documentation45
candidate-management
Search, view, and create candidates in Greenhouse. Use when working with candidate data, searching for candidates, or creating new candidates.
data-ai45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, or applications. Generates creative, polished UI that avoids generic AI aesthetics.
development45
interview-scheduling
Working with scheduled interviews in Greenhouse. Use when listing interviews, checking upcoming schedules, or understanding interview data.
testing45
storing-data
How and where to store application data. Use when adding new data models, deciding between settings vs Drizzle tables, reading/writing app config, or working with application state.
testing45
create-deck
How to create a new deck with slides from scratch. Read this before creating any deck. Contains exact HTML templates for every slide layout — no codebase exploration needed.
development45
deck-management
How decks are stored in SQL, how to create/read/update/delete decks. Read before working with deck data.
data-ai45
slide-editing
How to edit individual slides -- content formatting, HTML styling rules, updating slide content in the database.
development45
slide-images
Image generation workflow -- generate-image, image-search, logo-lookup scripts. Style reference patterns.
development45
animation-tracks
Track-based animation system. AnimationTrack, AnimatedProp types, findTrack/trackProgress/getPropValue helpers. Read before editing animations.
tools45
composition-management
How to create and register compositions. The registry pattern, CompositionEntry type, track system. Read before adding or modifying compositions.
tools45
remotion-best-practices
Best practices for Remotion - Video creation in React
development45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
storing-data
How and where to store application data. Use when adding new data models, deciding between settings vs Drizzle tables, reading/writing app config, or working with application state.
testing45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
new-branch
Stash, pull latest main, and create a new branch — fast, to minimize disruption to concurrent agents
testing45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
real-time-sync
How to keep the UI in sync with agent changes via polling. Use when wiring query invalidation for new data models, debugging UI not updating, or understanding jitter prevention.
development45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
storing-data
How and where to store application data. Use when adding new data models, deciding between settings vs Drizzle tables, reading/writing app config, or working with application state.
testing45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
real-time-sync
How to keep the UI in sync with agent changes via polling. Use when wiring query invalidation for new data models, debugging UI not updating, or understanding jitter prevention.
development45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
real-time-sync
How to keep the UI in sync with agent changes via polling. Use when wiring query invalidation for new data models, debugging UI not updating, or understanding jitter prevention.
development45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
real-time-sync
How to keep the UI in sync with agent changes via polling. Use when wiring query invalidation for new data models, debugging UI not updating, or understanding jitter prevention.
development45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
real-time-sync
How to keep the UI in sync with agent changes via polling. Use when wiring query invalidation for new data models, debugging UI not updating, or understanding jitter prevention.
development45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
client-side-routing
How to add routes without remounting the app shell. Use when adding a new route, fixing agent sidebar reloads on navigation, or choosing between `root.tsx` layout and pathless `_app.tsx` layout patterns.
tools45
commonroom
Look up community member engagement and signals via Common Room. Use this skill when the user asks about community activity, member engagement, or community signals.
tools45
context-awareness
How the agent knows what the user is looking at. Use when exposing UI state to the agent, implementing view-screen or navigate scripts, wiring navigation state, or debugging agent context issues.
development45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
form-building
How to create and structure forms. Use when creating a new form, adding fields, modifying form structure, or understanding field types and their JSON schema.
development45
form-responses
How to view, export, and analyze form responses. Use when the user asks about submitted data, wants to export responses, or needs response analytics.
data-ai45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
frontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use when building web components, pages, artifacts, posters, or applications (websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished UI that avoids generic AI aesthetics.
development45
gong
Search sales call recordings, transcripts, and participants via Gong. Use this skill when the user asks about sales calls, customer conversations, or call transcripts.
development45
issue-management
CRUD operations for Jira issues. Use when creating, updating, viewing, or searching issues. Covers create-issue, update-issue, get-issue scripts and the issue data model.
data-ai45
jql-queries
How to construct JQL (Jira Query Language) queries. Use when searching for issues with complex filters, or when the user asks for issues by type, status, assignee, sprint, label, or date ranges.
databases45
notion-integration
How Notion sync works. Covers connecting, linking pages, pulling from Notion, pushing to Notion, and checking sync status.
testing45
packages/pinpoint/.agents/skills/pinpoint
# Pinpoint — Visual Feedback Tool You are an agent with access to Pinpoint, a visual feedback and annotation tool. Users annotate UI elements on web pages and send structured feedback to you. ## Reading Annotations Pins are stored as JSON files in `data/pins/{uuid}.json`: ```json { "id": "uuid", "pageUrl": "/dashboard", "comment": "This button color is wrong", "element": { "tagName": "button", "selector": ".sidebar button.primary", "classNames": ["primary", "btn"] },
tools45
pipeline-workflow
Pipeline stages and candidate progression in Greenhouse. Use when advancing, moving, or rejecting candidates. Critical: applicationId (not candidateId) is used for all pipeline moves.
testing45
portability
How to keep template code database-agnostic and hosting-agnostic. Use when defining schemas, writing raw SQL, creating server routes, or anything that could leak a SQLite-only, Postgres-only, or Node-only assumption.
development45
pylon
Look up customer support tickets and account history via Pylon. Use this skill when the user asks about support tickets, customer issues, or support history.
tools45
real-time-collab
Multi-user collaborative editing with Yjs CRDT and live cursors. Use when adding real-time collaborative editing to a template, debugging sync issues, or understanding how the agent and humans edit documents simultaneously.
development45
real-time-collab
How to enable multi-user collaborative editing with Yjs CRDT, TipTap Collaboration extension, live cursors, and agent-driven edits.
tools45
real-time-sync
How to keep the UI in sync with agent changes via polling. Use when wiring query invalidation for new data models, debugging UI not updating, or understanding jitter prevention.
development45
remotion-best-practices
Best practices for Remotion - Video creation in React
development45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts.
development45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
slack
Search Slack messages and read channel history across your workspaces. Use this skill when the user asks about Slack conversations, channel messages, or internal communications.
business45
storing-data
How to store application data in agent-native apps. All data lives in SQL. Use when adding data models, deciding where to store data, or reading/writing application data.
testing45
storing-data
How and where to store application data. Use when adding new data models, deciding between settings vs Drizzle tables, reading/writing app config, or working with application state.
testing45
storing-data
How and where to store application data. Use when adding new data models, deciding between settings vs Drizzle tables, reading/writing app config, or working with application state.
testing45
storing-data
How and where to store application data. Use when adding new data models, deciding between settings vs Drizzle tables, reading/writing app config, or working with application state.
testing45
storing-data
How and where to store application data. Use when adding new data models, deciding between settings vs Drizzle tables, reading/writing app config, or working with application state.
testing45
stripe
How to connect to and query the Stripe API for analytics data.
development45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
notion
Access the Notion content calendar and page data for editorial planning. Use this skill when the user asks about the content calendar, blog planning, or editorial schedule.
data-ai45
a2a-protocol
How agents call other agents via the A2A (agent-to-agent) JSON-RPC protocol. Use when enabling inter-agent communication, exposing agent skills to other agents, or calling external agents from scripts.
data-ai45
actions
How to create and run agent actions. Actions are the single source of truth for app operations — the agent calls them as tools, the frontend calls them as HTTP endpoints. Use when creating a new action, adding an API integration, or wiring up frontend data fetching.
tools45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
adhoc-analysis
How to conduct ad-hoc analyses: gather data from multiple sources, synthesize findings, save reusable analysis artifacts that anyone can re-run for fresh results.
data-ai45
agent-engines
How to inspect and configure the AI engine (model provider) powering the agent. Use when the user asks to switch models, check which engine is active, test a new provider, or register a custom engine.
testing45
authentication
How auth works in agent-native apps. Use when wiring login/signup, configuring auth modes, setting up organizations, protecting routes, or debugging session issues.
development45
bigquery
Query BigQuery for analytics events, signups, pageviews, subscriptions, and user data. Use this skill when the user asks about metrics, funnels, user activity, or customer usage data.
data-ai45
candidate-analysis
AI analysis workflow for candidates. Use when analyzing resumes, comparing candidates, generating interview questions, or managing analysis notes.
data-ai45
document-editing
How to create, read, update, and delete documents. Covers the document scripts, markdown content model, parent-child hierarchy, and position ordering.
documentation45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
dashboard-management
How dashboards are stored, created, and modified. Covers the settings key pattern, layout model, and config structure for analytics dashboards.
data-ai45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
capture-learnings
Capture and apply accumulated knowledge in learnings.md. Use when the user corrects a mistake, when debugging reveals unexpected behavior, or when an architectural decision should be recorded for future reference.
development45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
security
Data security model, user/org scoping, and auth patterns. Use when adding tables with user data, implementing multi-user features, setting up A2A cross-app calls, or reviewing data access patterns.
testing45
actions
How to create and run agent-callable actions in actions/. Use when creating a new action, adding an API integration, implementing a complex agent operation, or running pnpm action commands.
development45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
adding-a-feature
The four-area checklist every new feature must complete. Use when adding any feature, integration, or capability to ensure the agent and UI stay in parity.
testing45
babysit-pr
Monitor a PR, fix feedback and CI failures until fully green for 30 min. Run with /babysit-pr <number>
testing45
capture-learnings
Capture and apply accumulated knowledge via structured memory. Use when the user gives feedback, shares preferences, corrects a mistake, or when you discover something worth remembering for future conversations.
databases45
create-skill
How to create new skills for an agent-native app. Use when adding a new skill, documenting a pattern the agent should follow, or creating reusable guidance for the agent.
documentation45
delegate-to-agent
How to delegate all AI work to the agent chat. Use when delegating AI work from UI or scripts to the agent, when tempted to add inline LLM calls, or when sending messages to the agent from application code.
development45
onboarding
How to register user-facing setup steps (API keys, OAuth, connecting third-party services) for the sidebar setup checklist. Use when adding a feature that needs initial user configuration.
development45
qa
Autonomous QA testing across template apps using Playwright. Use when testing apps end-to-end, finding and fixing bugs, or running a QA sweep. Invoke as /qa with optional --apps and --focus args.
testing45
real-time-sync
How to keep the UI in sync with agent changes via polling. Use when wiring query invalidation for new data models, debugging UI not updating, or understanding jitter prevention.
development45
recurring-jobs
Scheduled tasks the agent runs on a cron schedule. Use when a user asks for something recurring ("every morning", "daily", "weekly"), when creating or updating jobs, or when debugging the job scheduler.
development45
security
Secure coding practices for agent-native apps: input validation, SQL injection, XSS, secrets, data scoping, and auth. Use when writing any action, route, or component that touches user data or external input.
testing45
self-modifying-code
How the agent can modify the app's own source code. Use when the agent needs to edit components, routes, styles, or scripts, when designing UI for agent editability, or when deciding what the agent should and shouldn't modify.
development45