SkipCI
340 subscribers
137 photos
173 links
Daily reviews of trending GitHub repos & AI dev tools. Tested, not hyped
Download Telegram
38 diagram types that don't look like Mermaid vomited on your README

Ask an AI coding assistant for a diagram and you get the same thing every time: generic rounded boxes, a default color scheme, zero relation to your actual brand. Fixing it by hand means opening Figma and losing thirty minutes to a color picker.

This is a skill for Claude Code, Codex, and Pi that replaces the whole habit. It ships 38 editorial diagram types — architecture, flowcharts, state machines, pyramids, and more — as self-contained HTML and SVG. No build step, no JavaScript, no external image dependencies, and no shadows or Mermaid-style clutter.

Each diagram comes in three static variants — minimal light, minimal dark, full editorial — and the skill can read your website to match colors and style automatically. Install it, ask for a diagram, open the HTML file in a browser.

github.com/cathrynlavery/diagram-design
One coding agent, any model, zero lock-in

Most coding assistants chain you to a single model vendor. OpenCode is a terminal-native coding agent written in TypeScript that lets you plug in whatever model you want and keeps it that way — free and open source, no rented intelligence.

It ships two built-in agents you flip between with a single Tab press: build mode edits files and runs commands freely, plan mode stays read-only and asks permission before touching your shell, which makes it safe for poking around a codebase you don't fully trust yet. A general-purpose subagent handles multistep searches in the background.

Install it with one command, point it at any repo, and start handing it real tasks — it reads, edits, and runs things right in your terminal, no IDE plugin required.

https://github.com/anomalyco/opencode
Stop letting a bad format string crash your C++ program

{fmt} replaces printf and iostreams in C++ with something faster and harder to misuse. printf can crash on a mismatched format string, and iostreams force chains of << just to print a few values. {fmt} uses Python-style format strings checked at compile time, so an invalid specifier is caught before the program ever runs.

It's built for speed: a Dragonbox-based float formatter with correct rounding, minimal dynamic allocation, and an optional compile-time format path make it tens of percent to tens of times faster than sprintf and iostreams. It also formats containers, dates, times, and colored terminal output through the same simple API.

The core is a few headers with no external dependencies, MIT-licensed, and it's the basis for C++20's std::format and C++23's std::print. Drop it into an existing project and start formatting.

github.com/fmtlib/fmt
Dictation that never phones home your voice

OpenWhispr turns speech into text at your cursor, in any app, with a single hotkey press. Run it fully offline using Whisper or NVIDIA Parakeet — your audio never leaves the device — or switch to cloud models with your own API key when you want more speed. No telemetry, no data collection, ever.

Past plain dictation it becomes a voice-driven assistant: talk to GPT-5, Claude, Gemini, Groq, or a local model, dictate in one language and get the text pasted in another, or let it transcribe meetings live with on-device speaker diarization and voice fingerprinting, no cloud required.

It's a JavaScript/Electron app for macOS, Windows, and Linux, fully open source. Grab a build from the releases page, or clone the repo and run npm install && npm run dev to build it yourself.

https://github.com/OpenWhispr/openwhispr
Your own hedge fund, run entirely by AI agents

Building a real trading desk normally takes analysts, risk managers, and traders working around the clock. AutoHedge replaces that team with a swarm of specialized agents: a Director for strategy, a Quant for analysis, a Risk Manager for position sizing, and an Execution Agent to place the trades.

Each agent hands its output to the next in a structured pipeline, so a thesis gets generated, checked, sized, and executed without a human in the loop. Everything comes back as JSON with full logging, so you can audit exactly why a trade happened.

It's fully open source and written in Python. Install with pip install -U autohedge, drop in your API keys and wallet, and it's already trading autonomously on Solana, with Coinbase support on the way.

https://github.com/The-Swarm-Corporation/AutoHedge
A directory of tools that never ask for your email

FckSignups is a curated, open-source list of browser tools you can use the instant you click through — no account, no verification email, no credit card just to resize an image. Every entry is checked to work with zero signup.

