AI Ml AI agent skills

8,771 skills in the archive. Read a skill’s instructions or open its original repository.

• Bankr

  by @alsk1992

  AI-powered crypto trading via natural language through Bankr API

• Kamino

  by @alsk1992

  Kamino Finance — Solana lending, borrowing, and liquidity vaults

• Drift Sdk

  by @alsk1992

  Drift Protocol perpetual futures trading on Solana (direct SDK)

• Jupiter

  by @alsk1992

  Jupiter DEX aggregator - swaps, limit orders, and DCA on Solana

• Feeds

  by @alsk1992

  Real-time market data feeds from 8 prediction market platforms

• Mcp

  by @alsk1992

  Model Context Protocol server management and tool integration

• Drift

  by @alsk1992

  Drift Protocol - perpetuals and prediction markets on Solana

• Arbitrage

  by @alsk1992

  Automated cross-platform arbitrage detection and monitoring

• Mm

  by @alsk1992

  Market making - two-sided quoting with inventory management

• News

  by @alsk1992

  Monitor news and correlate with prediction market movements

• Auto Reply

  by @alsk1992

  Automatic response rules, patterns, and scheduled messages

• Integrations

  by @alsk1992

  External data sources, connectors, and custom data streams

• Memory

  by @alsk1992

  Persistent memory system for preferences, facts, and notes

• Mev

  by @alsk1992

  MEV protection against sandwich attacks and front-running

• Copy Trading Solana

  by @alsk1992

  Copy trade Solana wallets - mirror trades automatically

• History

  by @alsk1992

  Trade history tracking, sync, and performance analytics

• Meteora

  by @alsk1992

  Meteora DLMM - dynamic liquidity market maker on Solana

• Alerts

  by @alsk1992

  Create and manage price alerts for prediction markets

• Metrics

  by @alsk1992

  System metrics, telemetry, and performance monitoring

• Monitoring

  by @alsk1992

  System health monitoring, alerts, and error tracking

• Bridge

  by @alsk1992

  Cross-chain token transfers using Wormhole and CCTP

• Embeddings

  by @alsk1992

  Vector embeddings configuration and semantic search

• Agentbets

  by @alsk1992

  AgentBets - AI-native prediction markets on Solana

• Credentials

  by @alsk1992

  Secure credential management for trading platforms

• Automation

  by @alsk1992

  Schedule cron jobs and automate recurring tasks

• Meteora Dbc

  by @alsk1992

  Launch tokens on Meteora dynamic bonding curves

• Mexc Futures

  by @alsk1992

  MEXC Futures trading with DB tracking (No KYC)

• Doctor

  by @alsk1992

  System health diagnostics and troubleshooting

• Features

  by @alsk1992

  Real-time market features and trading signals

• Betfair

  by @alsk1992

  Betfair Exchange sports betting and trading

• Hyperliquid

  by @alsk1992

  Hyperliquid L1 perps DEX (69% market share)

• Dca

  by @alsk1992

  Dollar-cost averaging across all platforms

• Metaculus

  by @alsk1992

  Metaculus forecasting platform (read-only)

• Ledger

  by @alsk1992

  Trade decision audit trail and statistics

• Ai Strategy

  by @alsk1992

  AI Strategy - natural language to trades

• Binance Futures

  by @alsk1992

  Binance Futures trading with DB tracking

• Marginfi

  by @alsk1992

  MarginFi — Solana lending and borrowing

• Bybit Futures

  by @alsk1992

  Bybit Futures trading with DB tracking

• Harden

  by @alsk1992

  VPS security auditing and hardening

• Lighter

  by @alsk1992

  Lighter — Orderbook DEX on Arbitrum

• Blog Post

  by @nteract

  Author a new entry for the Semiotic blog. Use this skill whenever the user asks for a blog post, release summary, chart explainer, or case study to publish at /blog/SLUG.

• Behavioural Analytics

  by @Owl-Listener

  Read funnels, retention curves, and event data as a designer — separating a design problem from a tracking artefact. Use when handed product data you did not design and asked why people drop off. For choosing what to measure,…

• Qual Quant Triangulation

  by @Owl-Listener

  Reconcile what the numbers say with what users say, and design the study that settles it rather than restates it. Use when behavioural data and research findings point different ways. For reading the data on its own, use…

