Skill UI

Behavioral rules for LLMs writing or reviewing code, emphasizing caution, simplicity, surgical edits, and goal-driven execution to avoid common mistakes during implementation tasks, bug fixes, or refactors.

This guide details a production-ready reference architecture for applications built on Groq's LPU inference API. It covers sophisticated model routing based on latency, quality, or cost needs, implementing streaming pipelines, and establishing robust multi-provider fallback chains (e.g., Groq primary to OpenAI backup). Ideal for designing and reviewing complex, resilient LLM systems.

A comprehensive guide for auditing and ensuring regulatory compliance (SOC2, GDPR, HIPAA) when integrating Large Language Models (LLMs) via OpenRouter. It covers best practices for data handling, access control, PII redaction, implementing robust audit trails, and configuring provider routing to maintain data sovereignty and meet strict industry standards.

This skill provides comprehensive reference architectures for building production-grade AI applications using OpenRouter as a unified LLM gateway. It covers three scaling patterns: simple single-service, standard microservice (with caching and budget enforcement), and enterprise event-driven systems (with message queues and workers). Use this when planning system design, reviewing complex AI pipelines, or ensuring scalability and cost control in your LLM integration.

This guide outlines the comprehensive reference architecture for building advanced, AI-powered search and research applications, modeled after Perplexity. It covers three core tiers: a searchable service with model routing and caching, a citation pipeline for validation and rendering, and an orchestrator for multi-query research synthesis. Use this when designing complex, production-grade, search-augmented LLM integrations or reviewing advanced system patterns.

A comprehensive collection of battle-tested, structured prompts designed to elevate interactions with Large Language Models (LLMs). Covers advanced use cases including expert coding reviews, system architecture design, performance analysis, technical writing, and creative brainstorming, ensuring high-quality, actionable AI output.

Runs external LLM CLIs (OpenAI Codex or Google Gemini) to review uncommitted changes, branch diffs, or specific commits, providing an independent second opinion before merges or releases.

A set of behavioral guidelines derived from Andrej Karpathy's observations to help users writing, reviewing, or refactoring code with Large Language Models (LLMs). It guides developers to avoid overcomplication, make surgical changes, explicitly surface assumptions, and define verifiable success criteria, promoting clean, simple, and robust code development.

This skill automates the scholarly process of refining a generated academic paper. It executes an iterative loop (Review → Fix → Recompile) using advanced LLMs (like GPT-5.5) over multiple rounds. It is designed not for primary research, but specifically for polishing writing quality, correcting theoretical inconsistencies, improving presentation, and enhancing narrative flow after the initial draft is complete. It helps elevate a paper from a draft to a polished submission.

This skill automates the research improvement process by creating a closed loop: Review -> Implement Fixes -> Re-review. It leverages any OpenAI-compatible LLM API to iteratively refine research work until a positive assessment is reached or a maximum round limit is hit. Ideal for academic or technical project refinement.

This advanced skill automates the rigorous, iterative review and refinement of complex research topics or papers. It runs multi-round cycles, using an external LLM (MiniMax API) to provide continuous, constructive feedback. The process guides the user through review, fixes, and re-review stages until a positive assessment is achieved or the maximum round limit is reached. It includes robust state persistence for long-running academic workflows.

Behavioral guidelines for writing, reviewing, and refactoring code with LLMs, emphasizing minimalism, clear assumptions, surgical edits, and verifiable success criteria to avoid common machine-assisted coding mistakes.