The catch that isn't: over 200 tools, sorted into categories like design, development, privacy, and writing, each open source in its own right. Entries that stand out from the crowd get flagged as featured, so the list stays browsable instead of turning into a wall of duplicates.

It's a React + TypeScript app you can run yourself in four commands, or just browse it live. Missing your favorite no-signup tool? Submit it through the site or open an issue — the schema is simple: name, link, category, done.

…
A headless browser that isn't secretly Chrome in a trenchcoat

Lightpanda is built from scratch for AI agents and automation, no Chromium fork, no WebKit patch underneath. Written in Zig, it skips the weight that headless Chrome drags along: on a 100-page crawl it used 123MB of memory against Chrome's 2GB, and finished in 5 seconds instead of 46.

It plugs into what you already use: point Puppeteer or Playwright at its CDP server and nothing else in your script changes. There's also a WebDriver Bidi mode, and an `lightpanda agent` command that drives the browser from plain-English instructions in your terminal, then exports the session as a plain JavaScript script you can replay without an LLM.

Grab a nightly build via Homebrew, the AUR, Docker, or a direct binary for Linux and macOS, or build it from source.

…
Your scraper just got a Cloudflare-proof disguise

Playwright gets blocked. Headless Chrome gets fingerprinted on the first request. Even stealth plugins end up being the tell that gives you away. camofox-browser sidesteps all of it by wrapping Camoufox, a Firefox fork that spoofs navigator properties, WebGL, AudioContext, and screen geometry at the C++ level — before any JavaScript ever runs to detect it.

It ships as a REST API built for agents rather than humans: accessibility snapshots instead of bloated HTML, stable element refs like e1, e2 for reliable clicking, and search macros for sites like Google and Reddit. It's a drop-in replacement for Puppeteer or Playwright, idles at ~40MB of memory, and runs fine on a $5 VPS or a Raspberry Pi.

Try it with npx @askjo/camofox-browser, or clone the repo, run npm install && npm start, and hit http://localhost:9377. Docker and an OpenClaw plugin are both supported out of the box.

…
Your AI agent can write HTML all day. Now it can ship video too.

HyperFrames is an open-source framework that renders HTML, CSS, media, and seekable animations straight into deterministic MP4 files. No editor, no timeline — just markup in, video out, the same result every time.

It's built for agents, not humans clicking timelines. Skills teach Claude Code, Cursor, Codex, Gemini CLI, and other agents the full loop: plan the video, write valid HTML, wire up animations, add media, lint, preview, render. One prompt describing a video is enough to trigger it.

Try it with npx skills add heygen-com/hyperframes, or for agent and non-interactive runs npx hyperframes skills update. Written in TypeScript, Apache-2.0 licensed.

…
Your AI agent is burning its own context — this MCP server stops it

Every tool call dumps raw data into your agent's context window — a single Playwright snapshot alone costs 56 KB. After half an hour, 40% of that context can be gone, and when the conversation compacts, the agent forgets what it was doing.

Context Mode is an MCP server that sandboxes tool output before it reaches the model — 315 KB drops to 5.4 KB, a 98% cut — and persists session memory in SQLite with FTS5 search, so a resumed session picks up exactly where it left off.

It also changes the habit: instead of reading dozens of files into context, the agent writes a small script that does the work and logs only the result. Routing is enforced via hooks across 17 platforms, not left as something to remember.

Install through Claude Code's plugin marketplace or npm, then run the built-in doctor command to confirm everything is wired up.

mksglu/context-mode
Stop feeding your LLM raw PDFs

Messy PDFs, Word docs, and spreadsheets are a mess for language models to parse. MarkItDown is a lightweight Python tool that converts them into clean Markdown, keeping the structure that matters: headings, lists, tables, and links, instead of a wall of unformatted text.

It goes further than office files. Images get OCR and EXIF metadata, audio gets transcribed, and YouTube URLs get their captions pulled — all normalized into the same Markdown your model already reads natively. ZIP archives are handled too, converting everything inside.