• Accessibility Audit

  by @Owl-Listener

  Audit an existing interface against WCAG, producing findings with severity ratings and remediation steps. Use when you have a design or build to assess now. Not for planning future sessions with assistive-technology users — use…

• Journey Map

  by @Owl-Listener

  Map one persona's end-to-end experience with stages, touchpoints, emotions, and pain points. Use when improving an existing experience. For the multi-channel ecosystem use `experience-map` (ux-strategy); for screen-level paths…

• Design System Governance

  by @Owl-Listener

  Define how the system evolves — contribution model, versioning, deprecation, and change management. Use when multiple teams contribute. For driving uptake use `design-system-adoption` (designer-toolkit); for design file history…

• Animation Principles

  by @Owl-Listener

  Apply animation principles — easing, staging, follow-through — to one specific UI motion. Use when tuning how an animation feels. For product-wide duration and easing tokens use `motion-system` (design-systems); for a full…

• Handoff Spec

  by @Owl-Listener

  Write the implementation handoff — measurements, behaviours, assets, states, and edge cases. Use when engineering picks up the work. For verifying the result afterwards use `design-qa-checklist`; for reusable library components…

• Interfaces That Feel

  by @Owl-Listener

  Apply an emotional resonance lens to a UI that is technically correct but flat, prescribing changes at the copy, motion, and interaction layer. Use when a design tests fine but lands cold. For the polish-perception argument, use…

• Theming System

  by @Owl-Listener

  Design theming architecture — brand variants, dark mode, and high-contrast — mapped through token layers. Use when one system must serve multiple themes. For a single palette use `color-system` (ui-design); for dark mode craft…

• Design Token

  by @Owl-Listener

  Define and organise tokens for colour, spacing, type, and elevation with naming and usage rules. Use when establishing the token layer. For auditing existing usage use `design-token-audit` (designer-toolkit); for multi-brand…

• Navigation Patterns

  by @Owl-Listener

  Select and design a navigation pattern — tabs, drawer, hierarchy, or hub — matched to product structure and user tasks. Use when choosing how users move between sections. For the underlying content structure, use…

• Design Debt Audit

  by @Owl-Listener

  Inventory and prioritise accumulated design inconsistencies across a product. Use when drift has built up over time. For token coverage specifically use `design-token-audit` (designer-toolkit); for WCAG gaps use…

• Motion System

  by @Owl-Listener

  Define motion tokens — durations, easing vocabulary, and reduced-motion handling — for consistency product-wide. Use when standardising motion across a system. For crafting one specific animation, use `animation-principles`…

• Micro Interaction Spec

  by @Owl-Listener

  Specify one micro-interaction completely — trigger, rules, feedback, loops, and modes. Use when handing a single interaction to engineering. For motion craft alone use `animation-principles`; for multi-state components use…

• Usability Test Plan

  by @Owl-Listener

  Design a usability study — research questions, methodology, participant criteria, metrics, and facilitation guide. Use when planning the study as a whole. For writing the task scenarios inside it, use `test-scenario`…

• User Persona

  by @Owl-Listener

  Build research-grounded personas with goals, frustrations, and behavioural patterns. Use when decisions need a consistent user reference. For one session's emotional snapshot use `empathy-map`; for motivation framing use…

• Loading States

  by @Owl-Listener

  Design waiting experiences — spinners, skeletons, optimistic updates, and progressive reveal. Use when content takes time to arrive. For the latency budget itself use `doherty-threshold`; for success confirmation use…

• Component Spec

  by @Owl-Listener

  Specify one component — props, states, variants, accessibility, and usage rules. Use when defining a library component. For the reusable doc scaffold use `documentation-template`; for a problem-solution pattern use…

• Affinity Diagram

  by @Owl-Listener

  Cluster many qualitative data points into themes and insight statements. Use when synthesising across multiple sessions or sources. For a single transcript use `summarize-interview`; for one segment's inner state use…

• Jakobs Law

  by @Owl-Listener

  Apply Jakob's Law — users expect your product to work like the others they already use. Use when deciding whether to innovate on a familiar pattern. For OS-mandated conventions specifically, use `platform-conventions` (ui-design).

