Agent Skills Library

pip install openai
# define tools, a loop, and safety limits

# Keep a small stable system prompt, fetch only what the task needs
SYSTEM = "You are a concise senior engineer."
TASK = "Fix the bug in src/auth.py"

pip install sentence-transformers numpy scikit-learn
python -c "from sentence_transformers import SentenceTransformer; m=SentenceTransformer('all-MiniLM-L6-v2'); print(m.encode('hello').shape)"

Classify the sentiment of each review:

Review: "This product is amazing!"
Sentiment: Positive

Review: "Terrible experience, would not recommend."

pip install openai
# declare tools, let the model call them, execute, and loop

pip install pytest openai
# collect a golden set, score answers, gate releases in CI

from unsloth import FastLanguageModel
from datasets import load_dataset
from trl import SFTTrainer

# Load model with LoRA
model, tokenizer = FastLanguageModel.from_pretrained(

# Never trust model or user content; validate before acting
USER_INPUT = "<user content>"
MODEL_OUTPUT = "<model output>"
# apply input and output checks

# Fastest way: use the Python SDK
pip install "mcp[cli]"
# or Node:
npm install @modelcontextprotocol/sdk

pip install mlflow
mlflow ui  # experiment tracking UI

# Orchestrator picks a worker per task; workers return results
from dataclasses import dataclass

@dataclass
class AgentResult:
    task: str

# Put stable content first, mark it as cacheable
resp = client.chat.completions.create(
    model="gpt-6",
    messages=[
        {"role": "system", "content": LONG_SYSTEM_PROMPT},
        {"role": "user", "content": dynamic_question},

You are a senior Python code reviewer.
Review the code below for bugs, security issues, and style.
Output a markdown report with sections: Issues, Severity, Fix.

pip install openai chromadb sentence-transformers
# index documents, then query with retrieved context

pip install openai pydantic jsonschema
# combine response_format with a JSON Schema for guaranteed shape

// deno serve — modern HTTP server
import { Hono } from "jsr:@hono/hono";
import { cors } from "jsr:@hono/hono/cors";
import { Database } from "jsr:@db/sqlite";

const db = new Database("app.db");

pip install django djangorestframework
django-admin startproject mysite .
python manage.py migrate
python manage.py runserver

dotnet new webapi -n MyApi
cd MyApi && dotnet run
# https://localhost:5001

npm init -y
npm i express
node server.js  # http://localhost:3000

pip install fastapi uvicorn
uvicorn main:app --reload
# http://localhost:8000/docs  (Swagger UI)

go mod init example.com/myapi
go run .  # http://localhost:8080

npm init -y && npm i graphql @apollo/server
node server.js  # http://localhost:4000/graphql

pip install grpcio grpcio-tools
# or Go:
go get google.golang.org/grpc

composer create-project laravel/laravel my-app
cd my-app && php artisan serve
# http://localhost:8000

npm i -g @nestjs/cli && nest new my-api
cd my-api && npm run start:dev

Resources:   /users, /users/{id}, /users/{id}/orders
Methods:     GET list/detail, POST create, PUT replace, PATCH partial, DELETE
Status:      200, 201, 204, 400, 401, 403, 404, 409, 422, 429, 500

use tokio::net::TcpListener;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use std::sync::Arc;
use tokio::sync::Mutex;

#[tokio::main]

# start.spring.io -> Spring Web, Data JPA, Validation
./mvnw spring-boot:run
# http://localhost:8080

npm i ws
node server.js  # ws://localhost:8080

// age-check.circom — Prove age >= 18 without revealing age
pragma circom 2.1.0;

include "circomlib/comparators.circom";

template AgeCheck(maxAgeBits) {

pip install apache-airflow
airflow standalone  # dev instance

pip install pyspark
pyspark  # interactive shell

pip install matplotlib plotly pandas

pip install dbt-postgres
dbt init my_project
dbt run

docker run -p 9200:9200 -e "discovery.type=single-node" -d docker.elastic.co/elasticsearch/elasticsearch:8.17.0
curl -s localhost:9200  # cluster info

pip install pandas
python -c "import pandas as pd; print(pd.read_csv('data.csv').head())"

SELECT status, COUNT(*) AS cnt
FROM orders
WHERE created_at >= NOW() - INTERVAL '30 days'
GROUP BY status
ORDER BY cnt DESC;

docker run -p 8123:8123 -d clickhouse/clickhouse-server
clickhouse-client

docker run --name mongo -p 27017:27017 -d mongo:8
mongosh
use app
db.users.insertOne({ name: "Alice", role: "admin" })

docker run --name mysql -e MYSQL_ROOT_PASSWORD=secret -p 3306:3306 -d mysql:8
mysql -h 127.0.0.1 -u root -p

docker run --name pg -e POSTGRES_PASSWORD=secret -p 5432:5432 -d postgres:17
psql -h localhost -U postgres
# CREATE DATABASE app;

// schema.prisma
model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
  posts Post[]

docker run --name redis -p 6379:6379 -d redis:7
redis-cli ping  # PONG

sqlite3 app.db
CREATE TABLE users (id INTEGER PRIMARY KEY, email TEXT UNIQUE);
INSERT INTO users (email) VALUES ('a@b.com');

# pgvector on Postgres
docker run -e POSTGRES_PASSWORD=secret -p 5432:5432 -d pgvector/pgvector:pg17
# or Chroma:
pip install chromadb

// main.js
const { app, BrowserWindow, ipcMain } = require('electron');

function createWindow() {
  const win = new BrowserWindow({
    width: 1200,

pip install ansible
ansible -i hosts all -m ping

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

import { Handler, APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';

export const handler: Handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
  return {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },

# model-serving.yaml — vLLM inference server
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-server
spec:

docker build -t myapp .
docker run -p 8080:8080 myapp
docker compose up -d

# Add .github/workflows/ci.yml and push
# Workflow runs on push/PR automatically

stages:
  - test
  - build
  - deploy

test:

istioctl install --set profile=default
kubectl label namespace default istio-injection=enabled

docker run -p 8080:8080 -p 50000:50000 -d jenkins/jenkins:lts
# http://localhost:8080, unlock with initial admin password

docker compose up -d  # single-node kafka
kafka-topics --bootstrap-server localhost:9092 --create --topic events --partitions 3
kafka-console-producer --bootstrap-server localhost:9092 --topic events

# Local cluster (kind or minikube)
kind create cluster
kubectl apply -f deploy.yaml
kubectl get pods

# single binary or docker compose with promtail + loki
docker run -p 3100:3100 -d grafana/loki:latest -config.file=/etc/loki/local-config.yaml

sudo apt install nginx
sudo nginx -t && sudo systemctl reload nginx

# Langfuse — LLM observability platform
from langfuse import Langfuse
from langfuse.decorators import observe, langfuse_context

langfuse = Langfuse(
    secret_key="sk-lf-...",

# app-config.yaml — Backstage configuration
app:
  title: Internal Developer Platform
  baseUrl: https://developer.example.com

backend:

docker run -p 9090:9090 -v prometheus.yml:/etc/prometheus/prometheus.yml -d prom/prometheus
docker run -p 3000:3000 -d grafana/grafana
# Grafana: localhost:3000 admin/admin

// Cloudflare Workers AI — edge inference
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const { pathname } = new URL(request.url);

    if (pathname === "/generate") {

# slo-config.yaml — Service level configuration
apiVersion: sre.google.com/v1
kind: SLO
metadata:
  name: api-availability
  service: payment-api

terraform init
terraform plan
terraform apply
terraform destroy  # when done

//! Blinky example for STM32 microcontroller
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use panic_halt as _;

# AI test generation with Claude
from anthropic import Anthropic
import ast
import os

client = Anthropic()

# Install and start
npm install -g @anthropic-ai/claude-code
cd your-project
claude
# then in the REPL: /help, /clear, /add <file>, /model sonnet

Layers (outer -> inner):
  Frameworks/Drivers -> Interface -> Application -> Domain
Dependency rule: dependencies point inward only.

# Review a diff systematically
git diff main...HEAD
# check correctness, security, performance, and readability

git clone <repo>
git checkout -b feat/my-feature
# ... work, commit ...
git push -u origin feat/my-feature

1. Clarify requirements
2. Estimate scale
3. Sketch architecture
4. Design data model
5. Discuss trade-offs

1. RED: write a failing test
2. GREEN: make it pass minimally
3. REFACTOR: clean up safely

import pandas as pd
import numpy as np

class MovingAverageCrossover:
    """Simple mean-reversion strategy."""

import numpy as np
import pandas as pd

def calculate_var(returns: pd.Series, confidence: float = 0.95) -> float:
    """Historical Value at Risk."""
    return np.percentile(returns, (1 - confidence) * 100)

npm install -g @angular/cli
ng new my-app
cd my-app && ng serve

npm create astro@latest
cd my-site && npm run dev

# Install Bun
powershell -c "irm bun.sh/install.ps1 | iex"

# Create a new project
bun init

:root { --accent: #8b5cf6; }
.card { padding: 1rem; border: 1px solid color-mix(in srgb, var(--accent), white 40%); }

npx create-next-app@latest my-app -- --typescript --tailwind --app
cd my-app
npm run dev
# http://localhost:3000

npx create-react-app@latest my-app
# or with a build tool you control:
npm create vite@latest my-app -- --template react-ts
cd my-app
npm run dev

npm create svelte@latest my-app
cd my-app && npm install && npm run dev

/* app.css — Tailwind v4 CSS-first configuration */
@import "tailwindcss";

/* Native CSS custom properties for theme */
@theme {
  --color-brand: #6c5ce7;

npm create vite@latest my-app -- --template vanilla-ts
cd my-app
npm i
npm run build
# tsconfig.json enables strict mode

npm create vue@latest my-app
cd my-app
npm install
npm run dev

# Basic rigid body setup (example with common physics engine pattern)
class RigidBody:
    def __init__(self, mass, position, velocity):
        self.mass = mass
        self.position = position
        self.velocity = velocity

using Unity.Entities;
using Unity.Transforms;
using Unity.Mathematics;

// Define a component
public struct Health : IComponentData

import hashlib
import hmac
import json
import logging
from datetime import datetime
from functools import wraps

import requests

class FHIRClient:
    def __init__(self, base_url: str, access_token: str = None):
        self.base_url = base_url.rstrip('/')
        self.headers = {

// app/index.tsx — Expo Router file-based routing
import { router } from 'expo-router';
import { View, Text, FlatList, TouchableOpacity } from 'react-native';
import { useSQLiteContext } from 'expo-sqlite';

export default function HomeScreen() {

flutter create my_app
cd my_app
flutter run
# builds for your connected device or emulator

# Android Studio -> New Project -> Empty Compose Activity
./gradlew assembleDebug

# Xcode -> New Project -> SwiftUI App
# or: swift package init

npm init playwright@latest
npx playwright test
# or in Python:
pip install playwright && playwright install

npm i -D jest @types/jest ts-jest
npx jest

pip install pytest pytest-cov
pytest tests/ -v --cov=src --cov-report=term-missing

1. Authenticate every request
2. Authorize every action
3. Validate all input
4. Rate-limit abuse

import jwt from 'jsonwebtoken';
import bcrypt from 'bcrypt';

// Login
const user = await db.user.findUnique({ where: { email } });
const valid = await bcrypt.compare(password, user.password);

# Scan dependencies for known vulnerabilities
pip-audit --format full
npm audit
# then review the OWASP Top 10 checklist against your app

# Never commit secrets to git
# Use a vault or environment variables
export API_KEY="..."