Tutorials
Step-by-step guides for building with AI. (282 stories)
sapper-v2: run an autonomous pentest legion on your own lab — hands-on
sapper-v2 (N1nEmAn/sapper-v2) is a multi-agent pentest harness that won the 3rd Tencent Cloud Intelligent Attack-Defense Challenge — 634 teams, 80.18/100, 8 hours unattended, on 1B tokens where the runner-up burned 4.5B. This guide installs the CLI, sets up a project with a shared fact graph, drives one commander loop by hand, then lets the legion run itself — plus the full Docker legion for competition-style campaigns.
FLUX.1 [dev]: generate images on your own GPU — hands-on with Black Forest Labs' open-weights model
FLUX.1 [dev] (black-forest-labs/FLUX.1-dev) is a 12-billion-parameter open-weights image model you can run on your own GPU. This guide installs it with diffusers, generates a first image, tunes guidance and steps, and covers the faster FLUX.1 [schnell] variant — plus the hardware it really needs.
Chatterbox voice cloning: clone a voice on your own machine, free — hands-on
Chatterbox (resemble-ai/chatterbox, MIT, 27,576 GitHub stars) clones a voice from a 10-second clip and speaks 23 languages — free, on your own machine. This guide installs it, clones a voice with the Turbo model, takes the same voice into a second language, and checks the watermark baked into every file.
Colibri v2.1.0: run GGUF models as-is and use the new chat UI — hands-on
Colibri (JustVugg/colibri, Apache-2.0, 47,760 GitHub stars at the 4 November 2026 check) runs huge open mixture-of-experts models on the machine you already have. Version 2.1.0, released 31 October 2026, reads published GGUF files exactly as they are — no conversion — and adds a new chat UI. This guide installs v2.1.0, imports a GGUF, opens the new UI, and points your other apps at the local server.
RustXNG: give your AI agent its own private web search — hands-on with v0.27.1
RustXNG (sahenjp/RustXNG, AGPL-3.0, 815 GitHub stars at the 4 November 2026 check) is a self-hosted metasearch engine in Rust, based on SearXNG: one loopback binary that fans a query out to upstream engines and returns ranked JSON an agent can use, plus a read-only MCP server with search and read_page tools. This guide installs the v0.27.1 release binary, verifies it, and wires it into an agent — with the provider-terms caveat the project itself puts first.
CleanYourTV: debloat your Android TV and get an Apple TV-style home screen — hands-on
CleanYourTV (Gathin23/cleanyourtv, MIT, 51,716 GitHub stars at the 4 November 2026 check) debloats any Android TV or Google TV over Wi-Fi with a coding assistant: it backs up, disables bloat with pm disable-user, and installs a 572 KB launcher — with nothing uninstalled and a one-line restore. This guide follows the project's README and prompt, step by step.
Audit your Android phone for leaks: hands-on with NOIR over adb
NOIR (Verlintas/NOIR, MIT, 1,831 GitHub stars at the 4 November 2026 check) audits your own Android phone over adb — permissions, APK endpoints and data flows — with no root, no account and no uploads. This guide installs v0.2.5, scans read-only, reads the report and its three domain lists, and applies only reversible fixes.
Study any website, then rebuild it clean-room: hands-on with Craft Anything
Craft Anything (storytold/craft-anything, MIT OR Apache-2.0, 8,386 GitHub stars in its first three days) studies a website, app or game with 320 inspection tools and has a coding agent rebuild it from evidence, checking the result at three screen widths. This guide installs it, inspects example.com without any AI, runs a clean-room rebuild, and states plainly what is still early alpha.
See every coding agent at once: hands-on with whatsmyagentdoing's live office
whatsmyagentdoing (Charonyuu/whatsmyagentdoing, MIT, 371 GitHub stars) turns the session logs Claude Code, Codex and nine more coding agents already write into a live office in your browser: figures at desks while they work, wandering off duty when they finish, and waving when they need you. This guide installs it with one clone, tries the made-up demo team first, reads real sessions, and uses its JSON snapshot, privacy mode and stuck-agent alerts, with the log-format limits the project states itself.
See how your app actually fits together: hands-on with Floorplan
Floorplan (haydenschmitty/floorplan, MIT, 2,376 GitHub stars) is a Claude Code and Codex plugin that has Claude or Codex read your codebase and draw an interactive, plain-English map of its parts, files, endpoints, screens and outside services, with a health check and a record of recent work. This guide installs it, makes a first map, questions the map, updates it after a change, and exports it, with the local-only limits the project states itself.
One tiny binary, any model, plain English: hands-on with Shim
Shim (Balanov/shim, MIT, 383 GitHub stars) is a 7.29 MiB static Go binary that wires any OpenAI-compatible or Anthropic model API, MCP servers and Agent Skills into one terminal harness with no daemon, no TUI and no telemetry. This guide installs v0.1.0, runs shim setup, adds a local model and a hosted model, tests both, runs a read-only agent task, connects an MCP server, installs a skill, sets up the local-model command router and permissions, and resumes a session, with the safety limits the project states itself.
Let your coding agent click real apps — without screenshots: hands-on with agent-desktop
agent-desktop (vercel-labs/agent-desktop, Apache-2.0, 9,703 GitHub stars) is a Rust CLI and C library that lets a coding agent read and operate macOS, Windows and Linux apps through the operating system's accessibility tree. This guide installs v1.0.2 with npm, checks permissions with agent-desktop status, snapshots Finder by ref, drills into a dense app with --skeleton and --root, clicks and types, verifies by re-snapshotting, and teaches an agent the loop with the bundled skills, with the retry and privacy rules the docs insist on.
Stop paying Opus to type: stretch your Claude plan with Cheap Agent
Cheap Agent (muaaz9329/cheap-ag, MIT, 218 GitHub stars) is a Claude Code MCP server that lets Opus plan while a cheap model writes the code in a git worktree and proves it with tests. This guide installs v1.2.7 with npx cheap-agent, logs in through OpenRouter, DeepSeek, OpenCode Go or Command Code, allows one project with /cheapag:allow, runs a first delegated change, and checks the cost with /cheapag:status, plus the author's SWE-bench numbers and their limits.
Your own always-on AI bot, on any model: hands-on with AnyModelBot
AnyModelBot (modelflare-ai/AnyModelBot, MIT, 1,198 GitHub stars) is a local-first, open-source alternative to Grok Bot, OpenAI dots and Claude Duet: it runs on your own Windows, macOS or Linux machine, reaches GPT, Claude, Gemini, Grok, DeepSeek, Kimi, GLM and 70+ more models through one Modelflare account billed per token, and works in the background with approval cards for anything outside its workspace. This guide installs v0.1.16, signs in to Modelflare, builds a bot with its own workspace and permissions, gives it a background task and a scheduled rule, and reaches it from a chat app, plus the Docker route for a server.
Run a coding agent that never silently truncates: hands-on with UNCUT
UNCUT (Balanov/uncut, MIT, 388 GitHub stars) is a single static Go binary with four tools and no TUI, telemetry, or context compaction: it sends the full conversation on every model call and fails loudly instead of presenting a cut-off answer as success. This guide installs v0.1.1, runs it against a hosted OpenAI-compatible endpoint and a local Ollama model, pipes a diff through it, resumes a session, and reproduces its no-API-key lossless proof.
Find the file you only half-remember: hands-on with Kensaku, local search with OCR and MCP
Kensaku (yjid/kensaku, MIT, 480 GitHub stars) is a free, local-first file launcher for Windows, macOS and Linux that searches file names, text inside documents, and text inside screenshots with OCR — nothing leaves your machine. This guide installs the v1.0.11 release and its command-line companion, runs the first scan, searches the way you remember things, and gives an AI agent the same index over MCP, read-only by default.
Run a 763-billion-parameter model from your SSD: hands-on with InferSSD
InferSSD (wici-ai/inferssd, Apache-2.0, 206 GitHub stars) streams the experts of a 763-billion-parameter mixture-of-experts model from SSD instead of holding them in RAM or VRAM. This guide installs it on Apple Silicon or Linux with NVIDIA CUDA, starts DeepSeek-V4.1-Flash in terminal chat, serves it behind a browser UI and an OpenAI-compatible API, and states the 470 GiB download and the slow decode plainly.
Give your Android phone an agent that works in the background: hands-on with Mika
Mika (wangzan101/Mika, Apache-2.0, 3,350 GitHub stars) is an on-device AI agent for Android that works your apps and the web on a hidden background screen while you keep using your phone. This guide installs the v0.1.31 APK, connects a model, pairs wireless debugging with Mika’s six-step wizard, proves it with a safe first task, and shows the adb install route from a computer.
Skip the sprite sheet: hands-on with pixelfx, 244 pixel-art game effects written as code
pixelfx (patch-gg/pixelfx, MIT, 1,717 GitHub stars) is 244 pixel-art game effects and animations, each a small piece of JavaScript — no image files. This guide installs it, plays a frost nova on canvas, recolors a torch, exports a sprite sheet for Godot, Unity or Phaser, plays a full acted sword move, and builds a new effect with its Claude Code skill.
One tiny board for you and your coding agents: hands-on with Kanzo
Kanzo 0.2.1 (emanuele-em/kanzo, AGPL-3.0, 216 GitHub stars) is a self-hosted kanban board and MCP server in one small Rust program: the whole board is one folder, a private git repo syncs it between machines, and coding agents work the same cards you do. This guide installs it, runs the board, connects Claude Code and Codex, and syncs it to a second machine.
Make your AI-built UI stop looking AI-built: hands-on with unslop, the Claude skill that redlines like a designer
unslop (heydamir/unslop, CC BY 4.0, 3,104 GitHub stars) is a Claude Code skill by designer Damir Sokolovsky that turns vibecoded, AI-looking interfaces into designed ones: it audits the slop, sets a five-line direction drawn from the product itself, then fixes spacing, color, icons, copy, type, layout, details, visuals and motion in nine ordered passes. This guide installs it, runs it on the bundled EmberAI dashboard example, takes it to a live site, and renders the optional story video.
Turn PDFs and phone photos into Markdown on your own machine: hands-on with MiniCPM-OCR
MiniCPM-OCR 1.0 (OpenBMB/MiniCPM-OCR, Apache-2.0, 707 GitHub stars) is a 1.3B model that parses PDFs and images into Markdown — text, tables, formulas, and charts — with a second model, MiniCPM-OCR Jev, that scores each region for correctness. This guide runs it locally through Ollama, parses a first document with the minicpmvocr SDK, and shows the vLLM path for heavier batches.
One Python call drives your browser, desktop, or phone: hands-on with AutoCua
AutoCua (ComputerUseAgent/AutoCua, MIT) drives a browser, a desktop, or a phone from one run_agent call, with 48 model names across nine providers. This guide installs it, runs a read-only web task, branches on the result, and switches surfaces — without letting the agent near your real accounts.
Run your job search on your own server: hands-on with Dossier, the self-hosted resume tailor
Dossier (AienTech/dossier, AGPL-3.0) keeps one career profile in its own PostgreSQL database, scores job postings against it, and drafts a tailored resume and cover letter for each one using only facts from your profile. This guide installs it with Docker Compose, connects a local or hosted model, and takes one posting from paste to PDF.
Soup hands-on: fine-tune an LLM from a single YAML file, from first config to a working adapter
Soup is a command-line tool that collapses LLM fine-tuning into one YAML file and one command — and its layer streaming trains an 8B model on a 4 GB laptop GPU. This guide installs Soup, writes a real training config, trains a LoRA adapter on CPU, and proves the adapter changed the model's answers.
Your agent should brief you first: run OpenDuet, the self-hosted proactive agent
OpenDuet is CopilotKit's open-source template for a proactive agent: it triages Gmail and calendar, delivers a morning brief, and keeps working on a computer of its own, asking before it sends, pays, signs, or deletes. This guide runs it locally with Docker and Bun, tries it safely with the built-in fake Google account, and shows how to make it your own — 1,633 stars in its first nine days, MIT-licensed, and still early development.
Your fine-tune is only as good as its data: build a clean SFT dataset from your own documents
Most fine-tuning failures are data failures, not model failures: this guide turns a folder of draft examples into a validated, deduplicated, leakage-checked SFT dataset — train/validation split included — with Python's standard library alone, every check run and every number real.
Nanobot hands-on: run a 4,000-line personal agent on your own machine
Nanobot is a self-hosted personal AI agent with a roughly 4,000-line Python core: this guide installs 0.4.0, points it at a local Ollama model, proves the file read/write loop, and documents honestly where a 0.6B model fails and where this sandbox blocked the WebUI.
Lightpanda hands-on: the headless browser built for AI agents, from first fetch to a replayable scrape
Lightpanda is a headless browser written from scratch in Zig for agents and automation — no Chromium, a fraction of the memory. This guide installs the nightly binary, fetches JavaScript-rendered pages to Markdown, extracts structured data, and turns a REPL session into a replayable script you can run without any model at all.
Point your coding agent at your repo and get a threat model you can actually check: hands-on with Grim Prompter
Grim Prompter (jmanico/grim-prompter, MIT, 212 GitHub stars) turns Claude Code, Codex or any coding agent into a threat-model reviewer: 36 architecture workflows and 29 method prompts, installed by linking one skill, run with a single slash command, and checked against your code with file-and-line citations. This guide installs it, runs a quick API model, challenges the findings, and keeps the model current as the code changes.
Your laptop is the API: run a local LLM server with llama-cpp-python and a 398 MB GGUF model
llama-cpp-python turns a 398 MB GGUF model into a local OpenAI-compatible API: this guide loads Qwen2.5-0.5B on CPU, streams tokens, forces JSON-schema output, and serves it on localhost — with every command verified and one honest model failure included.
Blind the agent reading your code: hands-on with BLA, the open-source shield against AI reverse-engineering
BLA, a five-day-old MIT-licensed shield created on October 25, 2026, hardens your shipped JavaScript against AI reverse-engineering agents: one audit, one protect command, and the demo file's exposure score fell from 81 to 2 while its output stayed identical. This guide runs every command and shows the real numbers, including the caveats.
JetBrains' ThinkRail, hands-on: the agentic IDE that keeps every agent off your checkout
ThinkRail, JetBrains' open-source agentic IDE, wraps the pi coding agent in a real editor and gives every task its own git-worktree workspace — so parallel agents never touch your checkout. This guide installs it, starts the host, proves the isolation on disk, and shows how living specs keep the agent's memory.
Your own narration studio, offline: generate natural speech with Kokoro-82M on your CPU
Kokoro-82M turns plain text into natural narration on your own CPU — no account, no API key, no per-character bill. This guide installs it, auditions its 54 preset voices, tunes speed and pronunciation, and batches a whole script into one WAV file.
Put your agents to sleep: hands-on with Infinity, the runtime built for 75,000 concurrent agents
Infinity, the AWS and UC Berkeley agent runtime released in October 2026, suspends an agent the moment it calls a tool and resumes it when the result arrives — instead of holding a process open while it waits. This guide builds a real agent on the runtime with no API key and no AWS account, using the crate’s own scripted model, and watches a sleep tool call hibernate and resume.
Stop your coding agent from overbuilding: hands-on with the Karpathy guidelines for Claude Code
A 65-line text file distilled from Andrej Karpathy's observations about coding agents is one of GitHub's most-starred projects this week. This guide installs it in Claude Code and Cursor, explains its four principles, and proves each one on real code — with the honest limits stated.
One endpoint for every free model: hands-on with FreeLLMAPI, the self-hosted LLM router
FreeLLMAPI (tashfeenahmed/freellmapi, MIT, about 44,000 stars) is a self-hosted router that puts 34 providers' free tiers behind one OpenAI-compatible endpoint, with failover and quota tracking. Verified here with no account and no provider key: the from-source install, a declarative config registering a local Ollama model, the gateway listing 285 models, and a real completion routed to that local model. The cloud free tiers are documented, not run here.
Let an AI agent cut your video: hands-on with Concat, the free local CapCut replacement
Concat is a free, open-source video editor that runs entirely on your own machine — and version 0.2.8 ships a built-in MCP server, so a coding agent can drive the same engine the window uses. This guide installs 0.2.8, builds a two-clip edit with a title through MCP calls, and exports a real H.264 file — every command run, every output shown.
Run a private, Claude-style AI coworker on your own machine: hands-on with Hob
Hob is a free, MIT-licensed desktop app that runs open-weight models entirely on your computer — no account, no subscription, and no telemetry. This guide installs Hob 0.2.1, lets it pick the model your hardware can actually run, and puts it to work on a real spreadsheet before taking it fully offline.
Build typed, testable AI agents with Pydantic AI: tools, structured output, and tests that run without an API key
Pydantic AI turns an agent's output into a contract: a Pydantic model the model must satisfy, tools built from typed functions, and test models that let you prove it all without an API key. This guide builds a support-ticket triage agent and tests it three ways, all verified on Pydantic AI 2.62.0.
Run your office from the terminal: hands-on with GenOffice, the open-source AI office suite
GenOffice is a free, open-source office suite with a command line that builds real Word, Excel and PowerPoint files from a terminal. This guide installs v0.12.115, creates a document, a live-formula workbook and a checked slide deck, and wires the CLI into a coding agent — every command run, every output shown.
Run a full SEO audit from your terminal: hands-on with Claude SEO, the 22,000-star Claude Code plugin
Claude SEO is a free, MIT-licensed plugin for Claude Code: 26 skills and 19 agents that audit any website and return a prioritised action plan. This guide installs v2.5.0, sets up its isolated runtime, and verifies its tools — with the full agent audit’s limits stated plainly.
Stop shipping AI slop: hands-on with Hallmark, the design skill that refuses to look AI-made
Hallmark (Nutlope/hallmark, 38,038 GitHub stars) is a design skill for Claude Code, Codex, Cursor and OpenCode that refuses to look AI-generated: 48 themes, a hard floor of design rules, and a linter that grades your page. This guide installs it, deals a theme, and runs its own linter on a deliberately sloppy page until it passes clean.
Map everything attackers can see about your company: a hands-on guide to CVEngine
CVEngine (hevnsnt/CVEngine, GPL-3.0, 404 GitHub stars) is a free, self-hosted platform that maps your internet-facing assets, matches today's exploited CVEs against what you actually run, and hands you a verdict instead of a pile of alerts. This guide installs it with one command, adds your first authorized target, and walks the pipeline from discovery to a validated finding — plus the API and MCP hooks that let your coding agent work the same inventory.
Run open models on your own machine: the complete Ollama hands-on guide
Ollama turns your own computer into a private AI server: one binary, one command per model, and a local API your apps can call. This guide installs Ollama v0.40.11, runs a real model on CPU, customizes it with a Modelfile, and wires it into code through the REST and OpenAI-compatible APIs — every command run, every output shown.
Stop letting your coding agent grep: hands-on with XERJ, the local search engine for AI agents
XERJ (xerj-org/xerj) is a single Rust binary that turns any folder into a local search engine for coding agents: index a project once, then get cited passages instead of whole files. This guide installs v1.0.0-rc.99, indexes a demo shop, and verifies search, go-to-definition, the Elasticsearch API, reference coding, and the MCP server — every command run, every output shown.
Let your agent improve its own playbook: hands-on with Google Research's Harness²
Google Research's Harness² (20,269 stars) improves an agent's harness — prompts, tools, memory, guardrails and scripts — without retraining the model. This guide runs its no-credentials local demo end to end, reads the adopted harness and the lesson it stored, and maps the paid benchmark path.
Turn any website into RAG-ready Markdown: hands-on with PageSift
PageSift (YOLOW92/pagesift, AGPL-3.0, 111 GitHub stars) is a Rust web-crawling and extraction engine that turns websites, PDFs and Office files into clean Markdown for LLM pipelines, with Firecrawl- and Jina-compatible APIs. This guide runs it in Docker, scrapes a page two ways, crawls a small site, and wires it into Python and Claude Code — no hosted account required.
Build a real MCP server in Python: the complete FastMCP guide
FastMCP turns plain Python functions into a Model Context Protocol server: this guide builds a complete SQLite-backed reading-list server with tools, resources, and a prompt, tests it with an in-memory client, and serves it over HTTP — no API key required.
Audit your AI agent before it audits your reputation: hands-on with iFixAi
iFixAi (ifixai-ai/iFixAi, about 35,000 GitHub stars) is an independent auditor for AI agents: it puts your agent in a simulated business, probes it with the requests a real day brings — including ones that push past its role — and grades it A to F. This guide runs the keyless demo audit, reads the scorecard, and shows how to point it at a real agent.
Scan every skill before you install it: hands-on with NVIDIA's SkillSpector
SkillSpector (NVIDIA/SkillSpector, 22,356 GitHub stars) is a static scanner for agent skills: one keyless command scores a skill 0–100 and returns SAFE, CAUTION, or DO NOT INSTALL. This guide installs version 2.12.0, scans a clean skill, catches a quiet environment-stealing trap the default gate passes, and builds a strict gate with baselines that blocks it.
Stop photographing the browser: give your coding agent an accessibility-first browser with axuse
axuse (ctoldigital/axuse, 508 GitHub stars) is a browser-and-computer-use MCP server that drives Chrome through its accessibility tree over CDP instead of screenshotting it: one Node.js command plugs it into Claude Code, Codex or OpenCode, and your agent acts on stable element refs like [ref=e7] while every action returns only what changed.
Give your chatbot a memory that outlives the chat: hands-on with MemT-1.0
MemT-1.0 (MemTensor/MemT-1.0, 416 GitHub stars) builds memory into the model itself: a Native Memory Block that stores conversation in a constant-size latent state instead of a growing transcript. This guide serves the 36B-parameter Nano model with SGLang on two GPUs, commits a fact to memory, clears the transcript, and gets the fact back — then saves and restores the memory as a snapshot file.
Let Claude run a finite-element analysis: a hands-on guide to FieldCraft
FieldCraft (tangency-labs/fieldcraft, Apache-2.0, 197 GitHub stars) is an open-source, pure-Rust engineering app that meshes parts, solves structural, thermal and fluid analyses, and lets an AI agent drive the whole thing over MCP. This guide installs the v0.7.0 build, connects Claude Code, and has it solve a steel I-beam cantilever — then checks its answer against beam theory.
Lock your AI agent in a sandbox it can't talk its way out of: a hands-on guide to NVIDIA OpenShell
NVIDIA OpenShell (NVIDIA/OpenShell, Apache-2.0, 19,936 GitHub stars) is a Rust runtime that puts each AI agent in a kernel-enforced sandbox with a declarative policy: no network, no files, no credentials unless the policy says so. This guide installs it, watches default-deny block a request, then opens exactly one read-only door to the GitHub API.
Every AI quota in one glance: a hands-on guide to TokenBar
TokenBar (lwh0630/TokenBar, MIT, 51 GitHub stars) is an open-source, cross-platform monitor for AI usage limits, balances and reset times: it reads the Codex, Claude and Cursor logins already on your machine, adds 47 more services by API key or cookie, and puts the tightest quota in your system tray. This guide installs the v1.0.0 build, adds your accounts, and sets up alerts and phone sync.
Give your coding agent a 3D studio: a hands-on guide to Blender Agent Skills
Blender Agent Skills (EL4CTEO/blender-skills, MIT, 496 GitHub stars) packs 22 professional Blender 5.2 workflows — modeling, PBR, baking, rigging, animation, export and QA — into agent skills for Claude Code, Codex, Gemini CLI, Copilot and Cursor. This guide installs them, builds a game-ready crate, runs the QA pass, and exports it.
Build a phone agent on your own machine: a hands-on guide to Lampline
Lampline (C4rohan/lampline, Apache-2.0, 272 GitHub stars) is an open-source, self-hosted voice-agent platform built on Pipecat: it imports Dialogflow CX agents, runs them on your own machine with local models and speech, and tests them with an AI caller that grades real phone calls. This guide starts it free, builds a front-desk agent, and runs the first graded eval.
Stop your coding agent writing stale API code: a hands-on guide to stalemap
stalemap (Umair/stalemap, MIT, 103 GitHub stars) is a small tool that tells your coding agent which of your JavaScript or TypeScript dependencies changed after its training cutoff, writes the changes into a notes block your agent reads before it starts, and checks every edit against them. This guide previews the notes, writes them into your project, wires up the guard, and keeps the block fresh in CI.
Let your AI agent search your own WhatsApp history: a hands-on guide to whatsapp-mcp
whatsapp-mcp (finereli/whatsapp-mcp, MIT, 359 GitHub stars) is a read-only MCP server that links to your phone the way WhatsApp Web does and lets Claude, ChatGPT or Grok search and read your own message history — it can never send anything. This guide deploys your own copy on Cloudflare, links your phone, and asks the first questions.
Give your coding agent a map of your codebase: a hands-on guide to Graphicle
Graphicle (Graphicle-AI/graphicle, Apache-2.0, 354 GitHub stars) is one Rust program that turns a repository into a code graph and a project memory — files, functions, calls, docs, decisions and past agent sessions — and serves both to your coding agent over a single MCP server, with no API key and no account. This guide installs it, indexes a repo, and asks it the first cited questions.
One gateway for every AI provider: a hands-on guide to Antirion
Antirion (Apache-2.0, 198 GitHub stars in its first week) is a single Rust binary that sits between your apps and every model provider — OpenAI, Anthropic, Gemini and 13 more — behind one OpenAI-compatible API. This hands-on guide takes you from one Docker command to your first routed request, with per-request cost and latency in the built-in console.
Your own AI personal agent, on your own machine: a hands-on guide to Xiryn
Xiryn (MIT, 300+ GitHub stars in its first two weeks) is an open-source personal agent you run yourself: each agent gets its own sandboxed Linux desktop in Docker, your data stays in a SQLite file on your disk, and you can steer it from Telegram. This hands-on guide takes you from the one-command install to your first scheduled routine — with an Ollama mode that costs nothing.
Give your coding agent a sound studio: hands-on with Audio Studio MCP
kanaworksai-hue/audio-studio-mcp (MIT, 462 GitHub stars) puts a sound studio behind an MCP server: your coding agent generates background music, instrument loops and sound effects locally with Stable Audio 3 — no API key, no cloud, no cost. Here is how to install it and make your first loop.
See exactly what your coding agent did: replay any session as a map and a timeline with agentplay
Entelligence-AI/agentplay (Apache 2.0, 296 GitHub stars) turns the session transcripts your coding agent already writes on your machine into a replayable radial map and timeline: every file it read, every edit, every failed command, every subagent. One command, no account, nothing leaves your machine. Here is how to run it.
Spot rising AI terms days before keyword tools do: a hands-on guide to new-term-radar
zhuyansen/new-term-radar (MIT, 1,700+ GitHub stars) runs a daily AI-keyword radar over X, Hacker News, GitHub trending, Hugging Face and site sitemaps - standard-library Python, no key needed for the free signals, one pay-per-call key for the rest. Here is how to run your own.
Reverse-engineer anything with one 8 KB skill: a hands-on guide to leanrea
aicodeking/leanrea (MIT, 1,400+ GitHub stars) replaces the 207-tool REA MCP server with a single 8 KB skill file — 38% faster and 35% cheaper in the author's benchmark. Here's how to install it and reverse-engineer a real app with your coding agent.
From bare terminal to agentic workstation: a hands-on guide to Hermes Agent's official plugins
Nous Research's hermes-official-plugins (MIT, 378 GitHub stars) is the reviewed plugin catalog for the self-improving Hermes Agent. This tutorial installs the agent with one command, then wires up four official plugins: Spotify control, Home Assistant, a Claude-subscription model provider, and Langfuse tracing.
One AI agent across your phone, desktop and browser: a hands-on guide to nanoMuse
nanoMuse (nano-muse/nanoMuse, GPL-3.0-or-later, ~2,300 GitHub stars) is an open-source personal agent that runs on your phone, your computer and your browser under one account — doing tasks instead of just answering questions, handing control across devices, and asking before anything you can’t undo. This tutorial takes the browser demo for a spin, installs the desktop app, links a phone, and self-hosts the relay.
Audit your AI agent in two minutes: a hands-on guide to iFixAi
iFixAi (ifixai-ai/iFixAi, Apache 2.0, 32,000+ GitHub stars) answers the one question agent evals skip — is your agent actually doing its job? — in under 120 seconds. This guide installs it, runs the free mock audit, reads the scorecard, and gets a citable grade from an independent judge.
Run huge open models on your own PC: a hands-on guide to PolyStrata
PolyStrata (VecSzn/PolyStrata, MIT, ≈365 GitHub stars) runs nine large open models — GLM 5.3 Flash, DeepSeek V4 Flash, and Qwen3.8-Flash-Next among them — on an ordinary gaming PC, behind one localhost app and an OpenAI- and Anthropic-compatible API your coding agents can already use. This guide installs it, picks a model that fits your hardware, serves it on http://127.0.0.1:8080, and wires it into Claude Code.
Turn one sentence into an explainer video: a hands-on guide to Frametell's director agent
Frametell (sitor-ai/frametell, AGPL-3.0, ≈365 GitHub stars) is a local-first app whose director agent turns one sentence — or your PDFs and notes — into an explainer video: you approve the storyboard, it writes and voices the narration, draws every page in your chosen style, and renders a 1080p MP4 with subtitles. This guide installs it, adds your keys, runs the studio and the one-command CLI, and ships your first film.
Make your coding agents talk across machines, encrypted: a hands-on guide to Reason Network
Reason Network (reason-machines/reason-network, dual MIT/Apache-2.0 license, ≈893 GitHub stars in its first five days) is a small Rust daemon that lets coding-agent sessions on different computers see and message each other over end-to-end encrypted peer-to-peer connections. Your agents get MCP tools to list teammates’ sessions, send messages, attach small files, and ask a human for sign-off. This guide installs it, joins a second machine, and sends your first cross-machine agent message.
Stop burning tokens on grep: give your coding agent a local search engine with XERJ
XERJ (xerj-org/xerj, Apache-2.0, 12,600+ GitHub stars) is a single static Rust binary that indexes code, docs, logs, and PDFs for BM25, vector, and hybrid search — served to your coding agent over MCP. Its case study shows 2.7× fewer output tokens at the same solve rate. This guide installs it, wires it into Claude Code, and measures what it saves.
Sandbox your AI agent in a branchable microVM: a hands-on guide to smolvm
smolvm (smol-machines/smolvm, Apache-2.0, 6,700+ GitHub stars) runs untrusted code in hardware-isolated microVMs that boot in under a second — and lets you checkpoint, branch, and rewind a running machine the way git branches code. This guide installs it, builds a locked-down sandbox for your coding agent, and packs the whole thing into a single portable file.
Escape the subscriber tax: self-host MailCheap and send your newsletter for pennies
MailCheap (marclou/mailcheap, AGPL-3.0, ~1,275 GitHub stars) is a self-hostable newsletter app that swaps per-subscriber pricing for pay-per-email on your own Amazon SES account: 10,000 readers and 4 issues a month costs about $4 to $6. This guide deploys it, wires SES and background sending, and turns on sending behind a 5%-slice warm-up — then drives it from an AI agent over MCP.
Turn your agent's production failures into regression tests: a hands-on guide to Tracely
Tracely (jwuthri-cloud, MIT, ~1,150 stars) is trace-native CI/CD for AI agents: it grades every production trace as it lands, freezes the failing runs into hermetic regression cases, and blocks the pull request that would ship the failure again — replayed for $0, with no API keys.
Direct a short film with an AI agent — no video model required: a hands-on guide to lemo-opuscar
lemo-opuscar (lemomo-ai, MIT, 4,100+ stars) is a Claude Code skill that directs short films made entirely in code — canvas and WebGL frames, synthesized scores, TTS narration. Full hands-on: install, pick from 51 styles, commission your film, and design your own style.
Stop your RAG from guessing: a hands-on tour of 42 battle-tested retrieval techniques
NirDiamant/RAG_Techniques has nearly 30,000 stars and 42 runnable notebooks covering every upgrade path from naive chunk-and-retrieve to Self-RAG and Corrective RAG. This guide runs the baseline, tunes the chunks, fixes the queries, adds guardrails, and shows how to measure the difference.
Give your AI agent a PhD supervisor: a hands-on guide to Supervisor-Skills
HKUST's 10,100-star Supervisor-Skills distills a decade of PhD-advisor publishing experience into installable AI skills for research: idea evaluation, introduction drafting, literature surveys, and paper polishing. This guide installs the skills in your coding agent and walks the full idea-to-submission loop hands-on.
Teach your agent to rewire itself: a hands-on guide to Google's Harness²
Google's Harness² is a plug-and-play framework that recursively improves the system around a model — prompts, tools, memory, skills — while the weights stay fixed. This guide runs its credential-free local demo, then a real benchmark task end to end.
Render text-perfect images on your own GPU: a hands-on guide to MOSS-Image
OpenMOSS/MOSS-Image (867 stars on 2026-10-19, Apache-2.0) is a 5B-parameter open image model that renders legible text in pictures — posters, whiteboards, sticky notes — and pins text and objects to exact positions with JSON layouts. Released 2026-10-16 with Base and SFT weights, it runs on your own GPU via diffusers, Gradio, ComfyUI, SGLang or vLLM-Omni. Hands-on: the install, your first generation, the recommended sampling settings, layout-controlled posters, and the prompt-enhancer skill.
Stop queueing your agents' commits: a hands-on guide to gitai, Git rebuilt for AI agents
feder-cr/git-ai (2,321 stars in its first four days, MIT) is an open-source implementation of Anthropic's Scion design: a server-centric Git where coding agents land changes with compare-and-swap instead of merge queues — 1,862–2,544 lands per minute in its benchmark versus 240–272 the classic way. Hands-on: the build, the quickstart demo, landing changes as two agents with a policy denial, and reading history without cloning.
Make your agent draw diagrams worth publishing: a hands-on guide to diagram-design
cathrynlavery/diagram-design (57,687 stars, MIT) is an agent skill that turns plain-language requests into self-contained HTML+SVG diagrams in your brand — 45 diagram types, no shadows, no Mermaid slop. Hands-on: the one-command install, your first diagram, onboarding your brand colors, and exporting to SVG or PNG.
Turn chatbot answers into working apps: a hands-on guide to Open Intelligent UI
Thesys's Open Intelligent UI (thesysdev/open-intelligent-ui, 535 stars, MIT) is an open-source recreation of ChatGPT's interactive answers — maps, charts, working sliders — that you can self-host. Hands-on: a one-command API key, the /gallery tour, customizing the component library, and the fully-local Ollama path.
Turn Claude Code into a plugin-powered teammate: a hands-on guide to Anthropic's official plugin directory
Anthropic's official Claude Code plugin directory (anthropics/claude-plugins-official, 42K+ stars, Apache-2.0) bundles 40 internal plugins and 14 community plugins installable with one /plugin command. Hands-on: code-review, frontend-design, and the Playwright MCP plugin, plus what to know before you trust a plugin.
Give Blender an AI copilot: hands-on with mcp-for-blender-pro
A hands-on guide to anujasid/blender-ai-mcp-addon: install the add-on in Blender 4.2+, connect Claude, GPT, Gemini or a local Ollama model, and direct your 3D scenes in plain English — with 21 scene tools and a built-in MCP server for coding agents.
Teach your agent any website: turn web pages into callable APIs with api-anything
A hands-on guide to goodnight000/api-anything: install the CLI, run a bundled operation, plug it into your coding agent over MCP, then teach it a site of your own — no browser driving required.
Give your AI app a tactile glass interface: a hands-on guide to Solid Glass
Solid Glass (deeplethe/solid-glass, MIT, ~1,700 stars in its first week) is a glass-inspired design system for AI apps built on shadcn/ui: one stylesheet plus a registry of agent-oriented components — status lines, tool steps, diff views — installable with two npx commands. Here is how to put it in your app.
Give your coding agent ears: a hands-on guide to earshot
earshot (Leonxlnx/earshot, MIT, past 500 GitHub stars) gives coding agents ears: describe, match, find and critique audio from the CLI, forge sounds as code, and fit recordings into editable code. CPU-only, offline after a 1.4 GB download.
Query your codebase instead of grepping it: a hands-on guide to Graphify
Graphify (Graphify-Labs/graphify, Apache-2.0, past 127,000 GitHub stars) turns your code, docs, SQL schemas, and PDFs into a knowledge graph your AI assistant can query — parsed locally with tree-sitter, no LLM, nothing leaves your machine. This guide installs it, builds your first graph, wires it into your coding assistant, and keeps it fresh.
Rebuild any app and fix what its users hate: a hands-on guide to the Replica skill set
Replica (Jakeschincariol/replica-skill, MIT, roughly 2,900 GitHub stars in its first two weeks) is eleven free Claude skills that reverse-engineer any app, rebuild it clean-room style, test it, and turn its users' complaints into your launch angle. This hands-on guide walks the full pipeline, tool by tool.
Turn your JavaScript into a neural net — no training required: a hands-on guide to Handwired
Handwired (MIT, about 1,500 GitHub stars in its first two days) turns ordinary JavaScript — if-else, loops, state — into an exact, differentiable numeric program built from matrix multiplies and ReLU gates. This hands-on guide clones the repo, runs the demos, walks the toggle-switch template, and wires your first program.
Run a 321B AI model on your own GPU: a hands-on guide to Project Maya
Project Maya (mw00/project-maya, MIT, about 900 GitHub stars in its first ten days) runs Z.ai's 321-billion-parameter GLM-5.3-Flash on your own GPUs — one card up to sixteen — tiering model experts across GPU, RAM, and NVMe SSD, served through an OpenAI/Anthropic-compatible API. This hands-on guide installs it, picks the right quant for your memory pool, and wires it into your tools.
Run an autonomous AI pentest in your own lab: a hands-on guide to ARTEX
ARTEX Global Edition (jiwoochris/artex-global, AGPL-3.0, around 1,560 GitHub stars in its first two weeks) is an autonomous penetration-testing system driven by LLM agents. Hands-on: deploy it with Docker Compose, clear the setup-token first run, point it at a deliberately vulnerable target in your own lab, and mine the bundled detection rules — plus the honest limits.
Run a self-learning coding agent in your terminal: a hands-on guide to CodeAgent
CodeAgent (Harvil1/codeAgent, MIT, around 740 GitHub stars in its first two weeks) is a terminal coding agent with an approval panel for dangerous commands, long-term memory, and a self-learning skill pipeline. Hands-on: install with uv, wire it to DeepSeek or any OpenAI-compatible model, run a real task through plan mode and checkpoints, set the safety rails — plus the honest limits.
Turn any scan or PDF into Markdown on your own CPU: a hands-on guide to Indra OCR
Indra OCR (datalab-to/indra, Apache-2.0 code, ~340 GitHub stars in its first two days) is a 1M-parameter OCR model that turns PDFs and images into Markdown on CPU — no GPU, no PyTorch, ~18 MB of weights. Hands-on: install, convert a scan and a PDF, batch a folder, read the JSON, script it in Python — plus the honest limits.
Compose the shot before the model renders it: a hands-on guide to ArtCraft
ArtCraft (storytold/artcraft, dual MIT/Apache-2.0, past 28,600 GitHub stars) is an open-source "IDE for artists": compose your shot in 2D or staged 3D, then render it through a 62-model catalog (Nano Banana, GPT Image, FLUX, Kling, Veo, Sora, MiniMax H3, Suno). Hands-on: install v0.41.0, generate raw material, compose, stage, animate — plus the honest limits.
Give your coding agent a memory that survives the session: hands-on with OpenViking
OpenViking (volcengine/OpenViking, AGPL-3.0, past 39,000 GitHub stars) is a context database for AI agents: one browsable filesystem under viking:// URIs for knowledge, memory, and skills, with scoped semantic search. Hands-on: install the server, index a repo, browse the context filesystem, plug it into Claude Code — and the honest limits.
Turn your AI coding assistant into a video studio: hands-on with OpenMontage
OpenMontage (calesthio/OpenMontage, AGPL-3.0, 68,000+ stars) turns your AI coding assistant into a full video production studio: a dozen pipelines, 100+ tools, and a free zero-key path with Piper TTS and open archival footage. Hands-on: install, first render, a real-footage documentary, and the honest limits.
Turn any web chore into a one-line command: hands-on with Scout, the open-source browser agent
Scout (outcrawlai/scout, Apache-2.0, 600+ stars in its first day) is an open-source agent that drives a real browser — on the cloud or your own machine — from a one-line task. Full hands-on: install, keys, first run, your own browser, structured answers, and guardrails.
Run a 744-billion-parameter model on your own machine: a hands-on guide to Colibri
Colibri (JustVugg/colibri, past 41,000 GitHub stars, Apache-2.0) keeps a mixture-of-experts model's dense part in RAM and streams its routed experts from disk, so GLM-5.2's 744 billion parameters run on 16 GB of RAM with no GPU. This tutorial installs it, surveys the model catalog, chats, and serves it behind an OpenAI-compatible API.
Drive a real iPhone with AI: a hands-on guide to ESP32 iPhone Agent
ESP32 iPhone Agent (onehumanbeing/esp32-iphone-agent, past 1,500 GitHub stars, MIT) turns a $7 ESP32-S3 board into a USB mouse and keyboard that an AI vision model uses to tap and swipe a real iPhone — no Mac, no developer account, no jailbreak. This tutorial flashes the board, starts the server, and runs its first task.
Review your own code like Alibaba does: a hands-on guide to OpenCodeReview
OpenCodeReview (alibaba/open-code-review, past 46,000 GitHub stars, Apache-2.0) is the AI code reviewer Alibaba runs internally, now open source. This tutorial installs it, configures a model, and runs it on your own repo: uncommitted changes, branch diffs, and delegation mode.
Turn any website into LLM-ready Markdown: a hands-on guide to Crawl4AI
crawl4ai (unclecode/crawl4ai, past 85,000 GitHub stars, Apache-2.0) is an open-source web crawler that turns any website into clean, LLM-ready Markdown. This tutorial installs it, scrapes your first page, and extracts structured JSON with zero LLM calls.
Stop shipping AI slop video: a hands-on guide to motionmaxxing
motionmaxxing (Tejashmakwana/motionmaxxing, past 300 GitHub stars, Apache-2.0) is an agent skill that turns AI slop videos into films that look made by a motion designer: a 10-step protocol, 12 measured eases, and scripted quality gates G0–G5. This tutorial installs it, renders your first kinetic-type sting, and shows how the gates catch the defaults.
Turn your coding assistant into a full video studio: hands-on with OpenMontage
OpenMontage (calesthio/OpenMontage, past 67,000 GitHub stars, AGPL-3.0) turns your AI coding assistant into an agentic video production studio: 12 pipelines, 100+ tools, and a real-footage documentary path. This tutorial installs it, renders the zero-key demo, and directs your first video — no API keys required.
Give your coding agent an invisible browser: hands-on with invisible-playwright-mcp
invisible_playwright_mcp (feder-cr/invisible_playwright_mcp, 2,758 GitHub stars, MIT) wires a real Firefox — fingerprint patched at the C++ source, not the page — into Claude Code, Codex, Gemini CLI, or any MCP client. This tutorial installs it, wakes the browser, and sends it on a real errand.
Build your own spy-satellite console: track every plane, ship, and satellite live — hands-on with God's Eye View
God's Eye View (bilawalsidhu/gods-eye-view, 52,000+ GitHub stars) packs a spy-satellite console into your browser — 11,000+ live aircraft, thousands of ships, an 838-object satellite catalog, earthquakes, weather, and a voice-controlled AI agent — most of it with zero API keys. This tutorial installs it, tracks a live flight, and talks to the globe.
Turn any document into an editable PowerPoint deck: hands-on with PPT Master
PPT Master (hugohe3/ppt-master, MIT) is an agent skill that turns PDFs, DOCX files, and pasted text into real, natively editable PowerPoint decks — native shapes, data-backed charts, real slide masters — instead of flattened images. This tutorial installs it, points it at a document, and generates a first deck.
Boot an operating system that is an AI agent: hands-on with Herald OS
Herald OS (iamlukethedev/Herald-OS, MIT) is an agent-native operating system with Hermes Agent as the interface — 429 GitHub stars in its first five days. Talk or type to Hermes and it opens apps, organises files, runs routines on a schedule, and builds software while you watch. This tutorial: boot it in a virtual machine, give it a model, and put it through its paces.
Deploy your own private AI assistant to Cloudflare with one command: hands-on with Talorys
Talorys (rociiu/talorys, MIT) deploys a private AI assistant into your own Cloudflare account with one command — chat, memory, tasks, and scheduled reminders on the free tier. Roughly 720 GitHub stars in its first two days. This tutorial: deploy it, teach it to remember things, and set up automations.
Strip the AI accent from your Japanese drafts: a hands-on tour of yomiyasu
yomiyasu (nanaism/yomiyasu, MIT) is an open-source agent skill that turns AI-generated Japanese into text people can actually read: roughly 1,850 GitHub stars as of October 2026. Today we'll install it in Claude Code, run it on a sloppy AI-written draft, check the result with its built-in linters, and learn what it can't fix.
Teach your coding agent to teach itself: a hands-on tour of Reef's self-improving harness
Reef (Human-Agent-Society/reef, Apache-2.0) is infrastructure for continually self-improving agents, with roughly 7,500 GitHub stars. Its built-in Reefine recipe turns a plain-language request into a versioned change to your coding harness — a skill, a rule, an agent command — that you review and install like a release. Today we’ll wire Reef to Ollama, teach our agent a new habit, and inspect the version history.
Run your own deep-research agent: hands-on with Local Deep Research
Local Deep Research (LearningCircuit/local-deep-research, MIT) is a self-hosted, open-source deep-research agent: roughly 9,200 GitHub stars, running on your own machine with Ollama and SearXNG, every answer returned with citations. Today we'll install it, run a cited research report, and build a private searchable knowledge base.
Build your own AI coworkers: hands-on with OpenDots
OpenDots (CopilotKit/OpenDots, MIT) is an open-source template for persistent AI agents: each one has its own Docker computer, its own chat thread, and a human approval step before anything consequential runs. Roughly 4,800 stars in its first two weeks.
Write an interactive novel with an AI that can't rewrite its own characters: hands-on with AI Novel Studio
AI Novel Studio (weike-zhang/ai-novel-studio, MIT) is an AI interactive-fiction app in Next.js + Go where the model proposes each turn's prose and state changes, but the server validates and commits them — so an LLM can't silently rename your characters. Roughly 225 stars in its first week.
You build, AI writes: learn to code while Claude Code builds — hands-on with VibeWise
VibeWise (nykooi1/vibe-wise, MIT) is a plugin for Claude Code and Codex that asks for your approach first and checkpoints every design decision, so you actually learn while the AI writes the code. Around 3,300 stars in its first two weeks.
Text your own AI assistant: a hands-on guide to Open Instinct
Open Instinct (mariagorskikh/open-instinct, MIT) is an open-source clone of Instinct: a personal agent you text over iMessage, with its own Linux desktop, app connections, and a six-tier permission system that gates every tool call. Around 280 GitHub stars in its first week.
See how any app really works: reverse-engineer it with an AI agent — hands-on with REA
REA (morluto/rea, MIT) is one MCP server that wires your coding agent to professional reverse-engineering tools — Ghidra, Hopper, JADX — so you can ask how any app feature works and get answers with evidence. 41,000+ GitHub stars, #1 trending today.
Run a private AI wealth manager on your own machine: hands-on with Aurelio
Aurelio (LosaLosSantos/aurelio-finance, MIT) is a self-hosted wealth-management and financial-planning app with an AI advisor you can talk to: net worth, portfolios, fund look-through, cash flow, and goals — all on your computer. 800+ GitHub stars in its first three days.
Zoom any paper to five levels: a hands-on guide to PaperFold
PaperFold (chenxiachan/paperfold, Apache 2.0) opens any paper, README, or document and lets you zoom it through five levels — full text, brief, key points, takeaway, topic map — with margin notes that travel with you and answers that cite their paragraphs. Nearly 100 GitHub stars in its first five days.
Launch your own AI hotspot news site: hands-on with AIHOT
AIHOT (KKKKhazix/AIHOT, MIT) is the open-source engine behind aihot.news — a self-hosted framework that ingests six source types, scores every story twice with an LLM, clusters duplicates into events, ranks them by heat, and publishes a daily digest. Nearly 6,700 GitHub stars in under two weeks.
Host your own ChatGPT: hands-on with Whirl, the open-source AI chat app
Whirl (whirlchat/whirl, MIT) is the full production code behind whirl.chat — a Next.js 16 + Convex chat app that routes every top model through one conversation, keeps long-term memory, connects your tools over MCP, and edits living documents in a side panel. Roughly 500 GitHub stars in its first week. This walkthrough self-hosts it: clone, wire up Convex and Clerk, and switch on the extras.
Stop re-explaining your project to Claude Code: hands-on with claude-mem
claude-mem (thedotmack/claude-mem, Apache-2.0) gives Claude Code persistent memory: lifecycle hooks capture every session into a local SQLite and vector store, and the next session wakes up already briefed. Install it, build some history, then query that memory when you need it.
Confine an AI agent to one folder and one API: hands-on with Strands Box
Strands Box (strands-agents/box, Apache-2.0) is an open-source sandbox engine for AI agents: operating-system isolation plus deny-by-default policies written in Dogwood. Install it, box the Strands CLI, watch it refuse a file write, then grant exactly that one permission.
Route tickets, pick tools, and score outputs in 115ms: hands-on with Strands Decider
Strands Decider (strands-labs/strands-decider, 503 stars, Apache-2.0) is a 1.9B-parameter decision model for agents: it picks between options, answers yes/no, or rates on a scale in about 115 milliseconds — with a calibrated confidence on every answer. Install it, route a support ticket, batch three question types, and serve it over HTTP.
Benchmark how fast your machine really serves AI agents: hands-on with agentperf-local
agentperf-local (ArtificialAnalysis/aa-agentperf-local, Apache-2.0) replays real recorded agent conversations against your local model server — llama.cpp, vLLM, SGLang, LM Studio, or one it starts for you — and reports throughput and latency the way an agent actually experiences them. The full hands-on: install, the 6-turn quick check, the 168-turn comparable run, and the honest trade-offs.
Cut your AI agent's token bill by 20–60%: hands-on with Headroom, the local compression layer
Headroom (headroomlabs-ai/headroom, ~74.5K stars, Apache-2.0) is a local compression layer for AI agents: it squeezes tool outputs, logs, and JSON before they reach the model — 21–57% fewer input tokens in the project's seeded benchmarks, same answers, nothing leaves your machine. Here is the full hands-on walkthrough, plus the honest trade-offs.
Stop hand-writing agent skills: let Claude Code learn its own — hands-on with AutoHarness
AutoHarness (tigerless-labs/autoharness, ~9.1K stars, MIT) is a self-learning skill layer for Claude Code: it watches your real sessions, distills the lessons into native skills, merges the near-duplicates, and prunes the ones you never use — no daemon, no benchmark. Here is the full hands-on walkthrough, plus the honest trade-offs.
Stop parsing JSON from your LLM: typed decisions with real probabilities — hands-on with AnyJev
AnyJev (nokia-applied-research/AnyJev, ~1,100 stars, Apache-2.0) turns any open LLM into a decision engine: give it a state and a typed question — a choice, a yes/no, or a score — and read the answer as a probability distribution over the options, straight from the model's next-token distribution. Nothing generated, nothing parsed. Here is the full hands-on walkthrough, plus the honest trade-offs.
Give your coding agents an org chart: hands-on with Paperclip, the 98K-star agent orchestrator
Paperclip (paperclipai/paperclip, ~98,000 stars, MIT) is a self-hosted Node.js server and React UI that turns your coding agents — Claude Code, Codex, OpenClaw, Cursor — into an org chart with goals, budgets, and approval gates. One command installs it; here is the full walkthrough, plus the honest trade-offs.
Make your coding agent answer with pages, not walls of text: a hands-on guide to the Answer me with HTML skill
Answer me with HTML (QingYunA/answer-me-with-html, 1,600+ stars, MIT) is an agent skill that turns your coding agent's explanations into readable HTML pages — sequence diagrams, comparison tables, even 3Blue1Brown-style explainer videos — while the model writes 6x fewer output tokens. Here is the one-command install, the settings that matter, and the honest trade-offs.
Run your own voice studio on your own machine: hands-on with VoiceStudio
VoiceStudio (debpalash/VoiceStudio, 53K+ stars, AGPL-3.0) is a fully local, open-source ElevenLabs alternative: voice cloning, voice design, video dubbing, dictation, transcription and audiobook creation in 646 languages. Here’s the one-line install, the cloning workflow, the dubbing workspace, and the local API and MCP hooks for your coding agents.
Run Claude Code on DeepSeek: route every coding agent through one local gateway
Magpie (yetone/magpie, 5,100+ stars, MIT) is a local model gateway on 127.0.0.1:3425 that runs Claude Code on DeepSeek, Codex on Kimi, or Gemini CLI on GLM - with routing groups that fail over when a quota runs dry. Setup, routing, and honest limits, hands-on.
Stop refreshing job boards: build your own AI job hunter with JobRadar
JobRadar (suvamneog/jobradar, 150+ stars, MIT) watches 56 companies' job boards across seven ATS platforms, scores every posting 0–10 against your resume with an LLM, and emails the matches. Setup, scoring rules, and honest limits, hands-on.
Stop nursing broken selectors: describe your tests in plain English — hands-on with e2e
e2e (tester-army/e2e, 3,400+ stars, Apache-2.0) is an end-to-end testing framework where an AI agent drives your web or mobile app from natural-language goals, while deterministic locators and assertions keep the verdict honest. Here’s npx e2e init, the agent.act/agent.assert API, the zero-model-call replay trick, and the honest limits.
Run a 125-billion-parameter model on your own gaming PC: hands-on with Strata
Strata (Niko1221/Strata, 11,000+ stars in ten days, MIT) runs Qwen3.8-Flash-Next — a 125-billion-parameter model — on a gaming PC with 12 GB of VRAM and 32 GB of RAM. One-click install, an OpenAI-compatible API at localhost:8080, and about 53 tokens per second on an RTX 5070. Here’s the hardware check, the model sizes, and how to point your coding agents at it.
Is your model getting quietly worse? Build a daily LLM drift monitor — the livenerf playbook
livenerf (ninjahawk/livenerf, 1,200+ stars, MIT) asks whether frontier models quietly get worse after launch — and turned the argument into a 30-day experiment with a day-0 baseline. Steal the playbook: freeze a discriminating question panel, run it daily on your model with Inspect, and catch drift with statistics instead of vibes.
Give your coding agent real eyes: hands-on with Chrome DevTools MCP
Chrome DevTools MCP (ChromeDevTools/chrome-devtools-mcp, 53,000+ stars, Apache-2.0) hands your coding agent the keys to a live Chrome browser — screenshots, console messages, network requests, performance traces, and Lighthouse audits. Install it with one command, then let your agent see what it builds.
Stop tabbing back to the terminal: monitor Claude Code from your Mac's notch — hands-on with Coucou
Coucou (3,200+ stars, MIT) puts a live companion in your Mac's notch that watches your coding agents — live session steps, file diffs as they happen, and permission approvals with one click. Download it, install the Claude Code hooks, and stop tabbing back to the terminal.
Stop burning tokens on grep: find code by asking what it does — hands-on with jevgrep
jevgrep (dzhng/jevgrep, 2,100+ stars, MIT) turns repo questions into source excerpts: ask what the code does, Jev judges relevance, your coding agent gets a place to start. Install it, authenticate, install the skill, and stop burning tokens on grep.
Give your AI agent eyes on the whole internet: hands-on with Agent Reach, the 89K-star toolkit
Agent Reach (89K+ stars, MIT) gives any coding agent read-and-search access to X, Reddit, YouTube, GitHub, Bilibili, and more — one CLI, zero API fees. Install it, run agent-reach doctor, and put the social internet behind a single command.
Make your coding agent talk like a caveman: a hands-on guide to cutting its token bill
caveman (109K stars, Apache-2.0) teaches your coding agent to talk like a caveman: a one-command skill trims its output, a local proxy shrinks what it reads before every call — measured at -33.2% input tokens, red rows and all. The hands-on setup.
Stop your coding agent trusting stale docs: a hands-on guide to seiso
seiso (MIT, ~170 stars) is a Markdown convention and linter built for docs written by AI and read by humans and agents. Install it, declare each document's kind, hook it into Claude Code — and make stale docs fail loudly.
Read arXiv papers like a well-typeset book: a hands-on guide to EasyRead
EasyRead (MIT, 600+ stars) re-typesets any PDF into a bilingual book on your own machine — formulas and tables intact, AI answers in the margin, and a CLI your coding agents can drive. The hands-on setup.
Run Z.ai’s 7,300-star coding agent yourself: a hands-on guide to ZCode
ZCode (7,300+ stars, Apache-2.0) is Z.ai’s open-source coding agent harness: terminal TUI, web UI, a plugin marketplace, MCP servers, and deterministic guardrail hooks. Build the agent CLI from source and put hooks around your agent’s tool calls — in about half an hour.
Give your AI agent a browser: hands-on with browser-use, the 117K-star library
browser-use (nearly 117K stars, MIT) turns any LLM into an agent that clicks, types, and scrolls like a human. Install the Python library, wire up your model, and drive a real browser from a script — in about 15 minutes.
Skills for Real Engineers: hands-on with Matt Pocock's 274K-star agent skills
Matt Pocock's agent-skills collection just topped GitHub's trending AI repos with 274,000+ stars. Install the engineering skills — /grill-me, /tdd, /code-review — into your coding agent and run a real change through them, start to finish.
Merge models, don't just train them: hands-on model merging with MergeKit
SLERP, task arithmetic, and TIES/DARE, explained by actually running them: merge Qwen2.5-0.5B with its instruct sibling on a CPU, verify the identity merge, and measure what the midpoint really does.
Write your own GPU kernels in 30 lines of Python: a hands-on guide to TileLang
The fastest models alive run on hand-tuned GPU kernels. TileLang is an 8,167-star Pythonic tile-level language that compiles to CUDA, ROCm, Metal, and Ascend — here’s the 30-line tiled matmul that opens the door.
Stop vibe-coding: give your AI agent a real methodology — hands-on with Superpowers
Your coding agent doesn’t need more tools — it needs a methodology. Superpowers is a 294K-star skills framework that forces your agent to brainstorm, plan, TDD, and review like a senior team. Hands-on: install, bootstrap injection, and a full loop.
OpenClaw: run your own self-hosted AI agent on WhatsApp and Telegram — hands-on with the 391K-star personal assistant
OpenClaw is the 391K-star open-source personal AI assistant that runs on your own machine and answers inside WhatsApp, Telegram, and 20+ other chat apps. I installed it, connected Telegram, and set up a scheduled briefing — here is every verified step.
MoneyPrinterTurbo: turn any topic into a finished short video — hands-on with the 128K-star AI video pipeline
Hands-on with the open-source pipeline that scripts, voices, subtitles, and renders vertical short videos end to end — including a zero-API-key run you can do today.
Fit Qwen3-32B on one GPU instead of two: hands-on with Glyd's lossless model compression
Glyd (surya-koritala/Glyd) compresses bf16 weights and KV cache losslessly — about 33% less GPU memory, bit for bit. Pack a model with the CLI, load it packed in Python, serve it through vLLM, and put the compression levels to work on your own data. Every command below is from the project's own README.
Stop vibe-checking your model: write real evals with inspect_ai, the UK AI Safety Institute's framework
inspect_ai is the open-source eval framework from the UK AI Safety Institute: datasets, solvers, and scorers composed into reproducible Tasks. Build a multiple-choice benchmark, a custom numeric grader, and a tool-using agent eval — all runnable with zero API keys via the scriptable mock model.
One endpoint, 359 providers, zero API keys: hands-on with OmniRoute, the free AI gateway
OmniRoute (diegosouzapw/OmniRoute, MIT) collapses every model API key into one local OpenAI-compatible endpoint: 359 providers, 150+ free, automatic failover, and a compression stack claiming 78–95% token savings. Installed 3.8.51, booted the gateway, listed 478 models, and watched the router score upstreams — every command ran exactly as shown.
Your agent built the app — now take it live: hands-on with GoLive, the deployment skill for coding agents
GoLive (mikehasa/golive-skill, MIT) is the open-source agent skill + zero-dependency Node CLI that takes an agent-built app from repo to production: detect the stack, choose providers, write an explicit plan, approve it, then apply — with a human gate on every risky step. We ran detect, menu, init, doctor, plan, teardown, and verify on a demo Next.js app — every command executed.
Univer: give your AI agent a real spreadsheet — the open office harness, hands-on
Univer MCP (dream-num/univer-mcp, MIT) is a Model Context Protocol server that plugs AI agents straight into Univer, the 22K-star open-source office SDK. Wire it into Claude Code, point the agent at a live workbook, and have it build, format, and audit a real spreadsheet from a single prompt.
Turn any photo into an animatable 3D model: hands-on with img2threejs, the 17K-star image-to-code pipeline
img2threejs is an Apache-2.0 agent skill that rebuilds objects from a single photo as procedural Three.js code — quality-gated, staged, and self-correcting. We installed the skill, the img2 harness, ran its 1,364-test suite, and executed its intake gates for real. Every command verified.
Make Claude Code mod any PC game you own: a hands-on guide to universal-modder
universal-modder (rehan-remade/universal-modder) is the MIT toolkit that turns Claude Code, Codex, Cursor, or Gemini CLI into a game-modding agent: 12 engine playbooks, a fal-powered asset pipeline, the um CLI, and a knowledge base of field notes. Install the skills, scan your game library, brief the agent, and contribute your own field note.
GRPO from scratch: implement the RL algorithm behind DeepSeek-R1 in ~200 lines of PyTorch
Group Relative Policy Optimization — the RL algorithm behind DeepSeek-R1's reasoning — implemented from nothing in ~200 lines of PyTorch: sample groups of completions, score them with a verifiable reward, reinforce what beats the group average. No TRL, no critic, no value network — and every number measured on a real CPU run: 17% to 50% accuracy in about six minutes.
NPC-Forge: build conversational agents with zero ML — hands-on with the deterministic, CPU-only agent framework
NPC-Forge is a deterministic, CPU-only conversational-agent framework with no ML and no LLMs: a 24,000-intent terminal assistant, a built-in test suite, and an OpenAI-compatible gateway that serves every NPC as a model. Install it, test it, and build your own tool-calling NPC in one JSON file.
Hire an AI red team for the price of an API key: hands-on with Strix, the 65K-star autonomous pentesting agents
Strix (usestrix/strix) sends autonomous AI agents to hack your app inside a Docker sandbox and reports only vulnerabilities they have proven with a working exploit. We installed 1.6.2, mapped every CLI flag, built a deliberately vulnerable target and proved its holes, and wired the CI gate — command by command.
OpenRig: run Claude Code and Codex as one persistent agent team — hands-on with the 3,300-star multi-agent harness
OpenRig (mvschwarz/openrig) turns Claude Code, Codex, and Pi into persistent teams — roles, shared context, owned work — defined in one YAML file and launched with rig up. We installed @openrig/cli 0.6.3, previewed its setup plan, started the daemon, inspected the starter teams, and planned a two-agent launch, command by command.
Get decisions with real probabilities from any open LLM: a hands-on guide to AnyJev
AnyJev (nokia-applied-research/AnyJev) is the Apache-2.0 toolkit that turns any open LLM into a Jev-style decision model: typed choices, yes/no and score questions with probabilities you can actually threshold. Truncate a Qwen to two-thirds depth, serve it with vLLM, and fit a closed-form head from 100-300 labels — auto-decidable traffic goes from 7.7% to 52% at 5% risk. Every command verified against the project's own docs.
Pi: the 110,000-star open-source coding agent you can point at any model
Pi (earendil-works/pi) is the MIT-licensed open-source coding agent climbing GitHub trending: a unified multi-provider LLM API, a scriptable headless agent loop, and BYO-model support via a single models.json. Install 0.99.2, wire it to your own endpoint, and watch it write and read files — every command ran exactly as shown.
Herdr: run every coding agent in one terminal — hands-on with the 41K-star Rust multiplexer
Herdr is a 41K-star Rust terminal multiplexer rebuilt for the agent era: a background server keeps your coding agents’ terminals alive, marks each one working, blocked, or idle, and exposes everything over a socket API you can drive headlessly. Install it, build a three-pane dev rig, and survive a server restart — every command verified.
LoopGain: stop your agent loop the moment it actually converges — hands-on with the control-theoretic cost controller
LoopGain is an Apache-2.0 Python library that replaces max_iterations with a control-theoretic stop-and-rollback policy: it watches your loop's error trajectory, stops the moment it converges, and rolls back to the best iteration. Install it, run the verified examples, and wire it into any verify-revise loop.
Stop letting your coding agent grep: hands-on with CodeGraph, the 72K-star pre-indexed code knowledge graph
CodeGraph (72,600+ GitHub stars) pre-indexes your codebase into a local SQLite knowledge graph — symbols, call edges, imports — so your coding agent answers architecture questions in one explore call instead of forty grep-and-Read round-trips. We installed v1.6.1, indexed a real project, ran every query that matters, and wired the MCP server into an agent.
See exactly what your coding agents cost: hands-on with Agent Console, the 765-star local-first token dashboard
Agent Console (765 GitHub stars, MIT) reads the transcripts Claude Code and Codex already write on your machine and turns them into a local dashboard: tokens by class, per-model cost estimates, live burn rate, and spend alerts — no account, no telemetry, no build step. Installed v0.4.1 from source and from the signed release, walked the demo, pointed it at real sessions, joined a second machine to a team hub.
Your agents can't talk to each other: build two interoperating agents with the A2A protocol — hands-on
A2A (Agent2Agent) is the Linux Foundation's open protocol for agent-to-agent communication: MCP connects agents to tools, A2A connects agents to each other. We built two real interoperating agents with the official Python SDK 1.2.1 — a FactFinder research agent and a BriefWriter that delegates to it — covering agent cards, the task lifecycle, artifacts, and true delegation. No API key, no GPU; every command verified.
Context Mode: stop your coding agent from burning its context window — a hands-on tutorial
Context Mode (24,500+ GitHub stars) is an MCP server that runs your agent's code in an isolated sandbox so only stdout reaches the model, indexes knowledge into a local SQLite FTS5 search, and keeps sessions alive across compactions. Installed v1.0.169, ran every tool, wired it into an agent — the full hands-on walkthrough.
HypoArena: run a full AI co-scientist pipeline entirely offline — hands-on
HypoArena is an open-source workbench that decomposes AI co-scientist pipelines into testable stages — synthetic corpora, grounding checks, debate loops, Elo tournaments — all running offline with no API keys. This hands-on tutorial installs it, runs the full pipeline, and learns to read its reports.
Your agent forgets everything between sessions — fix it with mem0, hands-on
mem0 is the open-source memory layer for AI agents — 66,000+ stars, Apache 2.0. We wired it into a chatbot with real API calls: store, search, and retrieve memories per user. Every command verified.
Stop shipping untested prompts: test your LLM prompts like code with promptfoo — hands-on
promptfoo is an open-source CLI for test-driven LLM development: write assertions for your prompts, run them like a test suite, and gate deploys on the results. This tutorial builds a real prompt eval from scratch — a zero-cost mock provider, eight assertion types, a caught regression, CSV test scaling, and a CI gate — with no API key and no GPU.
Diagrams your agent can defend: hands-on with Archify, the 73K-star skill for verifiable architecture diagrams
Archify turns system descriptions into interactive, self-contained HTML diagrams — and pins every box to a git citation the renderer verifies against real committed code. We rendered all five diagram types, watched the evidence gate catch three of our own bad citations, and diffed two architectures.
Claude Code, fully loaded: set up agents, commands, MCPs, and skills with claude-code-templates
claude-code-templates (#7 on GitHub weekly trending, 32,000 stars) installs curated Claude Code agents, commands, MCP servers, and skills with one npx command. We installed a full stack, wired Postgres, ran the health check, and found the two things that are broken.
OpenRouter for agent tools: self-host one registry for every API your agents call — hands-on with treg
treg is OpenRouter for agent tools: one base URL and one token for every API your agents call, with real credentials injected server-side. We self-hosted the registry, registered a tool, and verified the injection end to end.
An AI web agent with its own unblockable browser: hands-on with dots
dots pairs any OpenRouter model with a real patched-Firefox browser engineered to look human from the inside out — no WebDriver flag, human-like clicks, one identity per seed. Install it with uvx and put it to work in 10 minutes.
Build a deep-research agent that never hallucinates its sources
Deep-research tools hallucinate their citations. Build the fix: a ~360-line Python evidence engine that decomposes questions, searches Wikipedia, OpenAlex, and Crossref in parallel, ranks passages with BM25, cross-verifies every DOI, and emits reports where every claim cites a real source. Zero API keys — every call verified live.
PaperGraph MCP: turn arXiv math papers into theorem maps and proof-evidence trails — hands-on
PaperGraph MCP (275 stars in four weeks) turns arXiv papers into evidence-grounded reading maps: extracted theorems, proof evidence with source spans, and explicit dependency edges. We installed v1.1.7, loaded two real papers, and verified every command.
Write HTML, get MP4: hands-on with HyperFrames, the 54K-star video framework built for agents
HyperFrames turns HTML, CSS and a paused GSAP timeline into a deterministic MP4 — and ships skills so coding agents can author video. I verified every step: the stock template fails its own check, vendored libraries fix it, and a three-scene product intro renders in 99 seconds.
Late-interaction retrieval with ColBERT: beat BM25 and retire your reranker — measured end-to-end
ColBERT's late interaction beats BM25 on paraphrased queries and can retire your reranker. I measured both end-to-end on a CPU: recall, MRR, latency, and the exact setup that works.
Run a real penetration-test workflow from your AI coding agent: a hands-on guide to Blitz Strike
Blitz Strike is a free, MIT-licensed MCP server that turns any AI coding agent into a security auditor: recon, source-to-sink tracing, and live verification in a single tool call. We wired it up and ran an engagement.
Split any song into six stems on your own machine: hands-on with StemDeck
StemDeck is a free, Apache-2.0, local-only stem separator: six studio stems from any song with Meta's open Demucs model, plus BPM/key/LUFS analysis and a DAW-style mixer. We installed it, ran a real separation end to end, and measured every stage. Every command verified.
DBX: one 25 MB database client for 100+ databases — hands-on with the AI SQL assistant and MCP server
DBX (t8y2/dbx) is an Apache-2.0, Rust+Tauri database client — one 25 MB binary for 100+ databases, with a CLI, an MCP server, and a built-in AI SQL assistant. We installed the CLI and MCP server, connected a real SQLite database, ran schema inspection, bounded queries, context and DBML exports, and set up the agent skill. Every command verified.
Route every AI coding agent to any model from one menu bar: hands-on with magpie
magpie (yetone/magpie, MIT, 3,100+ stars in its first week) puts every AI agent's model in one menu-bar screen — click a value, pick a model. We installed it, routed Codex to DeepSeek and Claude Code to Kimi, and tested its local translation gateway. Every command verified.
One-shot a playable browser game with a frontier model: the workflow behind the Opus 5.5 demos
A Reddit poster claims Sonnet 5.5 one-shot a 3D zombie FPS in 49 minutes — but the demos skip the workflow that makes it repeatable. Here’s the complete process: spec-first prompting, the debug loop, playtesting, juice, and shipping, with every step verified on a real game we built and ran.
Sepia: strip the AI out of your writing at the structural layer — hands-on with the 2.9K-star writing skill
Sepia is an MIT-licensed writing skill that de-AIs prose at the structural layer, not the word layer — 2,900+ GitHub stars in its first month. We installed it twice, validated its persona checker, ran its 94-test suite, and walked a release note through its full review protocol. Every command verified.
Page Agent: give any web page its own AI agent — hands-on with Alibaba's in-page GUI agent
Page Agent is Alibaba's MIT-licensed in-page GUI agent — 29,276 GitHub stars — that turns any website into a natural-language-operated page with one line of JavaScript. We installed [email protected], drove its real agent loop with a scripted model backend, and watched it fill forms, pick dropdown options, and click buttons. Every command verified.
Turn your AI agent into a research scientist: a hands-on tutorial for Scientific Agent Skills
Scientific Agent Skills is a 168-skill, MIT-licensed library — roughly 47,000 GitHub stars — that teaches coding agents to do real science. We installed it, validated all 168 skill manifests, and ran one skill’s bundled tooling to produce a genuine figure. Every command verified.
Stop guessing which LLM fits your machine: a hands-on guide to llmfit
llmfit scans your CPU, RAM, GPU, and VRAM, then scores hundreds of open models on fit, speed, quality, and context — so you download the model that actually runs well. Install, recommend, simulate, and verify — every command verified against the project's README.
Stop writing your own agent loop: a hands-on tutorial for OpenAI's Agents API
OpenAI’s DevDay put a managed agent harness behind a single API call. Build a long-running, tool-using agent on the Agents API — sessions, sandboxes, MCP tools, subagents, and cleanup — with every line verified against the official docs.
Impeccable: teach your AI coding agent to design like a design director — hands-on with the 72K-star skill
Impeccable, Paul Bakaus’s 72K-star design skill for AI coding agents, pairs 24 named design commands with 61 deterministic detector rules that run with no LLM and no API key. I scanned a deliberate AI-slop page hands-on — 12 findings down to zero — and documented every command.
Hands-on with NVIDIA Model Optimizer: quantize once, export anywhere
NVIDIA's Model Optimizer gained ~900 GitHub stars in four days: one Python API for quantization, pruning, distillation, and speculative decoding, plus a unified export to TensorRT-LLM, vLLM, and SGLang. I ran INT8 weight-only quantization end-to-end on a CPU-only VM — 6.5 seconds, no quality loss, one-third smaller checkpoint — and documented the INT4 AWQ attempt the sandbox OOM-killed.
PageIndex: vectorless, reasoning-based RAG you can run on your own models — hands-on
PageIndex hit 37,000 GitHub stars by throwing away the vector database: it indexes PDFs as hierarchical trees and sends an agent to walk them. I ran the whole loop locally with my own model — here is the full hands-on tutorial.
Give your AI agent a real memory: hands-on with Hindsight, the local-first memory layer
Hindsight (42k GitHub stars) gives AI agents persistent memory: retain facts, recall them with hybrid search, and reflect over them agentically — all running locally on Ollama. We verified every step end-to-end on a 2-core CPU box.
Ship your own AI news desk in an afternoon: a hands-on guide to AIHOT
Clone it, boot it with four commands, and you have a self-running news desk: AIHOT collects from six source types, double-scores every item with an LLM, clusters reports into events, ranks by heat, and publishes a daily briefing at 08:00.
Stop paying flagship prices for easy questions: build an LLM cascade router that escalates only when it matters
Your API bill is dominated by easy questions answered by your most expensive model. Build a cascade router that tries the cheap model first and escalates only when confidence is low — pricing, backends, scorers, and thresholds, measured end-to-end.
Stop feeding your agent the whole repo: a hands-on tutorial for code-review-graph
code-review-graph (26,500+ stars, 6,400 added in a single week) builds a persistent local map of your codebase — functions, callers, tests, blast radius — and serves it to any AI coding agent over MCP. Install, build, wire it up, and run a real change-impact review — every command verified.
Compose a full song on your own GPU: hands-on with YuE2, the open model taking on Suno
YuE2 (multimodal-art-projection/YuE, 10,500+ stars) writes an editable melody-and-chord plan before rendering a full song with vocals — and beat Suno v5 and v6 on WildSongBench. This tutorial installs it, generates a song from lyrics and a style prompt, reads the score it planned, and re-renders an edited version.
Jeff: run Jev-style zero-shot decisions on your own machine — hands-on with the 0.8B model
Jeff (firelex/jeff) is a 0.8B open-weight decision model that answers Jev-format choice, yes/no, and score questions in a single forward pass — trained on one workstation GPU. We installed it, served it locally, and built a working support-ticket triage pipeline with confidence-gated human escalation. Every output measured, every command verified.
Red-team your evals: catch reward hacking in your LLM judges, hands-on
Your LLM judge just crowned the worst model the winner — because it learned what the judge likes: length, confidence, pretty formatting. We built a runnable red-team harness that proves the leaderboard can invert, then measured five defenses that catch it. No API keys, no GPU, just Python.
Orca: run Claude Code, Codex, and every other CLI agent in parallel git worktrees — hands-on
Orca (stablyai/orca) is the MIT-licensed agent development environment that puts a fleet of coding agents into isolated git worktrees — 81,000+ GitHub stars and a real CLI. We installed v1.4.216 on Linux, ran it headless, and drove the whole loop: repo add, parallel worktrees, terminals, output streaming, and cleanup. Every command verified.
Install 25 senior-engineer workflows into your AI coding agent: hands-on with Addy Osmani's agent-skills
addyosmani/agent-skills passed 99,700+ stars with 25 production engineering workflows for AI coding agents. We installed the full pack, ran one skill end-to-end, and executed the repo's own validators and evals — here's the complete, verified setup guide.
Turn raw footage into final.mp4 with one chat command: a hands-on guide to video-use
Drop raw footage in a folder, chat with your coding agent, get final.mp4 back: install browser-use's 27,500-star video-use skill and run your first edit.
Speculative decoding with llama.cpp: measured end-to-end on a CPU — when it helps, when it hurts
Speculative decoding promises free speed for local LLMs: a tiny draft model guesses tokens, the big model verifies them in bulk. We set it up in llama.cpp b11243, measured it end-to-end on two CPU threads — and it made generation 2x slower. The honest breakdown: setup, numbers, acceptance rates, and the break-even math.
ECC: the 269K-star agent harness OS — install, skills, and AgentShield scans, hands-on
ECC is the agent-harness operating system blowing up GitHub: 269,000 stars, MIT-licensed, with a real CLI that installs skills, agents, and rules into your coding agent — plus AgentShield, a 102-rule scanner for your agent config. We installed it, scanned a sloppy config, and fixed it. Every command verified.
Ponytail: teach your AI coding agent to write less code — a hands-on tutorial
Ponytail is the "lazy senior dev" skill for AI coding agents — roughly 148,000 GitHub stars and climbing. We installed it, fired its hooks, ran its MCP server and its 121-test suite, and walked the seven-rung ladder. Every command verified.
Run a 744B-parameter model on your own machine: a hands-on tutorial for Colibri
Colibri streams frontier MoE models — 744B to 2.8T parameters — from your own disk in pure C with zero dependencies. Build the engine, verify the launcher, fetch a model container, and chat — plus the Brio mode trick that scores answers without generating them.
Tencent's Octop: run your own multi-agent AI assistant at home — hands-on
TencentCloud/Octop (MIT) is a self-hosted, multi-user AI assistant: one Python process serving a web dashboard, CLI, chat channels, and scheduled expert agents. This hands-on tutorial installs octop 1.0.1, wires any OpenAI-compatible provider, creates experts, and verifies the full chat loop and dashboard.
OKF Agent Memory: give your coding agents a git-native memory that survives every session
OKF Agent Memory stores your coding agent’s project knowledge as plain Markdown in your repo — with BM25 search, validation, and an MCP server in one 7.6 MB Go binary. This tutorial installs v0.4.4, bootstraps a project, writes real concepts, and wires the memory into an agent over MCP.
Transcribe anything on your own machine: a hands-on guide to faster-whisper
Ditch the transcription API. Install faster-whisper, pick the right Whisper model size, filter silence with VAD, and generate timestamped subtitles — all offline, all measured.
Tencent's WeKnora: turn your documents into a RAG knowledge base, agent, and wiki — hands-on
Tencent's WeKnora gained ~4,000 GitHub stars in ten days. I built the Lite binary from source, wired it to local models, ingested documents, and got cited answers back — here is the whole thing, hands-on.
One API for every LLM: run LiteLLM as your AI gateway
Stop hardcoding model providers into your app. Stand up LiteLLM's OpenAI-compatible proxy, wire in multiple models, and prove failover, retries, load balancing, and caching against live traffic — no API keys required.
Compile TypeScript to native binaries with Vercel Labs' scriptc: a hands-on tutorial
scriptc (vercel-labs/scriptc, Apache-2.0) is a TypeScript-to-native compiler at #6 on GitHub trending. Install it, compile hello world to a 56KB binary, benchmark fib(32) ~4.6x faster than Node, and ship a native HTTP server — every step executed.
Claude Code hooks: the complete hands-on guide to deterministic agent control
CLAUDE.md is advice; hooks are enforcement. A hands-on guide to Claude Code's lifecycle hooks — PreToolUse guards, PostToolUse automation, Stop gates, and prompt enrichment — with scripts tested end to end.
DeepSeek Harness: build your own plugins for DeepSeek's open agent runtime, hands-on
DeepSeek didn't just release another model this summer — it released the runtime. We installed the open-source DeepSeek Harness, pointed it at a $0 local model, and built a custom tool plugin — every command verified.
RTK: cut your AI agent's token burn with a Rust CLI output proxy
RTK (81,000+ GitHub stars) is a single Rust binary that compresses shell output before your coding agent reads it. Install it, measure real 41–74% output reductions on your own repo, and wire it into Claude Code with one hook.
Anthropic's knowledge-work-plugins: turn Claude Code into a role-specialist, hands-on
Anthropic's official plugin collection passed 25,700 stars and hit GitHub trending this week. Install it, run a real skill end to end, dissect the plugin anatomy, customize it, and build your own — every step verified.
Spec-driven development with GitHub Spec Kit: make your AI agent build what you actually meant
Prompt your agent and it invents; hand it a specification and it implements. GitHub's Spec Kit turns that discipline into a repeatable workflow — constitution, spec, plan, tasks, implementation — and this tutorial walks every artifact end to end, with every CLI command executed.
Laya: replace your LLM-as-a-judge with a 322M-parameter decision engine
Laya (26,000+ GitHub stars in 9 days) is a non-autoregressive System 1 decision engine: typed choice, score, and yes/no decisions over any text in a single forward pass, in 100+ languages. Install it, triage real support tickets, and add confidence-gated abstention — every step executed on CPU.
CLI-Anything: turn any desktop app into a tool your AI agent can actually use
CLI-Anything (50,000+ GitHub stars) is a registry of agent-native CLI harnesses for real desktop software: pip-installable command lines with JSON output, REPLs, and SKILL.md files your coding agent can use. Install the hub, generate a shareable diagram, resize a 3D-print hole — every step executed.
A 2-bit model that calls your tools: hands-on with Cactus Needle 3
Cactus Needle 3 is a 121M-parameter model quantized to ~2 bits that picks the right tool, fills every argument, and refuses to invent the ones it was never given — all offline, in under 100 MB of RAM. Install it, wire up real tools, and watch the grounding guardrails work; every step executed.
Cut your prompt tokens in half: a measured guide to prompt compression
Your prompts are carrying dead weight: bloated system instructions, messy retrieved context, verbose tool schemas. Four compression techniques cut a realistic RAG prompt nearly in half with zero lost answers — and every number below was measured with tiktoken, not estimated.
Perplexity's Bumblebee hit 5,000 stars in days: scan your machine for supply-chain compromises, hands-on
Perplexity's open-source Bumblebee turns your lockfiles, editor extensions, and MCP configs into a searchable package inventory — then matches it against real supply-chain compromise catalogs. Install it, run your first exposure check, and write your own catalog, every step verified.
Search your codebase by meaning: a hands-on tutorial for zvec-grep (zg)
zvec-grep (zg) unifies ripgrep, BM25, and vector search behind one local-first CLI — no API key, no server, no GPU. This tutorial installs it, indexes two real workspaces, and runs every query route against them, then wires it into a coding agent over MCP.
Your agent reads the internet: stop prompt injections from hijacking its tools
Indirect prompt injection is the unsolved security problem for AI agents: malicious instructions hidden in webpages, emails, and tool outputs. Build a vulnerable agent, watch it get owned, then layer four real defenses on top — and red-team every one.
Turn your coding agent into a security auditor with Cloudflare's security-audit-skill
Cloudflare's security-audit-skill turns "audit this code" into an accountable agent workflow: a coverage ledger, isolated hunters, adversarial validation, and machine-checked findings. This hands-on tutorial installs it, audits a deliberately vulnerable app, and validates every finding — every command executed, every output real.
Alibaba's OpenCodeReview hit #1 on GitHub Trending: a hands-on tutorial
Alibaba's OpenCodeReview pairs deterministic review engineering with a tool-using LLM agent. Install v1.12.9, connect a model, and review a real flawed commit — every command verified, every output real.
Stop paying twice for the same question: build a semantic cache for your LLM app
Exact-match caches miss every rephrased question. This tutorial builds a semantic cache — embeddings, a tuned similarity threshold, SQLite persistence — and measures it: hit rate, latency, and dollars saved per 1,000 queries, all run on a CPU with free tools.
Stop hand-tuning prompts: build and optimize an LLM program with DSPy
Prompt strings are the new spaghetti code: untestable, unversioned, and silently brittle. This hands-on DSPy 3.4 tutorial replaces them with typed signatures and composable modules, measures a real baseline, and compiles the program with BootstrapFewShot — 55.6% to 88.9%, every number actually run, free and offline.
Your 32K context window is a marketing number: measure what your model actually remembers
Vendors advertise 128K, 200K, million-token context windows — but how much of that window does a model actually use? Build the classic needle-in-a-haystack test, run it on a local model, and read the heatmap like an eval engineer.
Fine-tune embeddings for your domain: contrastive training that measurably improves retrieval
Generic embeddings rank the wrong document first on domain jargon. This tutorial fine-tunes all-MiniLM-L6-v2 with 60 contrastive pairs on a CPU in about 80 seconds — and measures accuracy@1 rising from 0.694 to 0.861 on held-out queries.
Teach Claude your workflow: build an Agent Skill with SKILL.md
Skills are folders with a SKILL.md file — a tiny open standard, now read by dozens of AI tools, that packages your repeatable workflows so any agent can use them. This tutorial builds one end-to-end: frontmatter, instructions, a validation script you can actually run, and install.
Qwen3.8-27B on your own hardware: the complete local setup guide
Qwen3.8-27B — Alibaba's 27B-parameter open model with a 262K context window — runs on a single gaming GPU, if you do the VRAM math right. This guide walks through exact VRAM arithmetic, the quant ladder, three verified serving paths, and taming the model's thinking.
From notebook to production: deploy your RAG chatbot on a free tier
Take a RAG chatbot from a Python file to a public HTTPS URL: FastAPI service, Docker container, Render Blueprint deploy, health checks, secrets, and free-tier survival — every command run, every output real.
From ratings to retrieval: a beginner-friendly book on recommender systems, with code that actually runs
Recommender Systems: From Ratings to Retrieval is a 142-page beginner’s guide to how recommenders actually work — 13 chapters, runnable Python throughout, every number produced by running the code. The companion code is free on GitHub today, and the first two chapters are a free PDF.
Testing agents: task-based evals for tool-using models
Impression-based testing breaks down the moment your agent starts calling tools. Here's the practical machinery behind trustworthy agent evals: sandboxed tasks, three kinds of graders, sharp success criteria, and a failure taxonomy that tells you what actually went wrong.
Automate your marketing with AI workflows: an n8n starter
n8n lets you build AI-driven marketing automations you actually own — from lead enrichment and scoring to content repurposing and follow-up sequences. Here is a practical starter guide with a working workflow template.
Build your first MCP-powered agent: tools, servers, and safety rails
Wire a model to real tools through the Model Context Protocol. You'll build a working MCP server, connect it to an agent host, and add permission scopes and guardrails before anything can touch your files.
Build a voice agent in a weekend: STT, LLM, TTS
Speech in, speech out. A weekend plan for wiring a streaming voice agent — picking STT, LLM, and TTS services, cutting latency below a second, and handling interruptions like a human would.
Give your chatbot a memory: session state that actually works
Context windows fill up and sessions reset. This tutorial walks through the three memory architectures that actually hold up in long conversations — summarization, retrieval-based recall, and entity stores — and how to combine them.
Consistent characters in AI images: a reference-image workflow
Keep the same face across every scene. This tutorial walks through reference images, character weight, seeds, and editing chains — from Midjourney's reference system to open-source identity adapters and character LoRAs.
Context engineering: the 2026 skill every AI builder needs
Model choice gets the headlines, but what goes inside the context window decides what your AI app actually does. Here's a systematic approach to designing context — from token budgets to compaction to RAG hygiene — that works across any model.
Document extraction at scale: invoices to structured data
A practical blueprint for turning messy invoice PDFs into clean, validated JSON — combining OCR, vision models, schema-enforced extraction, and a validation loop.
Embeddings for product search: build a semantic recommender
Keyword search matches strings; embeddings match meaning. This tutorial walks through building a semantic product search and a 'customers also liked' recommender from a raw catalog, step by step.
Build your first RAG pipeline in an afternoon
Retrieval-augmented generation is the highest-ROI pattern in applied AI. Here's a complete, working RAG pipeline — ingest, chunk, embed, retrieve, generate — you can build today with open tools.
Hybrid Search: BM25 plus Vectors in One Pipeline
Vector search understands meaning but fumbles exact terms like error codes and product IDs. BM25 nails exact terms but misses paraphrases. Here's how to fuse both into a single hybrid retrieval pipeline — with the math, the tuning knobs, and working code.
Write Your First LLM Eval: A Practical Guide
Start from real failures, build a small golden dataset, calibrate an LLM-as-judge against humans, and wire the whole thing into CI as regression testing for your prompts.
Add guardrails to your LLM app: filters, PII redaction, jailbreak detection
A layered defense you can ship this week — input screening, output checks, and monitoring that stop PII leaks, prompt injection, and jailbreaks before they reach users.
Fine-tune a model with LoRA on a single GPU
Adapt an open-weights model to your domain in an evening: pick a base model, prepare data, train LoRA adapters on one GPU, and evaluate the result — with working code.
Cut your API bill 75%: a prompt-caching tutorial
Prompt caching is the highest-ROI optimization most API users skip. This tutorial shows how it works on Anthropic, OpenAI, and Google Gemini — with pricing math, code samples, and the pitfalls that silently zero out your savings.
Prompt engineering that survives contact with production
Tips-and-tricks prompt advice falls apart in real apps. Here is how to build system prompts, curate few-shot examples, and test for failure modes so your LLM behavior survives scale.
Chain-of-thought and self-consistency: reasoning prompts that work
Why asking a model to show its work transforms multi-step reasoning, when step-by-step prompting backfires, and how sampling multiple answers and voting delivers the biggest accuracy win.
Serve an open model with vLLM: a deployment tutorial
From downloading weights to a monitored production endpoint — how to deploy an open-weights model with vLLM, tune throughput, apply quantization, and watch it with Prometheus.
Structured outputs: getting JSON you can trust from LLMs
Malformed JSON from LLMs doesn't have to be a fact of life. Here's the full reliability stack — strict schemas, provider enforcement, constrained decoding, and validation-and-repair loops — that ends the bug for good.
Build a support agent that knows when to escalate
The difference between a support agent customers trust and one they curse is escalation design: calibrated confidence thresholds, rich handoff context, and human-in-the-loop gates. This tutorial walks through building all three.
Seeing is prompting: a vision-model tutorial
Screenshots, diagrams, and product photos can all be prompts — but vision models see the world differently than you do. Here is what they do well, where they fail, and how to prompt them better.