• Empathy Map

  by @Owl-Listener

  Build a Says, Thinks, Does, Feels map for one user or segment. Use when sharing user understanding quickly. For a composite archetype with goals and behaviours use `user-persona`; for cross-session themes use `affinity-diagram`.

• Feedback Patterns

  by @Owl-Listener

  Design confirmations, status updates, and notifications that tell users an action registered. Use when the system must acknowledge success or change. For waiting states use `loading-states`; for failures use `error-handling-ux`.

• Localization Design

  by @Owl-Listener

  Design for multiple languages, writing directions, and cultural contexts — text expansion, RTL mirroring, and locale formats. Use when shipping beyond one locale. For the words themselves, use `ux-writing` (designer-toolkit).

• Serial Position Effect

  by @Owl-Listener

  Apply the Serial Position Effect — first and last items in a sequence are recalled best. Use when ordering menus, lists, and steps. For emphasising one item regardless of its position, use `von-restorff-effect` (ui-design).

• Doherty Threshold

  by @Owl-Listener

  Apply the Doherty Threshold — keep system response under 400ms to preserve user flow. Use when diagnosing perceived slowness or setting a performance budget. For what to show during unavoidable waits, use `loading-states`.

• Survey Design

  by @Owl-Listener

  Design unbiased survey instruments — question wording, scales, and sampling — to measure attitudes at scale. Use when you need quantitative breadth. For behavioural experiments, use `a-b-test-design` (prototyping-testing).

• Version Control Strategy

  by @Owl-Listener

  Define version control for design files, components, and libraries — branching, naming, and release. Use when file history is chaotic. For design system contribution rules, use `design-system-governance` (design-systems).

• Design Negotiation

  by @Owl-Listener

  Advocate for design quality, scope, and timeline with partners and leadership using evidence and shared goals. Use in the conversation itself. For the commercial vocabulary behind it, use `business-design` (ux-strategy).

• Design Token Audit

  by @Owl-Listener

  Audit token usage across a product for coverage, drift, and hard-coded values. Use when tokens exist and you suspect they are being bypassed. For defining tokens in the first place, use `design-token` (design-systems).

• Design Critique

  by @Owl-Listener

  Facilitate a structured team critique — framing, feedback rules, and actionable outcomes. Use when running a session with people in the room. For a solo expert review, use `heuristic-evaluation` (prototyping-testing).

• Gesture Patterns

  by @Owl-Listener

  Design gesture interactions for touch and pointer — swipe, drag, long-press, and their discoverability. Use when input is gestural. For OS-standard gestures on iOS and Android, use `platform-conventions` (ui-design).

• Peak End Rule

  by @Owl-Listener

  Apply the Peak-End Rule — a flow is remembered by its most intense moment and its last. Use when designing completion, celebration, or cancellation moments. For sustaining engagement mid-flow, use `zeigarnik-effect`.

• Design System Adoption

  by @Owl-Listener

  Create adoption strategy and enablement materials to drive design system usage. Use when the system exists but teams ignore it. For contribution and versioning rules, use `design-system-governance` (design-systems).

• Form Design

  by @Owl-Listener

  Design a form end to end — field order, grouping, validation, and completion. Use when the artifact is a form. For product-wide error strategy use `error-handling-ux`; for first-run signup use `onboarding-design`.

• Pattern Library

  by @Owl-Listener

  Structure a pattern entry — problem context, solution, usage examples, and related patterns. Use when documenting a recurring solution rather than a component. For a single component's API, use `component-spec`.

• Design Impact Reporting

  by @Owl-Listener

  Communicate design's contribution to business and user outcomes in stakeholder language. Use when reporting results upward. For choosing the metrics in the first place, use `metrics-definition` (ux-strategy).

• Card Sort Analysis

  by @Owl-Listener

  Analyse open or closed card sort results into a proposed grouping and label set. Use after running a sort study. For turning that evidence into a full structure, use `information-architecture` (ux-strategy).

• Error Handling Ux

  by @Owl-Listener

  Design error prevention, detection, and recovery across a product — message content, placement, and escape routes. Use when errors span multiple flows. For validation inside a single form, use `form-design`.