Trying it takes one line: pip install 'markitdown[all]', then markitdown path-to-file.pdf > document.md. Pipe input in, get Markdown out. A plugin system adds extras like LLM-vision OCR for scanned documents.

github.com/microsoft/markitdown
Give your AI agent hands: it clicks, types, and fills forms like a human

Most agents choke the moment a task needs a real browser: pop-ups, logins, multi-step forms, messy layouts. Browser Use hands your agent an actual browser instead of a text box, so it can open pages, click buttons, and complete the task you described in plain English.

It works both ways: point it at a job application and it fills every field and submits, or point it at a profile page and it extracts structured data straight to CSV. Pick any LLM, run it locally, and pair it with any agent you already use, from Claude Code to Cursor.

Install with uv add browser-use or pip install browser-use, drop an API key in .env, and run your first agent in a few lines of Python. It's open source and written in Python, ready to plug into whatever you're building.

https://github.com/browser-use/browser-use
An AI trading desk you can run from a single Python repo

TradingAgents is a multi-agent framework that simulates a trading firm instead of one model doing everything. Fundamentals, sentiment, news, and technical analysts each produce their own read, then bullish and bearish researchers debate the findings before a trader and a risk-management team decide whether the trade happens.

The interesting part is the disagreement: agents argue through structured debate rounds, and a portfolio manager approves or rejects the final proposal before anything reaches the (simulated) exchange. It supports many LLM providers, from GPT and Claude to Gemini, Grok, DeepSeek, Qwen, and local Ollama models.

Clone it, add your API keys, and run the CLI or import it as a package. Built for research, not financial advice, but a way to see how far agent teams get on messy, real-world data.

https://github.com/TauricResearch/TradingAgents
Design 3D buildings in your browser, no CAD required

Pascal Editor is an open-source 3D building editor that runs entirely in the browser, built with React Three Fiber and WebGPU. Sketch walls, drop in furniture, and render the result instantly, without months of learning professional CAD software.

What sets it apart: AI agents can build scenes too. Pascal ships an MCP server, so an agent can connect and design a scene directly, with dedicated agent skills for scene setup and furniture-fit checks.

The whole thing is a TypeScript monorepo under the MIT license, split into clean packages, a core state layer, a rendering viewer, the editing tools, and a CLI that ties it all together.

Try it locally with a single command:
npx @pascal-app/cli editor
It starts the editor plus an authenticated MCP service on your machine, no repository clone needed.

https://github.com/pascalorg/editor
❤1
Skills that let your coding agent design real hardware

Most coding agents can write software but stall the moment a task needs actual geometry. text-to-cad is a Python library of agent skills that plugs that gap: it generates and edits CAD models from plain-language requests, exporting STEP, STL, 3MF, or GLB.

Beyond CAD, the library covers the rest of the pipeline: sourcing off-the-shelf STEP parts, drawing 2D DXF layouts, writing URDF/SRDF/SDF robot description files, checking mesh printability, and slicing meshes into printer-ready G-code.

Install it with the Skills CLI (npx skills add earthtojake/text-to-cad) for supported agents, or grab the native plugin for Codex, Claude Code, or Grok Build. It's MIT-licensed and open source.

…
Your browser just became a spy satellite — and every feed on it is real

God's Eye View puts live aircraft, ships, satellites, earthquakes, and public cameras onto one photorealistic 3D globe, running locally in your browser. No dashboard full of tabs, no separate trackers for planes and ships and quakes — one map, real public data, click anything to follow it.

The unusual part: click a plane and you ride inside its cockpit as the camera tracks the terrain beneath it. Switch the whole globe to thermal, night vision, or a military HUD with a GLSL shader swap. There's also a realtime voice agent, so you can just talk to it and have it draw boundaries or routes on the world for you.

It runs keyless out of the box — clone it, npm ci, npm run dev, and you're looking at live traffic with no accounts and no API keys. Add a free Cesium ion token later for full photorealistic terrain if you want it. It's plain JavaScript, fully open source, and built to be extended with your own data layers.

…
A 744B-parameter model, running on hardware you already own

Frontier MoE models usually need a hyperscaler's GPU cluster. Colibrì streams experts straight from disk into RAM and VRAM, in pure C with zero dependencies, treating storage as part of one memory hierarchy. It boots a 744B-parameter model in about 32 seconds using under 10 GB of resident RAM.

Eight model families run today, from 7B to 2.8T parameters, through one front end: coli chat, coli serve, coli web. A live dashboard shows thousands of experts firing in real time, with token metrics and the VRAM/RAM/disk tier bar.

It's built as an open research platform: no promise on speed, but a hard guarantee that limited fast memory only changes performance, never model semantics. Clone it, point it at a model, and run ./coli chat.

https://github.com/JustVugg/colibri
Stop guessing which LLM your machine can actually run

Downloading a 30GB model only to watch it crawl at 0.5 tok/s is a special kind of pain. llmfit is a Rust CLI that scans your CPU, RAM, GPU, and VRAM, then scores hundreds of open-source models across quality, speed, fit, and context length — before you ever hit download.

It ships as a zero-dependency interactive TUI by default, ranking every model your hardware can handle, plus a CLI and REST API for scripting into pipelines. It works with the runtimes you already use: Ollama, llama.cpp, MLX, LM Studio, and Docker Model Runner. Multi-GPU rigs and MoE architectures are handled too.

The newest trick: benchmark your own runs and submit real tok/s numbers back to the project straight from the TUI. Your hardware's measured results replace estimates for everyone else on the same setup.

Install with brew install AlexsJones/llmfit/llmfit, scoop install llmfit, or the curl installer, then just run llmfit.

https://github.com/AlexsJones/llmfit
An open-source trading agent that never sleeps through a market move

CloddsBot is a self-hosted AI agent that trades across 1000+ markets at once — Polymarket, Kalshi, Binance, Hyperliquid, Solana DEXs, and five EVM chains. Most bots watch one venue and miss everything else; this one scans them all in parallel, finds the edge, and executes without waiting on you.

It's built on Claude, so setup is a conversation rather than a config file: run one command, answer the onboarding wizard, and it's live. Under the hood it manages its own risk — sizing, limits, a kill switch — and ships an agent commerce protocol so it can pay other agents directly, machine to machine.

Written in TypeScript, runs on your own machine, and the whole thing is open for you to read, fork, or point at your own strategies.

github.com/alsk1992/CloddsBot
Most AI research tools skim an abstract and call it done. This one reads the paper.

Hyperresearch turns Claude Code into a research agent that works through dozens to hundreds of sources before writing one sentence, instead of summarizing whatever the search snippet says. Even paywalled papers get chased down through legal open-access routes instead of being cited from a thin auto-generated abstract.

What's unusual is where the work goes: every source it touches lands in a persistent, searchable knowledge base instead of a throwaway context window. Ask about the same topic again next month and it starts from what it already knows rather than researching from zero. The report itself goes through a staged pipeline with adversarial critics attacking the draft before it ships, so claims get checked, not just written.

Install it with pip install hyperresearch, run hyperresearch install inside your project, then type /hyperresearch followed by your topic in Claude Code.

github.com/jordan-gibbs/hyperresearch
Stop making your LLM re-read everything, every time

Most RAG setups retrieve and re-answer from scratch on every single question, burning tokens and never actually accumulating understanding. LLM Wiki reads your documents once and incrementally builds a persistent, interlinked wiki that just keeps growing instead of resetting.

Ingest runs in two steps — the LLM analyzes a source first, then writes wiki pages with full source traceability, and a SHA256 cache skips files that haven't changed. A 4-signal knowledge graph with Louvain community detection surfaces connections you'd never think to search for, and images embedded in your PDFs get captioned and made searchable too.

It's a free cross-platform desktop app with a local HTTP API and bundled MCP server, so it drops straight into Claude Code or Codex as an agent skill and can answer strictly from your own sources.

github.com/nashsu/llm_wiki