• Conversational Ux

  by @Owl-Listener

  Design voice and conversational interfaces — dialog flows, error recovery, and persona. Use when the interface speaks and listens rather than being tapped. For graphical input collection, use `form-design`.

• Onboarding Design

  by @Owl-Listener

  Design the first-run experience — activation path, progressive disclosure, and time to first value. Use for a user's very first session. For the mechanics of the signup form itself, use `form-design`.

• Case Study

  by @Owl-Listener

  Craft a portfolio case study with narrative arc, process evidence, and outcomes. Use when telling a project's story to an external audience. For an internal stakeholder deck, use `presentation-deck`.

• Documentation Template

  by @Owl-Listener

  Generate a reusable documentation scaffold for components, patterns, or guidelines. Use when standardising how the system is documented. For the content of one component's spec, use `component-spec`.

• Hicks Law

  by @Owl-Listener

  Apply Hick's Law — decision time grows with the number of simultaneous choices. Use when a screen offers too many options at once. For how many items survive in memory afterwards, use `millers-law`.

• Millers Law

  by @Owl-Listener

  Apply Miller's Law — chunk information into groups of about four to fit working memory. Use when grouping fields, menu items, or steps. For reducing the number of choices offered, use `hicks-law`.

• Naming Convention

  by @Owl-Listener

  Establish naming rules for components, tokens, and layers with patterns and worked examples. Use when names are inconsistent or being set. For what the tokens actually contain, use `design-token`.

• Diary Study Plan

  by @Owl-Listener

  Design a diary study — prompts, cadence, duration, participant criteria, and analysis frame. Use when behaviour unfolds over days or weeks. For a single-session study, use `usability-test-plan`.

• Presentation Deck

  by @Owl-Listener

  Structure a design presentation for a specific audience and decision. Use when presenting internally. For a portfolio narrative use `case-study`; for the written argument use `design-rationale`.

• Fitts Law

  by @Owl-Listener

  Apply Fitts's Law — target acquisition time depends on size and distance. Use when sizing and positioning controls, especially for touch. For how many controls to show at once, use `hicks-law`.

• Icon System

  by @Owl-Listener

  Specify an icon system — grid, sizing, stroke weight, naming, categories, and implementation. Use when standardising iconography. For broader illustration, use `illustration-style` (ui-design).

• Team Workflow

  by @Owl-Listener

  Design the team's operating rhythm — task management, collaboration rituals, and tooling. Use when the day-to-day cadence needs structure. For a time-boxed sprint, use `design-sprint-plan`.

• Research Repository

  by @Owl-Listener

  Build a repository that makes findings findable, reusable, and cumulative across teams. Use when the same research keeps getting redone. For synthesising one study, use `affinity-diagram`.

• Ux Writing

  by @Owl-Listener

  Write interface copy — microcopy, error messages, empty states, and CTAs. Use when the words are the deliverable. For content structure and ownership, use `content-strategy` (ux-strategy).

• Design Rationale

  by @Owl-Listener

  Write rationale connecting decisions to user needs, business goals, and principles. Use when a decision needs defending in writing. For a live conversation, use `design-negotiation`.

• Jobs To Be Done

  by @Owl-Listener

  Map functional, emotional, and social jobs with outcome expectations. Use when reframing decisions around motivation rather than features. For who the user is, use `user-persona`.

• Summarize Interview

  by @Owl-Listener

  Turn one interview transcript into themes, supporting quotes, and action items. Use immediately after a session. For synthesising many sessions at once, use `affinity-diagram`.

• Design Sprint Plan

  by @Owl-Listener

  Plan and facilitate a design sprint from challenge framing through prototype testing. Use when compressing discovery into days. For ongoing team cadence, use `team-workflow`.

• Design Review Process

  by @Owl-Listener

  Establish review gates — criteria, checkpoints, and approval flow. Use when work ships without consistent review. For running one individual session, use `design-critique`.

• Search Ux

  by @Owl-Listener

  Design search — query input, zero results, refinement, and result presentation. Use when users retrieve rather than browse. For browse structure, use `navigation-patterns`.

• Interview Script

  by @Owl-Listener

  Write a structured interview guide — warm-up, core exploration, and wrap-up. Use before running interviews. For analysing what comes back, use `summarize-interview`.