DEV Community: Muhammad Tayyab

gstack: Y Combinator CEO Garry Tan's Open-Source Claude Code Setup That Ships Like a Team

Muhammad Tayyab — Fri, 16 Oct 2026 12:41:00 +0000

Garry Tan runs Y Combinator full-time and still shipped 3 production services and 40+ features in 60 days, part-time, using AI agents. His setup is now open source: gstack turns Claude Code into a virtual engineering team, with 23 slash-command specialists acting as CEO, designer, eng manager, release manager, doc engineer and QA. All Markdown, all free, MIT licensed. 136,500 stars and counting.

The Y Combinator CEO Who Ships Like a Startup

The most interesting thing about gstack is not the code. It is the person who wrote it.

Garry Tan is the President and CEO of Y Combinator. Before that, he was one of the first engineers, PMs and designers at Palantir, co-founded Posterous (which sold to Twitter), and built Bookface, YC's internal social network. He has worked with thousands of startups, including Coinbase, Instacart and Rippling back when each was one or two people in a garage.

And in the middle of running YC full-time, he has been quietly shipping more software than at any point in his twenty-year career. gstack is his exact personal setup for doing it, the slash commands and agent skills he uses every day, open-sourced with an MIT license. His own description is blunt: "This is my open source software factory. I use it every day."

810x: The Numbers Behind the Software Factory

The README opens with a quote from Andrej Karpathy: "I don't think I've typed like a line of code probably since December, basically, which is an extremely large change." Tan heard that and wanted to find out how one person ships like a team of twenty. Part of his answer came from watching Peter Steinberger build OpenClaw, now at 247,000 stars, essentially solo with AI agents.

Then he published his own numbers. In the last 60 days before the README was written: 3 production services, 40+ shipped features, part-time, while running YC full-time. Measured on logical code change (not raw lines of code, which AI inflates), his 2026 run rate is about 810 times his 2013 pace: 11,417 versus 14 logical lines per day. Year to date, 2026 had already produced 240 times his entire 2013 output, measured across 40 public and private repos including Bookface.

He is upfront about the caveat. AI wrote most of it. His point: "The point isn't who typed it, it's what shipped." There is even a full methodology document in the repo, ON_THE_LOC_CONTROVERSY.md, with the reproduction script, for anyone who wants to argue with the measurement.

What gstack Actually Gives You

Strip away the story and gstack is this: it turns Claude Code into a virtual engineering team. A CEO who rethinks the product, an eng manager who locks the architecture, a designer who catches AI slop, a reviewer who finds production bugs, a QA lead who opens a real browser, a security officer who runs OWASP and STRIDE audits, and a release engineer who ships the PR.

Concretely, that is 23 specialists plus 8 power tools, all exposed as slash commands, all Markdown, all free. The command list reads like an org chart: /office-hours, /plan-ceo-review, /plan-eng-review, /review, /qa, /ship, /cso, /autoplan, /retro, /investigate, /learn, and more.

The core loop the README recommends:

Run /office-hours and describe what you are building
Run /plan-ceo-review on any feature idea
Run /review on any branch with changes
Run /qa on your staging URL
Stop there. You will know if this is for you.

Installing gstack Takes About 30 Seconds

Requirements: Claude Code, Git, and Bun v1.4.2 or newer (Node.js additionally on Windows). On macOS the Aside browser is recommended for the browser-driven skills, but setup builds its own bundled browser if it is missing.

Open Claude Code and paste this. Claude does the rest:

git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup

Then add a "gstack" section to your CLAUDE.md listing the available skills. There is also a team mode (./setup --team) that bootstraps a shared repo so teammates get gstack automatically, with no vendored files and no version drift.

Claude Code is the fully supported host, but gstack is not Claude-only. ./setup --host auto installs for every agent it detects, with Codex CLI, OpenCode, Cursor, Kiro and GitHub Copilot CLI at an experimental tier, and OpenClaw gets native support since it spawns Claude Code sessions.

Who It Is For

Good fit if you are a technical founder who still wants to ship, a first-time Claude Code user who wants structured roles instead of a blank prompt, or a tech lead who wants rigorous review, QA and release automation on every PR.

Poor fit if you want a fully hands-off pipeline. gstack keeps you in the loop by design: /office-hours interrogates you, /plan-ceo-review challenges your scope. If you would rather the agent just go, the structure will feel like friction.

Read the full breakdown with FAQs on DevPik: https://www.devpik.com/open-source/gstack

Scientific Agent Skills: Turn Your AI Agent Into an AI Scientist

Muhammad Tayyab — Thu, 15 Oct 2026 12:15:22 +0000

Ask your AI coding agent to dock a molecule against a protein, and it will happily write the code. Ask it which protonation state the ligand should carry at physiological pH, and you get a confident answer that may be wrong in a way that invalidates the whole run. That gap, between being able to call a library and knowing how a field actually uses it, is what Scientific Agent Skills exists to close.

It is a free, MIT-licensed library of 177 validated skills plus 100+ scientific databases, created by K-Dense, that turns Claude Code, Cursor, Codex, Gemini CLI, Google Antigravity, Pi or any host speaking the open Agent Skills standard into something the project calls an AI Scientist. The skills cover biology, chemistry, medicine, physics, engineering, Earth science, data analysis and scientific communication. The repository has 49,945 stars and 4,455 forks, was created in October 2025, and ships version 2.72.0. There is even an arXiv paper describing the collection: Scientific Agent Skills: A Library of Procedural Knowledge for Research Agents.

The phrase "procedural knowledge" is doing the heavy lifting there. Each skill is not a prompt. It is a SKILL.md carrying the purpose, the workflow, the version metadata, the scientific conventions and the validation checks for one package, data source or workflow. Your agent already knows how to import RDKit. The skill tells it which conformer generation settings the field trusts, and what to check before believing the output.

What Is Inside: The 177 Skills in Five Buckets

The collection breaks into five groups, and the counts tell you where the weight is:

Bucket	Size	What you get
Scientific and financial databases	100+	The Database Lookup skill documents 80 sources with public, registered or licensed access: PubChem, ChEMBL, UniProt, COSMIC, ClinicalTrials.gov and more, with endpoint selection, pagination and provenance. Dedicated skills add DepMap, PrimeKG, AlphaGenome and others
Optimized Python package skills	70+	Version-aware workflows for RDKit, Scanpy, scikit-learn, PyTorch Lightning, PyTDC, BioPython, Qiskit, GeoPandas, pymatgen, molecular dynamics (OpenMM/MDAnalysis) and more
Scientific integration skills	9	Benchling, DNAnexus, LatchBio, OMERO, Protocols.io, Open Notebook, Ginkgo Cloud Lab, LabArchives, Opentrons
Analysis and communication tools	30+	Literature review, evidence-traceable writing, peer review, Paperclip (full-text papers with line-pinned citations), Exa Search, macro-free PPTX posters, Mermaid diagrams
Research and clinical tools	10+	Hypothesis generation, grant writing, PK/PD modelling and simulation, BIDS, ISO standards-readiness preparation, analytical method validation

Two things are worth noting about that table. First, the skills are an explicitly defined floor, not a ceiling: the agent can still use any Python package or API, these are just the pre-documented paths that make common workflows faster and more dependable. Second, skills with bundled scripts ship with a test suite under tests/<skill-name>/ and a dependency entry in a shared requirements file, so the collection is maintained like software, not like a folder of prompts.

Why Procedural Knowledge Beats a Clever Prompt

The difference shows up in the small print. A generic agent asked to convert genomic coordinates will happily produce an answer. The Genomic Coordinates skill exists because BED, GFF, GTF, VCF, SAM and WIG files disagree about 0-based versus 1-based indexing and contig naming, and getting that wrong silently corrupts the analysis. The skill catches the mismatch before it happens.

That pattern repeats across the library. The primer design skill runs bounded local or BLAST-assisted specificity screening instead of just returning Primer3 candidates. The QIIME 2 amplicon skill checks read retention through denoising instead of assuming the pipeline worked. The marine carbonate chemistry skill carries measurement uncertainty instead of reporting a single number. Each of these is a mistake a smart non-specialist makes exactly once, and the skill makes sure the agent does not make it at all.

This is also why the collection documents versions. The skills pin baselines like PathML 3.0.8, GeoPandas 1.2.0 and build123d 0.13.0, and each skill records its own compatibility requirements and validation scope. Scientific software moves fast and breaks workflows quietly; version-aware guidance is the difference between a result you can trust and one you have to redo.

Install It in One Command

The standard route installs into every supported host at once:

npx skills add K-Dense-AI/scientific-agent-skills

That covers current versions of Claude Code, Claude Cowork, Codex, Gemini CLI, Google Antigravity and Cursor. If you use the GitHub CLI (v2.90.0 or newer), gh skill gives you more control:

gh skill install K-Dense-AI/scientific-agent-skills
gh skill install K-Dense-AI/scientific-agent-skills scanpy   # one skill only
gh skill install K-Dense-AI/scientific-agent-skills --pin v2.71.0   # reproducible

Pinning to a release tag or commit SHA is worth doing for any published workflow, since skill guidance and package baselines both move. gh skill update --all pulls everything current again.

For plugin clients, the repo is also a valid Agent Plugins 1.0.0 package (plugin.json plus skills/), so Cursor, Codex, GitHub Copilot, VS Code, Kiro and other compatible clients can load the whole collection as one plugin. Manual installs follow the ~/.agents/skills/ convention for user-level or .agents/skills/ for project-level. Installing a topical subset keeps the catalog focused: a genomics lab does not need the battery cycling skill in context.

What You Can Actually Ask It to Do

Once installed, the agent picks up relevant skills on its own, or you can name one directly. The README's worked examples read like real lab notebooks:

Drug discovery pipeline. "Query ChEMBL for EGFR inhibitors (IC50 < 50nM), analyze structure-activity relationships with RDKit, generate improved analogs with datamol, perform virtual screening with DiffDock against the AlphaFold EGFR structure, search PubMed for resistance mechanisms, check COSMIC for mutations, and create visualizations and a comprehensive report." One prompt, six skills, a full preclinical prioritization.

Single-cell RNA-seq. The Scanpy skill handles the analysis, Bulk RNA-seq prepares validated counts for a PyDESeq2 handoff, and Pathway Enrichment covers the downstream ORA and GSEA. The handoff boundaries are explicit, which matters: each step's output is validated before the next step consumes it.

Virtual screening campaign, primer design, variant evidence review, systems biology network analysis. The pattern is the same every time: the skill supplies the conventions, the agent supplies the labor, and the validation checks decide whether the result stands.

The Database Layer: 100+ Sources With Provenance

The database coverage deserves its own section because it solves the most tedious part of computational research: finding the right source, hitting the right endpoint, and knowing whether the data can be trusted.

The Database Lookup skill documents 80 databases with their access requirements (public, registered or licensed), endpoint selection, pagination contracts and provenance checks. Dedicated skills go deeper on high-value sources: DepMap for cancer dependency data, PrimeKG for precision medicine knowledge graphs, AlphaGenome for DeepMind's precomputed variant effects across GRCh38. Multi-database packages like BioServices, Biopython and gget extend the reach further.

Provenance is the key word. A number without a source is a rumor, and the skills treat it that way: retrieval contracts say what was fetched, from where, and under what access terms. For anyone building on published analyses, that is the difference between reproducible and decorative.

The Honest Boundaries: What It Refuses to Decide

This is the section that most raises confidence in the project. The skills that touch sensitive territory carry explicit research-only boundaries, stated in the skill, not buried in a disclaimer page:

Healthcare AI and biosignal skills cover EHR and model research and retrospective validation, explicitly not patient-specific diagnosis, treatment, alarms or deployment decisions.
Preclinical animal-welfare skills do severity scoring and humane-endpoint forecasting as an aid to assessment, never as a decision rule, with EU Directive 2010/63/EU reporting in mind.
Regulatory skills prepare draft evidence artifacts for ISO and ICH/USP/CLSI frameworks for qualified review, never as certification, accreditation or method-release decisions.
Variant effect predictions from AlphaGenome are marked research only, not clinical.

The security disclaimer is equally direct: skills are documentation and helpers, and anything that touches credentials, lab hardware or licensed data sources needs the operator's own review. An agent that knows where its authority ends is more useful than one that never asks.

K-Dense BYOK: The Free AI Co-Scientist on Your Desktop

If you want the skills without assembling the agent setup yourself, K-Dense ships K-Dense BYOK, a free, open-source AI co-scientist that runs on your own desktop. You bring your own API keys, pick from 40+ models, and get a full research workspace with web search, file handling, 100+ scientific databases and all 177 skills from this repo. Your data stays on your computer, and you can optionally scale heavy workloads to cloud compute via Modal.

It is the same playbook as the skills themselves: the labor is automated, the judgment stays with the researcher, and nothing phones home with your data.

Repo Health: 49,945 Stars and an arXiv Paper

The repository was created in October 2025 and had 49,945 stars, 4,455 forks and 32 open issues at the time of writing, with the latest push landing on 12 October 2026. Version 2.72.0 is current. The README is backed by a large docs tree, the blog carries skill benchmarks and deep dives, and CI runs security scans and skill tests on every change.

The durable signals: every skill carries version metadata and a validation scope, breaking changes are documented in release notes, and the project is unusually willing to state what each skill will not do. The commercial side is K-Dense Inc., which offers enterprise support; the skills themselves are MIT licensed with no paid tier.

Good fit if you do computational research in any of the covered domains and you already use an AI coding agent. It is strongest where the conventions are sharp and the mistakes are silent: genomics coordinates, chemistry protonation states, phylogenetics pipelines, PK/PD modelling.

Poor fit if you want the agent to make the call a specialist should make. The skills prepare evidence and draft artifacts; the treatment decision, the certification and the diagnosis stay human, by design. It is also not a substitute for learning the domain: the skills encode the conventions, but you still need to know which question to ask.

FAQ

What is Scientific Agent Skills?

Scientific Agent Skills is a free, MIT-licensed library of 177 validated skills plus 100+ scientific databases for AI agents, created by K-Dense. Each skill gives an agent the procedural knowledge, conventions and validation checks for one scientific package, data source or workflow, covering biology, chemistry, medicine, physics, engineering, Earth science and scientific communication.

Which AI agents does it work with?

Any host that supports the open Agent Skills standard: Claude Code, Cursor, Codex, Gemini CLI, Google Antigravity, Pi, OpenClaw and others. It is also packaged as an Agent Plugins 1.0.0 plugin for Cursor, Codex, GitHub Copilot, VS Code and Kiro. Install with npx skills add K-Dense-AI/scientific-agent-skills.

Is Scientific Agent Skills really free?

Yes. The collection is MIT licensed with no paid tier. K-Dense offers commercial enterprise support separately, and the optional K-Dense BYOK desktop app is also free and open source; you only bring your own model API keys.

Can it diagnose patients or certify lab methods?

No, and the skills say so explicitly. Healthcare skills are for research and retrospective validation, not diagnosis or treatment decisions. Regulatory skills prepare draft artifacts for qualified human review, never certification or accreditation. The judgment stays with the researcher.

How is this different from just asking my AI agent to do science?

A generic agent can call any library, but it does not know the field's conventions: 0-based versus 1-based genomic coordinates, validation handoffs between analysis steps, or which package versions a workflow was tested against. The skills encode those conventions with version-aware guidance and validation checks, so the agent's output can be trusted, not just generated.

How do I install only the skills I need?

With the GitHub CLI: gh skill install K-Dense-AI/scientific-agent-skills scanpy installs one skill. Or clone the repo and copy selected skill folders into ~/.agents/skills/. Pinning with --pin v2.71.0 keeps published workflows reproducible.

Originally published on DevPik.

Anti-Slop: Stop AI Agents Shipping Generic UI

Muhammad Tayyab — Thu, 15 Oct 2026 09:44:10 +0000

Anti-Slop is a free, MIT-licensed rulebook for AI coding agents: 38 rules in three tiers, six skills and a pass/fail Delivery Gate that strip generic UI, filler copy and slop code out of what your agent ships.

What Anti-Slop Actually Is

Every AI coding agent has a house style, and it is not yours. Ask Claude Code, Cursor or Codex for a landing page and you get the page everyone else gets: a sparkle logo, a beta pill above the headline, a fake terminal reporting 0.0001ms latency, and statistics nobody measured. Anti-Slop is a rulebook that exists to stop exactly that.

It is a free, MIT-licensed set of 38 mandatory rules (R-01 to R-38) that an AI coding agent reads at the start of a session and applies to the UI, copy and code it produces. The repo was created in August 2026 and has passed 4,200 stars on GitHub, with a fresh release (v3.2.20) landing this week. Nothing here runs as an app. Anti-Slop ships as agent skills: folders holding a SKILL.md that your agent loads as standing instructions.

A note on the GitHub language label, which says JavaScript. The installer is an npm package, but the substance is markdown: rules, checklists and examples that the agent reads rather than code that you run. Clone this expecting a codebase and you will find a very well-organised rulebook instead.

The one-line summary the project gives itself is the honest one: a filter, not a style guide. It prescribes no colors, no fonts and no layouts. It removes what should not be there, and the direction that replaces it stays yours.

The Problem: AI Output Has a Default Look

Slop is the default AI look and sound, and you have seen all three versions of it.

In UI: the color-fading banner, the identical rounded cards, the "Unlock the power of..." headline, the invented metrics row. The repo's own four-way comparison is blunt about it: one brief, built with no filter, produced a page claiming a "10,000% ROI Synergy Multiplier" and a "5.0 rating from 500,000 founders", neither of which exists. That is not a design flaw. It is an honesty flaw, and it ships because nothing in the agent's instructions forbids it.

In copy: excitement that says nothing. Emoji bullets, hype in every line, fake-candid openers, social proof with no evidence behind it. DevPik's own AI Text Cleaner exists to strip exactly these artifacts out of text after the fact; Anti-Slop tries to stop them being written in the first place.

In code: box-drawing section banners, emoji comments, and a comment on every constant that restates the constant. If you have ever reviewed AI-written code and deleted twenty comments that added nothing, that is the pattern the code skill hunts. Our AI Code Detector flags the same family of tells from the reviewing side.

The commercial point underneath all of this: AI output currently looks alike, so it all reads as cheap. A filter that removes the tells is worth more than another prompt telling the model to be creative.

How It Works: 38 Rules in Three Tiers

The 38 rules are not a flat checklist. They are tiered by how much judgement they allow.

Hard Gate rules are absolute. No exceptions, no negotiating with them.
Purpose-Gate rules ask whether a choice has a purpose, and reject technique that has none.
Quality Locks apply the same test at the polish level: every shadow, animation, stat and section has to earn its place.

On top of the rules sits a Liveliness Toolkit: three dials (ENERGY, RHYTHM and MOTION) and a Design Read, so the result comes out alive rather than merely clean. This is the part that separates Anti-Slop from a lint pass. Removing slop is subtraction; the toolkit exists so that subtraction does not leave you with something sterile.

The rules reference each other by number, and the skills (next section) build on the core instead of duplicating it, so adding a skill never changes the core. Rule R-37 is the one to remember: a sterile result means the direction was missing, not that the filter failed. Anti-Slop never beautifies on its own.

Six Skills, Loaded Only When a Task Needs Them

Anti-Slop ships as six skills. One core always loads; the other five load only when a task needs them, which matters, because an agent dragging copywriting rules into a database migration is wasting context and diluting instructions.

Skill	Covers	Pick it for
antislop	The core filter: rules, tiers, the Delivery Gate, liveliness	Everything. Always loaded
antislop-ui	Layout, color, components, decoration, motion, structure	UI and visual work
antislop-copywriting	Headlines, CTAs, tone, fake stats, anti-AI writing, markdown hygiene	Copy and text
antislop-human	Contrast, keyboard, focus, states	Accessibility
antislop-layoutmobile	Reflow across screen widths, breakpoints, grids, overflow, tap targets	Responsive work
antislop-code	AI-slop comments: which to remove, which to keep	Comment cleanup

Install one, several, or the core alone. The human skill (accessibility) deserves a specific mention: low-contrast text and keyboard traps are the two most common ways AI-generated pages fail real people, and the skill pushes agents toward the WCAG 2.2 basics they otherwise skip. If you are comparing skill-based tooling in this ecosystem, Cloudflare's security audit skill takes the same load-only-what-you-need model in a security direction.

The Delivery Gate: A Pass/Fail Report Before Anything Ships

Rules that nobody checks become suggestions. The Delivery Gate is Anti-Slop's enforcement mechanism: before anything ships, the agent must run a mandatory PASS/FAIL report in four blocks that you can read and challenge. A build that fails the gate does not get quietly shipped with a note attached; it gets fixed, or it stays unshipped.

In practice this changes the texture of working with the tool. You are not trusting the agent to have absorbed your taste. You are reading a checklist verdict at the end of every session, the same way you would read a CI result before merging.

One honest caveat, taken from the project's own guide: the gate only bites where Anti-Slop arrives as a skill. Inside a coding agent, a skill is an instruction the agent is built to follow, and the gate runs. Paste the single-file version into a chat window and the rules become reference material instead: still genuinely useful for tone and structure, but no chat app runs the Delivery Gate for you.

Two Modes: Guide New Builds, or Audit What You Already Have

Anti-Slop runs one of two ways, and by default the agent asks which at the start of every session. Both end with a report you can check; they differ in when the rules apply.

During guides the work while it is built, and the session closes with the Delivery Gate report. Use it when you are building something new.
After audits work that already exists: a numbered findings list, you approve which items to fix, then a follow-up report. Use it to clean up output you already have.

Being asked every session gets old, so a saved preference is opt-in (it arrived in v3.2.20, the current release). Set it once with npx antislop-ai --mode during. Swap during for after to default to audits, use ask to restore the question, or run --mode alone to see the current setting. The shared settings file is plain JSON (~/.config/antislop/settings.json on Linux and macOS, %APPDATA%\antislop\settings.json on Windows), so if you hand-edit it, running it through a JSON formatter first is worth the ten seconds. When a saved preference is active the skill announces it once ("antislop active: during (global preference)"), and an explicit instruction in the current chat always outranks the saved setting without overwriting it.

Works With the Agent You Already Use

The README lists thirteen supported agents: Claude Code, Codex, Antigravity, OpenCode, Cursor, Cline, Amp, Gemini CLI, Hermes, GitHub Copilot, Kimi Code, Pi and Oh My Pi. The installer covers twelve of them and detects which ones you have. Seven (Claude Code, Antigravity, Codex, Cursor, Kimi Code, Cline and Oh My Pi) also have plugin doors that load Anti-Slop straight from this repository with nothing copied into your project, and Pi installs through its own package manager.

This makes Anti-Slop part of the fast-growing agent-skills ecosystem rather than a single-vendor add-on. The same load-a-markdown-skill model powers Anthropic's Claude for Financial Services agents and the audit skill linked above: standing instructions that ride along with the agent instead of an app you context-switch into. If you are exploring how far that model goes, BuilderIO's agent-native approach is the adjacent read.

Getting Started in One Command

Most people should use the installer. It asks which skills you want, where to install them (this project or everywhere) and which agents you use, then copies the folders and writes the pointer that reloads Anti-Slop every session:

npx antislop-ai

You need Node.js 18 or newer. Two alternatives deliver the same content. The skills.sh directory route, npx skills add miqdadbadjuber/anti-slop, copies the same folders and writes no pointer, so Anti-Slop reloads by description alone. Or take a plugin door: in Claude Code, /plugin marketplace add https://github.com/miqdadbadjuber/anti-slop followed by /plugin install antislop@anti-slop. Every route (install, update, removal) is walked through per agent in the GUIDE.md.

No terminal, or want it in a chat window? The single file antislop.md is a complete filter on its own: fetch it with curl -o antislop.md https://raw.githubusercontent.com/miqdadbadjuber/anti-slop/main/antislop.md and paste it in.

Two operational notes. Skills load when a session starts, so after installing or updating, open a new session or the old rules are still the ones in force. And Anti-Slop does not update itself: npx antislop-ai --update replaces what the installer put down, while plugin installs update through each agent's own plugin command. If you installed through the installer, rerun it in each project to refresh the project pointers.

The Honest Limitation: A Filter Is Not a Style Guide

The most important sentence in the README is the caveat, quoted on its own closing banner: "antislop is a filter, not magic."

The division of labour is explicit. Anti-Slop removes what should not be there; a DESIGN.md file you write supplies the direction that fills the space. The repo's own four-way comparison shows why both halves matter. Anti-Slop alone produced honest copy on a plain, restrained layout ("Plain, because beauty is not its job"). DESIGN.md alone produced the directed look with the invented statistics still in it, because direction does not filter. Both together were the only one of the four that was clean and directed.

So the limitation is real, and disclosed: install Anti-Slop expecting it to art-direct your product and you will get clean, honest output that still looks plain, plus (R-37 again) the correct diagnosis that the direction was missing. If you have no DESIGN.md, the agent labels its work "draft without direction" instead of passing it off as finished. That single labelling rule is, for many teams, worth the install on its own.

Repo Health: 4,200 Stars in Under Two Months

The repository was created on 7 August 2026 and passed 4,200 stars with 285 forks in under two months; the latest push landed two days before this page went up. The star history shows the usual early hockey stick, which is either a community forming or a trend passing, and two months is too early to say which. The more durable signals: releases are frequent (v3.2.20 is current, adding the opt-in mode preference above), the community files (CONTRIBUTING, CODE_OF_CONDUCT, issue and PR templates) are all in place, and the documentation is unusually willing to state what the tool will not do.

Good fit if you build pages or write copy with an AI agent and keep deleting the same tics by hand, or you have a backlog of AI-generated work that needs auditing against a written standard.

Poor fit if what you actually want is taste. Anti-Slop will hand you clean output and wait for you to say what good looks like. Pair it with a DESIGN.md and it earns its keep; treat it as a designer and it will disappoint you in exactly the way its own README predicts.

FAQ

Is Anti-Slop really free?

Yes. Anti-Slop is MIT-licensed and published on GitHub with no paid tier, no feature gates and no per-seat pricing. The installer runs over npx, and every route in (installer, skills directory, plugin doors, the single file) pulls from the same open repository.

Does Anti-Slop work with Cursor?

Yes. Cursor is one of thirteen supported agents and has a plugin route: add the repository as a marketplace with the agent plugin command, then open Customize, find antislop and select Install. The full list is Claude Code, Codex, Antigravity, OpenCode, Cursor, Cline, Amp, Gemini CLI, Hermes, GitHub Copilot, Kimi Code, Pi and Oh My Pi, and the npx installer covers twelve of them and detects which ones you have.

Is Anti-Slop a style guide?

No, and it says so itself. It is a filter: it rejects generic UI patterns, filler copy and AI-shaped code, but it never prescribes colors, fonts or layouts. Design direction stays yours, ideally written down in a DESIGN.md file, which pairs with the filter rather than being replaced by it.

What is the Delivery Gate?

A mandatory pass/fail report, presented in four blocks, that the agent must run before anything ships. In During mode it closes the session. In After mode the agent produces a numbered findings list, you approve which items to fix, and a follow-up report confirms them. In a plain chat window (the single-file route) nothing enforces the gate, so treat it as best-effort there.

How do I install Anti-Slop, and how do I update it?

The recommended route is npx antislop-ai, which asks which skills to install and detects your agents; it needs Node.js 18 or newer. Alternatives are npx skills add miqdadbadjuber/anti-slop, a per-agent plugin install, or pasting the single antislop.md file into any chat. Update with npx antislop-ai --update, and start a new agent session afterwards, because skills only load at session start.

Originally published on DevPik.

Logo Design Skill: AI Logo Designer for Claude

Muhammad Tayyab — Thu, 15 Oct 2026 09:43:10 +0000

Logo Design Skill is a free, MIT-licensed agent skill that turns Claude or any Agent Skills agent into a logo designer: a brief-to-checkpoint workflow, 1,400+ visually classified reference logos, dependency-free Python audit and export tools, and production-ready SVG output.

What Logo Design Skill Actually Is

Ask an AI agent for a logo and you usually get clip art with your company name under it: a swoosh, a lightbulb, a hexagon that means nothing. Logo Design Skill exists to stop that.

It is a free, MIT-licensed skill that turns Claude, or any agent that supports the open Agent Skills format (Gemini CLI, Codex CLI, Cursor, GitHub Copilot and more), into a disciplined identity designer that works from the first brief to production-ready SVG files and brand guidelines. The repository was created on 26 September 2026 and passed 1,400 stars within its first week on GitHub.

Nothing here runs as an app. The skill ships as a SKILL.md file, a shelf of reference documents and dependency-free Python tools that your agent loads as standing instructions. A note on the GitHub language label, which says HTML: the substance is markdown and Python, and the HTML label comes from the local gallery page that browses the reference library. Clone this expecting a web project and you will find a design school for your agent instead.

The Problem: AI Logos All Look the Same

Every category has its clichés, and AI agents reach for them first. Food delivery gets a fork, a chef hat or a scooter. Security gets a padlock or a shield. Health gets a cross or a heartbeat line. The README's briefs read like a banned-symbols list on purpose: Kiln, a specialty coffee roaster, is told "not rustic cliché"; Keyfort, a password manager, gets "no padlocks, shields, keyholes, fingerprints or chain links"; Mediora, a telehealth app, gets "no crosses, stethoscopes, hearts or pulse lines".

The skill's first move is research: it searches its 1,400-logo reference library to map what the category already looks like, so the concepts it builds can avoid both the clichés and accidental look-alikes. That step alone separates it from a prompt that says "design a modern logo" and hopes.

The second move is craft that most people never see. Logo work lives in details like optical corrections (overshoot, the bone effect, irradiation), geometric construction and snapping diagonals to exact angles. The skill's audit caught a 60.8° diagonal in an early concept and an off-centre symbol before anything was shown to the client. Our Color Converter is the tool you will reach for when the skill hands you a brand palette and you need it in hex, RGB and HSL without thinking.

How It Works: From Brief to Checkpoint

The skill runs a fixed pipeline, and each stage has a job.

Brief: the agent starts from your stated assumptions or runs a discovery question bank: word mapping, choosing the right mark type (wordmark, letterform, pictorial, abstract, emblem, mascot and the rest), and a decision guide for which fits.
Research: it queries the reference library for the category, studying construction and conventions, and checking that its ideas do not echo an existing mark.
Concepts: 8 to 12 one-line ideas, of which 3 get built in SVG.
Test and refine: every concept goes through svg_audit.py and a test sheet before you ever see it: 96 and 32 px side by side, one-colour and reversed versions, then a size ladder down to 16 px, plus backgrounds, treatments, contexts and a competitor shelf test.

The reference documents cover the full discipline on demand: the twelve principles, mark types, visual techniques (geometry, grids, balance, optical corrections, negative space), colour, typography, the design process, SVG construction, a testing checklist, presentation and delivery, identity systems, redesigns and critique. The agent loads what the task needs and nothing else, which keeps the context lean.

The Checkpoint Is the Whole Point

The skill always stops at the checkpoint. It shows the concepts as one overview image with a recommendation and offers the full kit. Nothing else is produced until you choose a direction, because the kit (colour, lockups, presentation board, icons, guidelines) is most of the work and only makes sense for an approved idea.

This is the design decision that makes the whole thing work. An agent left to run end to end will polish the wrong idea beautifully. Forcing a human decision at the concept stage is what keeps the labour pointed at the right target.

The 28 example brands prove the checkpoint earns its place. In four of them the client picked a different concept than the one the skill recommended, and the skill refined that choice before colouring it: Tinkertrail's client took the letterform over the recommended snail because it reads at 16 px; Hearsay's client took the pull-up chair over the recommended ear. That is exactly what the checkpoint is for. A recommendation you cannot overrule is not a recommendation.

A 1,400-Logo Reference Library, Visually Classified

The library is the skill's unfair advantage. More than 1,400 SVG files covering roughly 1,200 brands, each visually classified by mark type, technique, geometry, subject, typography, mood and industry. The breakdown reads like a design textbook's table of contents: abstract 24%, combination 21%, pictorial 20%, letterform 15%, wordmark 10%, emblem 4%, mascot 4%, lettermark 3%. Median 2 colours, three quarters of the library uses 3 or fewer, gradients appear in 19%, and 141 files are flagged as exemplary teaching examples.

It is searchable from the command line (python3 scripts/search_library.py --technique negative-space --exemplary, or --industry payments-fintech --summary) and browsable in a local gallery page. The stated purpose is study: learn construction, map category conventions, avoid look-alikes. Never to copy. The library guide says it plainly, and the TRADEMARKS.md file draws the legal line (more on that in the limitations section).

For comparison of scale in this ecosystem, Anti-Slop ships a rulebook where this ships a school. Both are agent skills; one filters output, the other teaches craft.

The Tools: Audits, Test Sheets, Boards, Icon Export

Everything is plain Python with no dependencies beyond the standard library (Python 3.8+), so the tools run anywhere your agent runs.

svg_audit.py turns craft rules into checks: viewBox and aspect, colour count, anchor points against library medians, near-miss angles, tiny details under 1/48 of the canvas, centring. It ends with a production-readiness score out of 100. The README's own example scores a recommended lockup at 99 and a rejected emblem at 76, with the warnings spelled out.
preview_sheet.py builds an HTML test sheet: sizes, backgrounds, treatments, contexts and the competitor shelf test.
concept_sheet.py renders the one-image concept overview the checkpoint shows you.
presentation_board.py builds client presentation boards with six industry-specific mockups per concept.
render_png.py and export_variants.py take the final SVG to transparent PNGs at exact sizes, a favicon.ico, black/white/mono/square variants and the complete favicon, app-icon and web-manifest set.

PNG and ICO export uses whatever renderer is available: cairosvg, rsvg-convert, Inkscape, a Chromium-based browser or macOS Quick Look. If you hand-edit the exported SVG afterwards, running it through an HTML minifier keeps the file lean, and embedding it as a data URI is a one-liner with Base64 encode.

28 Example Brands, Run End to End

Twenty-eight fictional briefs, from quiet luxury and neon festivals to B2B SaaS, fintech and health, each run end to end with the skill. For every brand you see exactly what the skill shows at the checkpoint (greyscale concepts at true 64, 32 and 16 px sizes plus a recommendation), followed by a colour preview of the chosen direction on mockups picked for that industry.

A few of the strongest: Kiln, a specialty coffee roaster, where the recommended mark is a K whose leg is the kiln's arched firing mouth, with the arch returning as the n of the wordmark. Zestly, a food delivery app, where a citrus wedge flips into a cheeky grinning face, and the skill flags its own honest risk: some people read the wedge as watermelon. Maison Orvelle, a luxury fashion atelier, where a Didone M holds an O like a pendant at a V-neckline, and the craft pass killed an M-in-a-circle for sitting too close to a famous transit sign. Keyfort, a password manager, where one unbroken wall winds inward into a Greek key that is also a fortress with only one way in.

The later batches deliberately push vivid, saturated palettes while still passing the one-colour and 3:1 contrast checks, which is the hard combination. Colour that only survives at full saturation is decoration; colour that survives one-colour is identity.

Getting Started in One Command

Claude Code users get the recommended route, a plugin marketplace install:

/plugin marketplace add kaankiziltug/logo-design-skill
/plugin install logo-design@logo-design-skill

Manual install is a copy: git clone https://github.com/kaankiziltug/logo-design-skill.git then cp -r logo-design-skill/skills/logo-design ~/.claude/skills/logo-design for personal use (or .claude/skills/logo-design per project). Claude.ai and Claude Desktop users download logo-design.zip from the Releases page and upload it under Settings, Capabilities, Skills; if the upload has a size limit, logo-design-lite.zip carries everything except the SVG files themselves.

Gemini CLI, Codex CLI and other agents use the open Agent Skills format, so it is the same drill: clone once, copy the folder into your agent's skills directory (~/.gemini/skills/logo-design, ~/.codex/skills/logo-design, and so on), start a new session and ask.

Then just ask, in plain language:

"Design a logo for **Harbor, a savings app for first-time savers. It should feel calm and safe."
"Here's our current logo (logo.svg), critique it and suggest a refresh."
"Give me three wordmark directions for a specialty coffee roaster called Kiln."
"Turn this symbol into favicon, app icon and one-colour versions, plus a one-page usage guide."

Two operational notes. The skill works best with a model that can view images, because it renders its own drafts to PNG and checks them before showing you anything. And like all skills, it loads at session start, so open a new session after installing.

The Honest Limitation: Trademarks Are Not MIT, and It Needs Eyes

Two caveats, both stated in the repository itself.

First, the license split. The skill text, scripts, templates and catalog data are MIT. The 1,400 SVG logo files in assets/library/svg/ are trademarks of their respective owners, included for reference and education only, and are not covered by the MIT license. Study them, learn from them, do not ship them. The skill is built to prevent copying, but the legal responsibility for what you publish stays yours.

Second, vision matters. The skill renders its own drafts to PNG and checks them before showing you anything, which is how it catches things like a letterform that reads as a different letter at 16 px. That loop only closes with a model that can view images. Run it on a text-only model and you still get the SVGs and the written reasoning, but you lose the self-review pass, and the self-review is where half the craft lives.

The broader limitation is the honest one for any design tool: it executes a process with unusual discipline, but the brief is still yours to write well. A vague brief gets you disciplined clichés.

Repo Health: 1,400 Stars in a Week

The repository was created on 26 September 2026 and passed 1,400 stars with 79 forks in under a week; the latest push landed on 30 September, two days before this page went up. It carries a badge for #14 on The New 100 agent leaderboard, and the test suite runs on every push via GitHub Actions.

The growth curve is the usual early hockey stick, which is either a community forming or a trend passing, and a week is too early to say which. The durable signals: the documentation is enormous and specific (the README alone runs close to 500 lines), the tools are dependency-free and tested, the 28 worked examples show the process rather than describing it, and the project is unusually willing to state what it will not do.

Good fit if you need a real logo for a side project, startup or open-source tool and want actual craft (geometry, optical corrections, testing at 16 px) instead of clip art with your name under it.

Poor fit if what you need is a human designer's taste, negotiation and accountability, or you were hoping to lift marks out of the reference library. It is built to stop exactly that.

FAQ

Is Logo Design Skill really free?

Yes. The skill text, scripts, templates and catalog data are MIT-licensed with no paid tier. The 1,400 reference SVG logo files are trademarks of their respective owners and are included for reference and education only, not covered by the MIT license.

Which AI agents does it work with?

Any agent that supports the open Agent Skills format: Claude Code (the plugin marketplace route is recommended), Claude.ai and Claude Desktop, Gemini CLI, Codex CLI, Cursor, GitHub Copilot and OpenCode. The instructions are plain Markdown and the tools are plain Python with no dependencies.

Do I need design experience to use it?

No. The skill runs the full process itself: discovery questions, word mapping, category research, concepting and testing, then stops at a checkpoint with a recommendation. You pick a direction and ask for the kit. A good brief helps, but the skill will interrogate you for one.

How do I install it in Claude Code?

Run /plugin marketplace add kaankiziltug/logo-design-skill, then /plugin install logo-design@logo-design-skill. Or manually: git clone the repository and copy skills/logo-design into ~/.claude/skills/. Start a new session afterwards, because skills only load at session start.

Can it critique my existing logo?

Yes. The skill triggers on critique requests, and its svg_audit.py tool scores any SVG against logo principles: anchor-point complexity, colour count, near-miss angles, tiny details and centring, ending with a production-readiness score out of 100.

Why does it need a model that can view images?

Because it renders its own drafts to PNG and checks them before showing you anything. That self-review loop is how it catches problems like a letterform that reads as a different letter at 16 px. On a text-only model you still get the SVG and the written reasoning, but you lose the review pass.

Originally published on DevPik.

Caveman Claude Code Skill: What It Really Saves

Muhammad Tayyab — Thu, 15 Oct 2026 09:41:02 +0000

Caveman started as a joke prompt that made Claude grunt. 111,000 stars later, the repo's own Honest Numbers page says the voice saves about 3% over "Answer concisely", and version 4.0 rebuilt the project around the tokens your agent reads instead.

What This Actually Is

Caveman began in April 2026 as a joke: a prompt that told a coding agent to answer like a caveman. Short fragments, no greeting, no recap. It reached number one on Hacker News with 904 points, ThePrimeagen's verdict on video was "No way this actually works", and the repository has since passed 111,000 stars and 6,400 forks.

The joke kept its voice and outgrew its premise. Version 4.0.0, released on 13 October 2026, reorganises the project into six parts the README calls "rocks", and only one of them is the caveman voice. The rest are a local proxy that compresses what your agent reads, a router that picks the model and reasoning effort per request, a library of reusable scripts, and smaller tools for finding where tokens go.

That explains the GitHub language label, which says Go. Most of the code is now the compression engine and proxy behind those input-side rocks, with JavaScript and TypeScript for the CLI and installers and Python for the evaluation harness. The skill that made it famous is still a markdown file.

The whole repository is Apache-2.0. "Caveman" and the rock logo are trademarks of the author, Julius Brussee.

The most interesting file in the repo is not the skill. It is a page titled Honest Numbers, which measures the project's most famous claim and publishes the result even where it is unflattering. This article follows that thread, because it is the clearest guide to which parts of Caveman are worth installing.

Six Rocks in 4.0, and Only One of Them Is the Voice

The full install is one command:

npx @caveman-ai/cli@latest

It finds the agents and logins on your machine, shows what it is about to change, and waits for you to press Enter. It needs Node.js 22.13 or newer. Afterwards, plain claude runs through Caveman, as do Codex, Gemini CLI, OpenCode and, per the install matrix, more than 30 other agents. It runs locally, with your own API keys or your Claude Pro or Max login.

Rock	What it does	What the README measured
Say less	The caveman voice: shorter replies, code untouched	63 → 20 tokens on one example
Read less	Shrinks logs, JSON, CSV, YAML and test output before the model reads them	33.2% fewer input tokens per session
Auto	Picks the model and the effort for each request	54% cheaper than Opus 5.5 at xhigh, interim
Blocks	Keeps the scripts the agent writes and hands them back	397 → 76 tokens for one test run
Waste fixes	Finds where your tokens go, keeps the prompt cache warm while you pause	Not measured yet
Browse	Returns web pages to the agent compressed	121 tokens instead of 15,704 on a 200-row table

All six are on after install. Each has its own switch, caveman off browse for example, and caveman status shows what is running. Only Auto needs an account, and the account is free.

If you only want the voice, the skill installs on its own, with no proxy and no CLI:

npx skills add JuliusBrussee/caveman -g

Type /caveman ($caveman in Codex) if it does not start by itself, and say "stop caveman" to go back. Claude Code also has a plugin marketplace package, and Gemini CLI an extension.

How Caveman Mode Turns 63 Tokens Into 20

This is the example the project is famous for. A normal agent explains a React re-render like this:

The reason your React component is re-rendering is likely because you're creating a new object reference on each render cycle. When you pass an inline object as a prop, React's shallow comparison sees it as a different object every time, which triggers a re-render. I'd recommend using useMemo to memoize the object.

Caveman mode says:

New object ref each render, so React re-renders. Wrap the prop in useMemo.

Same fix, 63 tokens down to 20. The README insists this is "a voice, not broken grammar", and the rules underneath are more careful than the meme suggests:

Answer first. [thing] [action] [reason]. [next step]. No greeting, no "let me", no recap.
One idea per sentence. The rules borrow from ASD-STE100, the Simplified Technical English written for aircraft maintenance manuals: 20 words at most, active voice, one term per thing.
Meaning is never dropped. Articles can go. Not, never, no and only never go, and numbers and units stay exact.
Payload stays verbatim. Code, commands, paths and error messages are left character for character.
No theatre. No "me think", no chatter between tool calls, and if caveman phrasing is not actually shorter, plain English wins.
It knows when to stop. Security warnings, irreversible actions and confused users get full sentences, then the grunting resumes.
Your prompts stay yours. Caveman never rewrites what you type.

The negation rule is the one that makes terse output safe. Compress "do not run this against production" carelessly and you get "run against production". The rules protect those words explicitly.

There are three intensities. /caveman gives the 20-token answer above, /ultracave drops to 14 ("Inline object prop, new ref, re-render. useMemo."), and /megacave answers in Classical Chinese for 13 tokens, which is the most compressed and least readable of the three.

Against "Answer Concisely", the Caveman Skill Saves 3%

Here is the table the repo publishes for ten developer questions on claude-opus-5-5:

Instruction	Output tokens
None	6,983
`Answer concisely.`	4,334
`/caveman`	4,119
`/ultracave`	2,693

Read the first two rows before the last two. A plain two-word instruction takes the total from 6,983 to 4,334, about 38%, and the repo itself calls "be concise" the real baseline because current models already know how to do it. On top of that baseline, /caveman cuts 3% more at the median. /ultracave cuts 35% more, which is the variant that measurably goes further, at a real cost in readability.

The caveats are printed next to the numbers: ten questions, a single run, output length only, measured on the 3.1.0 rules and not yet re-run since. The rules themselves cost about 1,160 tokens of input.

The GitHub tagline still says the project "cuts 65% of tokens". The Honest Numbers page notes that earlier releases of the stats command applied a fixed 65% output ratio with no committed, reviewed result behind it. Current reports ignore those historical estimates, and the statusline no longer displays a savings figure at all.

It is unusual for a project at this scale to walk back its own headline number in its own documentation. It is also the most useful thing in the repo, because it tells you exactly where not to expect savings.

Output Is 0.3% of an Agent Session's Tokens

The deeper reason the voice matters less than it looks comes from the outside A/B tests the repo collects:

One contributor analysed 662 real Claude Code sessions and found output was 0.3% of all tokens. Caveman's net effect on the bill was within ±0.2%.
LemonCrow ran 300 runs per arm on claude-opus-4-8. Billed output fell 44.1%, yet total cost rose 0.06%. The rules added 1,532 tokens of cached context to every run.
JetBrains ran 86 real coding tasks as a paired A/B: 8.5% fewer output tokens, with no measurable quality loss (p = 0.82).

Think about what a coding agent sends on each turn: the system prompt, the tool definitions, the conversation so far, every file it read and every tool result it got back. The reply is a sliver at the end of all that. Halving the sliver halves almost nothing. The repo's own summary is that output shrinks, but an agent run's bill is mostly input and cache re-reads, which an output-style rule cannot touch.

The voice does win where the reply is the bulk of the work. Adobe Research's CAVEWOMAN paper, which cites the repo, measured caveman-style output cutting cost 1.4 to 2.4 times per model across eight models and five datasets, and Elastic's remake for Elasticsearch MCP scenarios measured 63.6% fewer response tokens. Those are chat-shaped workloads.

Adobe also found the effect reverses on the other side of the conversation. Cavemanning your prompt makes answers worse, which is why Caveman never touches what you type.

The repo lists the cases where it loses outright:

Terse coding Q&A. The fixed rule overhead can exceed any output saving, and one user measured a net loss.
Per-request billing. GitHub Copilot charges premium requests, so a shorter answer is the same request and saves nothing. The same applies to any per-message pricing.
Tool-side accounting. One Cursor A/B showed 4.3 million tokens with Caveman against 1 million without, at twice the wall-clock time. It was not reproducible, but the repo keeps it listed, because rule re-injection, retries and cache accounting can swamp output savings.

What is still missing is a published quality claim. A fidelity eval exists, with fixed cases and regex checks that numbers, negations and safety wording survived compression, but no reviewed snapshot is committed. If you run your own A/B, borrow the idea: a few patterns asserting that a "not" or a version number made it through, drafted against real replies in a regex tester, catch the failure a token count never will.

Read Less: 33.2% Fewer Input Tokens, and HTML Got Worse

If output is the sliver, input is the bill, and 4.0 puts its weight there. The proxy compresses tool output before the model sees it. The README's benchmark ran Claude Code on six large files, each hiding one record the agent had to find:

Shape	The file through Caveman	Whole session, 3 runs	Session saved
CSV	28,041 → 314	165,823 → 74,484	55.1%
Logs	22,810 → 348	148,807 → 74,068	50.2%
YAML	20,447 → 178	132,124 → 71,027	46.2%
Test output	18,806 → 203	150,377 → 108,514	27.8%
JSON	18,837 → 281	147,975 → 108,939	26.4%
HTML	21,670 → 21,670	140,687 → 154,641	9.9% worse
All six	130,611 → 22,994	885,793 → 591,673	33.2%

Caveman got 18 of 18 answers right. Headroom, another compression wrapper run on the same suite, got 15 of 18 at 6.7% fewer tokens.

The gap between the file column and the session column is the lesson in miniature. A supported file shrinks by about 98%, but every request still carries the system prompt, tool definitions, conversation and the Caveman skill itself, so the session moves by a third. HTML went backwards because there is no HTML compressor yet, while the skill overhead was still counted. The repo kept that red row rather than dropping it.

The compression is lossy and query-aware: the engine keeps what looks relevant to the question. Every original stays on your disk, and the agent can pull it back from a local recovery store when the compressed view is missing something. Those recovery calls were counted in the benchmark.

Read the limits before you quote 33.2%. The fixtures are deterministic 60 to 95 KB files, each burying one record in noise, which is the ideal case for a needle-finding compressor. The session run dates from August 2026 on an older engine. And the raw harness artefacts are not in the public repo, so the result cannot be reproduced from a checkout, and the repo says to treat it as a pinned report.

You can get a lossless slice of this by hand, so we measured how big. Using the same o200k tokeniser Caveman reports in, we encoded two payloads three ways:

Payload	Pretty JSON (indent 2)	YAML	Minified JSON
50 customer records	3,994	3,072	2,490
20-service deployment config	4,038	2,788	2,310

Minifying cut 38% and 43%. The common advice to convert JSON to YAML before pasting it into a prompt beats indented JSON, but it lost to minified JSON on both shapes, because YAML keeps every key name and spends tokens on indentation instead of braces. If you paste structured data into an agent by hand, a JSON minifier is the cheapest lossless win available. Reach for a JSON to YAML converter when a human has to read the prompt, not when the bill is the point.

Auto Saves 54%, Mostly by Turning Effort Down

Auto adds a model to your agent's picker. Choose it, and Caveman picks the model and reasoning effort for each request: a big model for a hard ask, a cheaper setting for an easy one.

Setup	Tasks solved	Cost per try	Median time
Opus 5.5, xhigh effort, every request	44.3%	$7.83	35.2 min
Auto, Claude models only	43.7%	$3.59	15.9 min
Auto, plus OpenAI and open models	42.9%	$3.47	16.7 min

That is 85 real coding tasks from SWE-Interact and SWE-Together, one attempt each, at 0.46 times the cost and under half the time.

The benchmark document is more revealing than the headline, because it shows what Auto actually did. On the Claude-only pool it sent 87% of requests to Opus 5.5 at medium effort, 8% to Opus at high, and 5% to Sonnet 5.5. The saving comes mostly from lower effort, not from switching to a cheaper model, and the document says so itself: against an agent already running Opus at medium effort, expect much less, and that case has not been measured.

The other caveats are stated just as plainly. The run is interim, 85 of 169 tasks. The quality interval is about ±7 points, so the arms cannot be told apart, and on SWE-Interact alone Auto is 6 points behind. Costs are list prices from the router's catalogue, not billed amounts, and the raw trajectories are not in the repo.

The practical reading: if you run xhigh effort by habit, the first cheap experiment is lowering effort yourself. Auto is the version of that experiment that decides per request.

caveman login                  # free account; Auto appears in the model picker
caveman providers add openai   # optional: more models, on your own key

It works in Claude Code, OpenCode and Codex. Any other model you pick runs exactly as picked, and without signing in there is no Auto and nothing is sent.

Blocks Stop the Agent Writing the Same Script 394 Times

Code mode is the pattern of an agent writing a small script instead of making tool call after tool call, an approach both Cloudflare and Anthropic have written up. Its weakness is that the agent writes the same script every session and throws it away. On one machine, in one week, agents wrote the same script 394 times, and a Purdue study measured the habit at up to 9.57% of task cost.

Blocks keeps those scripts in your repository, checks them on every pull request, and hands them back. Eight ship with Caveman: json-peek, jsonl-stats, test-summary, first-error, wait-for, grep-defs, http-json and replace-in-file. When the agent starts typing a script a block already covers, it gets a one-line hint to use the block. It never denies or rewrites a command.

Input	Raw tokens	What agents type now	With a block
`go test -v ./...`, 326 tests	10,561	397, piped through `tail -20`	76, `test-summary`
1.4 MB JSON file	251,893	236, their own heredoc	227, `json-peek`
366-line Go file	3,111	250, `grep -n`	489, `grep-defs`

The third row is a loss: the block reads back more than a bare grep, and the row stays in the README anyway. That consistency, publishing the rows that lose, runs through the whole project.

caveman-blocks scan shows what your agents retyped this month without the script text leaving your machine, and caveman-blocks init writes the rules and the block index into your repo's AGENTS.md. Blocks is a pre-release (v0.1.0-rc.5), Python only, with no sandbox yet.

Compress, Browse, Learn: The Smaller Rocks

The rest of the toolkit is a set of narrower tools, most with their own numbers:

/caveman-compress <file> shrinks memory files such as CLAUDE.md and keeps a backup. Across five test files it took 6,198 tokens down to 4,138, between 22.8% and 49.1% per file, with every heading, code block and path intact. Since a memory file is sent with every request, this saving compounds in a way a shorter reply does not.
caveman browse <url> hands the agent a compressed web page: 121 tokens instead of 15,704 for a Playwright snapshot of a 200-row table. Tiny forms come out 2.3 times worse, and the README says so.
Warm cache keeps Anthropic's prompt cache warm while you step away, but only when your own history says you usually come back in time, so the next request does not pay full price. Every warm is listed in caveman stats. Not measured yet.
caveman learn ranks where your tokens go using agent history already on disk, and caveman learn implement applies fixes one diff at a time, only when you say yes.
Middleware brings the same compression to Vercel AI SDK, LangChain, OpenAI and Anthropic SDK calls in your own code.

Inside the agent there are a few commands worth knowing. /caveman-commit writes a one-line Conventional Commit. /caveman-review returns one finding per line, in the form L42: 🔴 null deref. Guard it. cavecrew runs subagents that find, edit and review code and report back in caveman.

The most useful command, given everything above, is caveman trial -- claude, which A/B tests a real session on your own work. Every number on this page is someone else's workload. That one is yours.

What Caveman Sends Home

The privacy section is specific, and it differs sharply by component:

The skill runs on your machine and sends nothing. The exception is /caveman-compress, which sends the file you compress to your configured model provider.
The CLI sends usage stats by default: commands run, token counts, Blocks usage counts, a random install ID, your OS and your IP address. Never your prompts, code, file paths or scripts. caveman telemetry off or DO_NOT_TRACK=1 turns it off for good.
Auto, once you sign in and pick it, sends Caveman Cloud your latest ask with whatever the agent attaches to it, such as CLAUDE.md, memory or @-mentioned files, plus the ask before it, the end of the agent's last reply, tool names, effort and token counts. On the free plan, Caveman may keep that data to improve routing. caveman off routing stops it.
Requests routed to a Caveman Cloud model pass through Caveman Cloud whole: system prompt, tool results and code. caveman providers cloud off stops that.

Two things follow. Telemetry that includes your IP address is on by default in the CLI, which is worth knowing before you install it on a work machine. And Auto, the rock with the biggest headline saving, is also the one that sends your context off the machine.

The commercial side of the project is Caveman Cloud, aimed at teams building their own agents rather than using one: run tracing, evals on real traffic, and an "autopilot" that proposes cheaper changes, tests them on recorded work, and ships only when the evals hold, with you approving the pull request. The open-source CLI and skill do not require it.

Worth Installing?

It depends on which rock you came for, and the repo's own numbers make the answer unusually clear.

For the voice alone, install just the skill, but first add "Answer concisely." to your CLAUDE.md and compare. The repo's own table says that gets you most of the way, and /caveman adds about 3% on top. If you want a real further cut, /ultracave is the variant with the 35% number behind it.

If your sessions read big logs, CSVs or test output, the Read less proxy is the rock with the strongest evidence: 33.2% fewer input tokens at held accuracy on its benchmark, with the limits stated above.

If you run Opus at xhigh effort by default, Auto's saving is mostly an effort saving. Try lowering effort yourself, or let Auto decide per request, knowing it sends context to Caveman Cloud.

If you pay per request, as with GitHub Copilot, skip the voice. A shorter answer is the same request.

Whichever you pick, measure it. Run caveman trial, or compare provider-billed totals on the same task with and without Caveman, and turn it off for any workload where the bill goes up. That instruction comes from the repo itself.

Caveman became famous as a joke about grunting. What makes it worth trusting is the page that measured the grunting and reported, plainly, that it was not where the money was.

FAQ

What is Caveman for Claude Code?

Caveman is an open-source skill and local proxy for AI coding agents, created by Julius Brussee. The skill makes the agent answer in short, caveman-style sentences while leaving code, commands and error messages exact. Since version 4.0 it also compresses tool output before the model reads it, routes requests between models and effort levels, and reuses scripts the agent writes. It works with Claude Code, Codex, Gemini CLI, OpenCode and more than 30 other agents, and is licensed Apache-2.0.

Does the caveman skill actually save tokens?

It shortens replies, but by less than the viral claim. On the repo's own test of ten developer questions, a plain "Answer concisely." instruction cut output from 6,983 to 4,334 tokens, and /caveman cut 3% more at the median, while /ultracave cut 35% more. Because output is a small share of an agent session (one analysis of 662 Claude Code sessions put it at 0.3% of all tokens), the larger savings in Caveman 4.0 come from compressing input, where the README reports 33.2% fewer input tokens on its benchmark.

How do I install Caveman?

Run npx @caveman-ai/cli@latest for the full toolkit. It detects your agents and logins, shows what it will change, and needs Node.js 22.13 or newer. If you only want the caveman voice, run npx skills add JuliusBrussee/caveman -g instead, then type /caveman (or $caveman in Codex) if it does not start automatically. Say "stop caveman" to switch it off.

Does caveman mode make Claude's answers worse?

Published outside tests have not found a measurable quality drop: JetBrains ran 86 coding tasks as a paired A/B and found no measurable quality loss (p = 0.82), and Elastic reported zero information loss in its remake. The rules keep negations, numbers, code and error messages exact, and switch back to full sentences for security warnings and irreversible actions. Caveman never rewrites your prompt, because Adobe Research found that compressing the prompt itself makes answers worse. The repo has not yet published its own reviewed quality snapshot.

Does Caveman help with GitHub Copilot or Cursor?

Caveman installs into Copilot, Cursor and many other agents, but the savings depend on billing. GitHub Copilot charges per premium request, so a shorter reply is the same request and the voice saves nothing there. The repo also records one Cursor A/B where token use rose from 1 million to 4.3 million with Caveman, which it could not reproduce but keeps listed as a warning. Its advice is to compare provider-billed totals with and without Caveman and turn it off where cost goes up.

What data does Caveman send?

The skill sends nothing, except /caveman-compress, which sends the file you compress to your own model provider. The CLI sends usage stats by default, including commands run, token counts, a random install ID, OS and IP address, but never prompts, code or file paths; caveman telemetry off or DO_NOT_TRACK=1 disables it. Auto, once you sign in and select it, sends your latest ask and attached context to Caveman Cloud, which may keep it on the free plan; caveman off routing stops that.

Originally published on DevPik.

Diagram Design: A Claude Code Skill for Editorial Diagrams

Muhammad Tayyab — Thu, 15 Oct 2026 09:38:30 +0000

The model already understood your architecture. What it was missing was taste. Diagram Design writes the taste down as a loadable reference, and the result is diagrams that do not look generated.

What This Actually Is

Diagram Design is an Agent Skill. You install it into Claude Code, Codex, Cursor, GitHub Copilot, Factory Droid, Gemini CLI, Cline, Windsurf or Amp, then ask for a diagram in plain English, and the agent writes one .html file you open by double-clicking.

It crossed 53,000 stars, with 3,384 forks, in under six months. The repository was created in April 2026 and it is MIT licensed.

The GitHub language label says HTML, which is accurate and slightly misleading. There is no application here. What ships is a set of markdown reference files, a handful of Python extraction scripts, and a library of example HTML files. The whole thing is instructions for a model, plus the gates that check the model obeyed them.

That makes it a useful thing to study even if you never install it, because it is one of the clearest worked examples of the question every skill author eventually hits: how do you encode judgement, rather than just capability, in a file an agent reads?

The Model Had The Content, It Was Missing The Taste

The author, Cathryn Lavery, explains the origin in one paragraph that is worth quoting because it names the problem precisely:

I wanted diagrams I actually liked for my blog posts. Every time I needed one, whether an architecture sketch, a flowchart, or a pyramid of what matters most, I'd ask Claude and get back a generic rounded-box thing that looked nothing like the rest of the site. I'd either fight with Figma for 30 minutes or skip the diagram.

Then the key line: the model already understood the content. What it was missing was taste, so I wrote the taste down.

This is the part most people get wrong when they write skills. The instinct is to describe the capability, "you can draw diagrams", when the model could already do that. The gap was never capability. The gap is that a model with no constraints produces the statistical average of every diagram it has ever seen, and the statistical average of all diagrams is a grey rounded box with a drop shadow.

So the skill does not teach drawing. It removes options. One accent colour, reserved for the one or two things the reader should look at first. 1px hairline borders. No shadows at all. Maximum border radius of 10px. Target information density of 4 out of 10, with an explicit instruction that the highest-quality move is usually deletion.

Constraint, not instruction, is what produces the house style.

The 4px Grid Is The Anti-Slop Rule

One rule in the design system is marked non-negotiable, and the README says exactly why:

Every coordinate, width, and gap is divisible by 4. That rule is non-negotiable; it's what keeps the diagrams from feeling AI-generated.

That is a sharper diagnosis than it first appears. When you look at a generated diagram and something feels off without being able to say what, you are usually reacting to near-misses: a node at x=247 next to one at x=250, a 13px gap beside an 11px gap. No single value is wrong. The accumulated irregularity is what reads as careless.

A human designer gets alignment for free because their tool snaps to a grid. A model emitting SVG coordinates as text has no snapping, so the grid has to become a stated rule it can check its own output against.

The type ramp works the same way, and it is tied to output size rather than fixed. A diagram built for a projected slide gets 16px node names where a doc-inline diagram gets 12px. If you are translating those sizes into a stylesheet of your own, an em to px converter saves the arithmetic, since the diagrams specify px while most design systems reason in em or rem.

Three font families carry the whole system: Instrument Serif for titles and italic callouts, Geist for node names, Geist Mono for technical sublabels. The monospace rule is specific and good: mono is for genuinely technical content such as ports, URLs and field types, not as a blanket "developer" aesthetic.

45 Types, And The Agent Reads Exactly One

The skill covers 45 diagram types, each shipping in three static variants: minimal light, minimal dark, and full editorial.

The list runs well past the usual suspects. Alongside architecture, flowchart, sequence, state machine, ER, timeline, swimlane, quadrant and Gantt, there are types most diagram tools never offer: Wardley maps, service blueprints, fishbone cause analysis, medallion data tiers, story maps, waterfall bridges, polar charts, and exploded axonometric projections that pull a phone or a keyboard apart along one axis.

The interesting engineering is not the count, it is what the count costs. Forty-five type references, plus semantic patterns, animation contracts, primitives and import grammars, is far more than you want in an agent's context on every request.

The answer is progressive disclosure. At startup the agent sees only the skill's name and description. A matching request loads SKILL.md. Only then does it pull the one reference it needs:

You ask for	Agent loads
"Make me a flowchart"	`SKILL.md` + `type-flowchart.md`
"Build an architecture diagram"	`SKILL.md` + `type-architecture.md`
"Draw our office floor plan"	`SKILL.md` + `type-axonometric-plan.md`
"Animate that policy trace"	Prior selection + `animation.md`
"Redraw this .drawio for my deck"	`SKILL.md` + `import-drawio.md` + `output-spec.md` + the chosen type

The README states the property this buys in one line: no matter how many types exist, the agent only reads the one you need, so adding a type tomorrow changes nothing else.

That is the architectural lesson worth stealing. A skill's context cost should scale with the request, not with the size of the skill.

Onboarding Reads Your Brand Off Your Own Website

Out of the box, diagrams render in jet black and tangerine on white smoke. The README is honest that this is "good enough to screenshot straight away" and that sixty seconds of onboarding is better.

The onboarding flow is a single sentence to your agent:

"onboard diagram-design to https://yoursite.com"

The agent fetches your homepage, extracts the dominant palette and font stack, and maps what it found onto semantic roles rather than raw hex values:

Detected on your site	Becomes
`<body>` background	`paper`
Primary text colour	`ink`
Secondary or caption text	`muted`
Cards and containers	`paper-2`
Most-used brand colour (CTA, link, heading)	`accent`
`<h1>` font family	`title` font
`<body>` font family	`node-name` font
`<code>` / `<pre>` font	`sublabel` font

Two details raise this above a colour-picker script.

First, contrast is checked before tokens are written. The skill verifies WCAG AA contrast of ink on paper at the sizes diagrams actually use, 9px to 12px, and if your brand colour fails there it proposes an adjusted value and explains why rather than silently shipping unreadable labels. The default skin is held to the same contract in CI: text roles clear 4.5:1 and essential marks clear 3:1 on both light and dark paper.

Second, brand matching emits a fidelity receipt: the URLs it sampled, the exact colour roles, font families and weights, font source URLs, and any fallback it had to take. Public site fonts are used directly and verified after rendering instead of being quietly swapped for a generic system stack. You get told what it could not match.

There is also a first-run gate. On the first diagram in a new project, if style-guide.md is still at defaults, the skill stops and asks whether to onboard, paste tokens manually, or proceed with the default. It will not silently ship default-skinned diagrams into a branded project.

If you juggle clients, onboard each brand once, save it as a named profile, and drop a .diagram-design marker containing profile: <slug> into each project. Parallel workspaces then use different brands without overwriting a shared install.

Redrawing Mermaid And draw.io: The Four Dials

If you already have diagrams, the skill does not convert them. It redraws them: same content, its design system, sized for wherever the output is going.

It reads .drawio, .drawio.xml, .drawio.png with an embedded diagram, and .drawio.svg, including the compressed payloads that look like base64 noise in an editor. For Mermaid it takes .mmd, .mermaid, and fenced mermaid blocks inside Markdown. For Excalidraw it takes .excalidraw scene files, parsing text only with no rendering, JavaScript, browser or network access.

A draw.io file is XML underneath, and if you want to see what the extractor sees before handing it over, running the file through an XML to JSON converter makes the node and edge structure legible in a way the raw markup does not.

The point, as the README puts it, is not conversion but fitting the output to its destination. Four dials control that:

Dial	Options	What it changes
Format	`html` · `svg` · `png` · `html+png`	The deliverable. SVG for Figma, PNG for slides, HTML for the web.
Size	`doc-inline` · `doc-wide` · `slide-16x9` · `social-og` · `print-a4-landscape` · `fit` and more	The `viewBox` and the type ramp together.
Detail	`faithful` (≤24 nodes) · `balanced` (≤12) · `simplified` (≤7)	How much survives, via a fixed degrade ladder.
Audience	`engineer` · `mixed` · `executive`	The wording, not the node count.

The detail ladder degrades in a stated order: decorations first, then duplicates, then leaf clusters, then infrastructure. You can predict what a simplified pass will drop.

The audience dial is the cleverest of the four, because it changes language while leaving structure alone. The same node reads Auth Service / JWT · RS256 · :8443 for an engineer, Auth Service / token check for a mixed room, and simply Sign-in for an executive.

Every import closes with a fidelity ledger:

Detail: balanced · 12 source nodes → 8 drawn
Collapsed: "Token valid?" decision → edge label on Gateway → Auth
Dropped:   1 sticky note ("legacy path, to be retired"), unconnected in source
Kept in full: the request path (Web/Mobile → Gateway → Orders → Postgres)

The reasoning behind that is sound: you know your own source diagram, so you would notice the omissions anyway. Being told is better than discovering it in a review.

What never carries over is also stated plainly: source coordinates, source palette, source fonts, draw.io's diagonal connector spaghetti, Mermaid's automatic layout, and Excalidraw's hand-drawn geometry. What always carries over is components, relationships, grouping and direction.

One File, No Build Step

Every diagram is a single self-contained HTML file with inline SVG. No build step, no JavaScript, no external image dependency. Double-click it and it opens.

The only network request is Google Fonts, pulling Instrument Serif, Geist and Geist Mono. Ask for system fonts, or set the font source to system in your style guide, and the file makes no network requests at all, falling back to the platform's own serif, sans and mono faces. For anything going into an air-gapped environment or a PDF pipeline, that switch matters.

Accessibility is built into the template rather than bolted on. Each inline SVG gets role="img", a resolving aria-labelledby, and first-child <title> and <desc> elements. IDs are prefixed per diagram and variant, so several exported SVGs can be inlined on one page without colliding accessible-name IDs, which is the bug that usually appears the moment you put two generated SVGs in one document. Decorative icons are hidden from assistive technology instead of being announced.

Motion is optional, off by default, and constrained. The none, reveal, step and loop modes each require a complete static first frame and deterministic timing, prefers-reduced-motion renders the full static frame with playback controls hidden, and motion files must use the exact reviewed controller. Arbitrary inline scripts, remote assets, CSS imports and executable HTML attributes are rejected.

Because the output is one HTML file, publishing it to a docs site is a copy. If you are inlining many of them, an HTML minifier trims the per-file overhead without touching the SVG geometry, which is the part you cannot afford to have rewritten.

Exporting is a slash command or a sentence. SVG export extracts the <svg> node and injects the font imports so it renders standalone in browsers, Figma and Illustrator. PNG export rasterises through Playwright at 2x by default. Both are diagram-only: the editorial cards and headers from the -full variants are not included, so for a shot of the full layout you use print-to-PDF or a full-page screenshot.

It Tells You When Not To Use It

The section that most raises confidence in the repo is the one that argues against itself. The README lists, specifically, when you should not reach for this skill:

Diagrams that live in Git and change every sprint go to Mermaid, because Mermaid diffs and GitHub renders it.
Quick unicode diagrams for a tweet or terminal output belong in a wiretext-style skill.
Lists of anything should be a table or bullets.
Before and after comparisons should be a table. If you are building those by hand, a markdown table generator is the faster path and the output diffs cleanly in review.
One-shape diagrams, a single labelled box, should just be a sentence.

Then the question it tells you to ask before drawing anything: would a reader learn more from this than from a well-written paragraph? If no, do not draw.

The comparison table is equally frank about the trade-off. Output quality depends on the model you run it with, and the same prompt can lay out differently on two runs. The result is not an editable source format: there is no text to diff in a pull request and no canvas to drag a box on. Changing it later means asking the agent again or editing the SVG by hand.

So the honest positioning, which the repo states itself, is that Mermaid is still the better fit for docs that live in Git and change constantly. Diagram Design is for the diagram you are going to publish. That is a real and narrower claim than "replaces Mermaid", and it is the claim the project actually delivers on.

The Validation Gates Are The Interesting Part

A skill that only writes instructions has no way to know whether the model followed them. This repo closes that loop with CI, and the gates are more specific than most:

lint-skin.py checks palette, fonts, accessibility and single-file safety.
lint-render.py loads the output in Chromium and inspects the rendered layout rather than the source.
verify-geometry.py checks label, connector and port geometry.
verify-docs-sync.py verifies that routing, the gallery, the README and the type counts still agree.

The render lint is the one worth noticing. Checking generated SVG by reading the markup tells you the coordinates are on the grid; it cannot tell you two labels overlap or a node clips its container at the viewBox you chose. Rendering it in a real browser and measuring catches the failures that only exist after layout. Every pull request runs these on Linux, Windows and macOS.

There is an end-user equivalent too. Running python3 skills/diagram-design/scripts/self_check.py <file> on any generated diagram prints OK when it passes, and --offline additionally fails the file if it still carries the Google Fonts link. That is a genuinely useful gate to put in your own docs pipeline.

The README also publishes an "it's working if" list, which doubles as a bug report template: a routine request should load SKILL.md, exactly one type reference and at most two core references; the agent should state its chosen type, pattern, size and planned cuts before drawing; the output should open offline; screen readers should announce the title and description. If any of those fail, it says, that is a bug worth filing.

Worth Installing?

Install it with one line, npx skills add cathrynlavery/diagram-design, or through the plugin marketplace of whichever agent you run.

It is worth your time if you publish diagrams: blog posts, docs sites, decks, README headers, anywhere the diagram is the artefact rather than a sketch in a pull request. The brand onboarding is the feature that justifies it over asking a model directly, because it is the difference between a diagram that sits on your page and one that looks pasted in from somewhere else.

It is not worth it if your diagrams live in version control and change every sprint. The repo says so itself, and Mermaid remains the right answer there.

The broader reason to read this repository, even if you never draw a diagram with it, is that it is a working answer to a question every agent skill eventually faces. Models are not short on capability. They are short on constraint. Diagram Design writes down a specific, opinionated, arguable set of constraints, then builds the CI to prove the model honoured them, and loads only the fraction of those constraints each request actually needs.

That pattern transfers to almost any skill you might write.

FAQ

What is Diagram Design?

Diagram Design is an open-source Agent Skill that lets a coding agent draw editorial diagrams as a single self-contained HTML file with inline SVG. It covers 45 diagram types, applies one opinionated design system, and can pull your brand colours and fonts off your own website so every diagram matches your site. It is MIT licensed and has over 53,000 stars.

Which AI coding agents does it work with?

Any host that reads Agent Skills. The README documents Claude Code, Codex, GitHub Copilot, Cursor, Factory Droid, Pi, Gemini CLI, Cline, Windsurf, Amp, Zed, Warp, Roo, Kilo, Kiro, OpenCode and Claude Cowork. The one-line install is npx skills add cathrynlavery/diagram-design, and Claude Code, Codex, Copilot and Factory Droid additionally have plugin marketplace packages that carry the slash commands.

Is this a replacement for Mermaid?

No, and the repository is explicit about that. Mermaid is text that diffs in a pull request and renders natively on GitHub, which makes it the better choice for diagrams that live in Git and change every sprint. Diagram Design produces a rendered HTML file with no editable source format, so it is aimed at the diagram you are going to publish. It can also redraw existing Mermaid, draw.io and Excalidraw files into its own style.

Can it redraw my existing draw.io or Excalidraw diagrams?

Yes. It reads .drawio, .drawio.xml, .drawio.png with an embedded diagram, .drawio.svg, Mermaid .mmd files and fenced mermaid blocks in Markdown, and .excalidraw scene files. It keeps components, relationships, grouping and direction, and discards source coordinates, palette, fonts and layout. Every import ends with a fidelity ledger naming what was merged, collapsed or dropped.

Do the diagrams need an internet connection?

By default each file makes exactly one network request, to Google Fonts for Instrument Serif, Geist and Geist Mono. Setting the font source to system, or simply asking for system fonts, produces a file that makes no network requests at all and falls back to the platform's own serif, sans and monospace faces. There is no build step or JavaScript in ordinary output.

How does it keep diagrams accessible?

Every template gives the inline SVG role="img", a resolving aria-labelledby, and first-child title and desc elements, with IDs prefixed per diagram so multiple SVGs can be inlined on one page without duplicate accessible-name IDs. Brand onboarding verifies WCAG AA contrast at the 9px to 12px sizes diagrams actually use before writing tokens, and proposes an adjusted value when a brand colour fails. Optional motion respects prefers-reduced-motion by showing the complete static frame.

Originally published on DevPik.

Matt Pocock Skills: Open-Source AI Agent Skills for Real Engineering

Muhammad Tayyab — Thu, 15 Oct 2026 09:36:54 +0000

Matt Pocock's skills repo is a collection of agent skills he uses every day for real engineering, not vibe coding. Built to fix the four ways coding agents fail, it gives Claude Code, Codex, GitHub Copilot and Gemini CLI composable workflows for grilling, TDD, debugging, code review and architecture, and it has 283,000+ stars.

What Matt Pocock's Skills Are: Agent Skills for Real Engineers

Matt Pocock, the educator behind Total TypeScript, open-sourced the agent skills he uses every day. The repo's pitch is blunt: "Skills for Real Engineers. Straight from my .agents directory." These are not demos or vibe-coding toys. They are small, composable workflows designed to fix the failure modes he keeps seeing in Claude Code, Codex and other coding agents.

The philosophy matters as much as the content. Approaches like GSD, BMAD and Spec-Kit try to help by owning the whole process, but in doing so they take away your control and make bugs in the process hard to resolve. These skills do the opposite: they are small, easy to adapt and composable, based on decades of engineering experience. You hack around with them and make them your own.

The project is MIT licensed, works with any model, and had 283,427 stars at the time of writing, making it one of the most-starred repositories on GitHub.

The Four Failure Modes These Skills Fix

The README frames the whole collection around four ways coding agents fail, each with a matching skill.

1. The agent did not do what you want. The most common failure mode in software development is misalignment: you think the dev knows what you want, then you see what was built and realize it never understood you. The fix is a grilling session, getting the agent to ask you detailed questions about what you are building. The /grill-me skill (for non-code uses) and /grill-with-docs (same idea, plus it builds your project's domain model) handle this. These are the repo's most popular skills: use them every time you want to make a change.

2. The agent is way too verbose. Agents dropped into a project use 20 words where 1 will do, because they never learned the project's jargon. The fix is a shared language: a glossary document that helps the agent decode domain terms. This is built into /grill-with-docs, which sharpens terminology and updates GLOSSARY.md and ADRs inline. The README gives a vivid example: "There's a problem when a lesson inside a section of a course is made 'real'" becomes "There's a problem with the materialization cascade." That concision pays off session after session, and it even saves tokens because the agent thinks in a more compact language.

3. The code does not work. Once you are aligned, the agent still needs feedback loops: static types, browser access and automated tests. The /tdd skill slots a red-green-refactor loop into any project, encouraging the agent to write a failing test first and fix it. For debugging, /diagnosing-bugs wraps best debugging practices into a disciplined loop: build a feedback loop that goes red on the bug, minimize, hypothesize, instrument, fix, regression-test, gated phase by phase.

4. We built a ball of mud. Agents speed up coding, which also accelerates software entropy: codebases get more complex at an unprecedented rate. The fix is caring about design every day. /to-spec quizzes you about which modules you are touching before creating a spec, and /improve-codebase-architecture surveys the codebase for deepening opportunities, presents them as a visual HTML report, then grills through whichever one you pick. The README is honest about the limit: it is a survey, not a rescue. It will not untangle a genuinely old codebase for you.

The Skills Catalog: Engineering and Productivity

The skills split on two axes. Engineering skills are for code work; productivity skills are general workflow tools. And each skill is either user-invoked (you type it, like /grill-me, and its job is to orchestrate) or model-invoked (the agent reaches for it automatically when the task fits, holding the reusable discipline).

Engineering highlights:

/grill-with-docs: grilling session that also builds the project's domain model, updating GLOSSARY.md and ADRs inline
/triage: moves issues through a state machine of triage roles
/improve-codebase-architecture: scans for deepening opportunities and presents a visual HTML report
/to-spec and /to-tickets: turn conversations into specs and break plans into tracer-bullet tickets with blocking edges
/implement and /implement-spec: build the work, driving /tdd at pre-agreed seams and closing with /code-review before committing
/wayfinder: plans work bigger than one agent session as a shared map of decision tickets
/tdd: red-green-refactor, one vertical slice at a time
/diagnosing-bugs: disciplined diagnosis loop for hard bugs and performance regressions
/code-review: two-axis review (standards and spec fidelity) run as parallel sub-agents
/pr: the shape a PR body should take, with before/after evidence and a merge-danger call

Productivity highlights:

/grill-me: relentlessly interviewed about a plan until every branch of the design tree is resolved
/handoff: compacts the current conversation into a handoff document so another agent can continue
/teach: teaches a new skill or concept over multiple sessions
/wait-what: fires the moment a message does not land; the agent re-pitches it in plain English using your glossary vocabulary
/writing-for-agents: guidance for writing documents agents actually use, like skills and AGENTS.md files

How to Install the Skills (30-Second Setup)

Installation takes about 30 seconds and differs per agent. A plugin updates itself; the skills.sh route copies editable files into your project that you update by hand. Pick one per agent, because installing both gives you every skill twice.

Claude Code:

claude plugin install mattpocock-skills@claude-plugins-official

Codex:

codex plugin marketplace add mattpocock/skills
codex plugin add mattpocock-skills@mattpocock

GitHub Copilot (CLI and VS Code):

copilot plugin marketplace add mattpocock/skills
copilot plugin install mattpocock-skills@mattpocock

Then add the marketplace to ~/.copilot/settings.json once. In VS Code, run Chat: Install Plugin From Source and enter the repo URL.

Gemini CLI (manual updates):

gemini skills install https://github.com/mattpocock/skills.git --path skills/engineering
gemini skills install https://github.com/mattpocock/skills.git --path skills/productivity

Any other agent, or editable files:

npx skills@latest add mattpocock/skills -a <agent>

This supports Cursor, OpenCode, Devin, Windsurf, Amp and Pi; omit -a to choose interactively. When the installer asks which skills to take, include setup-matt-pocock-skills. To update, run npx skills@latest update, and re-run add to pick up new skills.

After installing, run /setup-matt-pocock-skills once per repo in your agent. It asks which issue tracker you use, what labels you apply when triaging, and where to save docs. Then you are ready.

Why Skills Beat Frameworks: Small, Adaptable, Composable

The design philosophy is the part most worth stealing. Heavyweight agent frameworks own your process: they decide the workflow, and when the workflow has a bug, you are stuck debugging someone else's process. These skills are the opposite bet: small units you compose yourself.

That shows up in the architecture. User-invoked skills orchestrate; model-invoked skills hold reusable discipline. A user-invoked skill may invoke model-invoked skills, but never another user-invoked one, which keeps the composition graph clean. The /ask-matt skill even acts as a router, asking which skill or flow fits your situation.

It also shows up in the tone. The README reads like advice from a senior engineer, not a product manual: "Hack around with them. Make them your own." The skills encode practices from The Pragmatic Programmer, Domain-Driven Design, Extreme Programming and A Philosophy of Software Design, but they never lecture. They just make the agent do the disciplined thing by default.

If you want to keep up with changes and new skills, about 60,000 developers follow the author's newsletter. The repo itself moves fast: it was pushed as recently as 9 October 2026.

Good Fit, Poor Fit

Good fit if you use Claude Code, Codex, Copilot or Gemini CLI daily and your agent keeps building the wrong thing, rambling, shipping broken code or growing your codebase into mud. It is also a great fit if you want to learn the underlying engineering practices, since each skill is a readable Markdown file you can adapt.

Poor fit if you want a fully automated pipeline that owns the process end to end. These skills deliberately keep you in control, which means they ask more of you than a framework would. If you prefer the agent to just go, the grilling sessions will feel like friction.

Fuller write-up aside, the repo README itself is the best documentation: every skill links to its own SKILL.md with the full workflow. Start with /grill-me on your next real task and see how the alignment changes the output.

FAQ

What is mattpocock/skills?

It is an open-source collection of agent skills by Matt Pocock (Total TypeScript) for real engineering with AI coding agents. The skills fix four common failure modes: misalignment, verbosity, broken code and architectural decay, and they work with Claude Code, Codex, GitHub Copilot, Gemini CLI, Cursor and other agents.

Is mattpocock/skills free?

Yes. The repo is MIT licensed and free to use. You install the skills as a plugin or as editable files, and they work with whatever model your agent already uses.

What is the difference between user-invoked and model-invoked skills?

User-invoked skills are triggered when you type them (like /grill-me) and orchestrate a workflow. Model-invoked skills can be invoked by you or reached for automatically by the agent when the task fits; they hold the reusable discipline, like the TDD loop or the code review checklist.

Which agents support these skills?

Claude Code, Codex, GitHub Copilot (CLI and VS Code), Gemini CLI, Cursor, OpenCode, Devin, Windsurf, Amp and Pi. Claude Code, Codex and Copilot install it as a self-updating plugin; other agents use npx skills add with editable files.

What is /grill-me?

It is the repo's most popular skill. It makes your agent relentlessly interview you about a plan or design until every branch of the design tree is resolved, fixing the most common failure mode: the agent building something you did not want.

Do these skills work with any model?

Yes. The skills are model-agnostic prompt workflows, not model-specific integrations. They work with whatever model your agent uses.

How is this different from GSD, BMAD or Spec-Kit?

Those frameworks own the whole development process, which takes away your control and makes process bugs hard to resolve. These skills are small, easy to adapt and composable: you combine them yourself and adapt them to your workflow.

How do I update the skills?

Plugin installs update themselves (Claude Code by default, Codex at startup, Copilot daily in VS Code). For the editable-files route, run npx skills@latest update, then re-run the add command to pick up new skills.

Originally published on DevPik.

Text-to-CAD: Open-Source AI CAD Generator for Claude Code

Muhammad Tayyab — Thu, 15 Oct 2026 09:35:44 +0000

Text-to-CAD is an MIT-licensed plugin that gives Claude Code, Codex, Cursor, Gemini and Grok a full CAD workflow. Instead of generating a mesh, your agent writes a parametric Python model that produces exact STEP geometry, then exports STL or 3MF, draws dimensioned drawings, checks manufacturability and sends parts to a printer.

What Text-to-CAD Is: CAD Superpowers for Your AI Coding Agent

Text-to-CAD is an open-source plugin with a one-line promise: "Give your agent CAD superpowers." Install it in Claude Code, Codex, Cursor, Gemini or Grok Build, describe a part in plain language or show it a sketch, and your agent produces a real 3D model.

It goes well past a single model, too. The plugin gives the agent local workflows to:

generate 3D models as STEP, STL, 3MF or GLB files
produce dimensioned engineering drawings as PDF
run design-for-manufacturing checks for sheet metal, CNC machining, injection molding and 3D printing
find off-the-shelf parts like screws, bearings and motors as ready-made STEP files
slice models into G-code and send them to 3D printers, or check files before ordering laser-cut parts
write robot description files for ROS and simulators

It is built on two serious open-source foundations: build123d 0.11, a Python CAD library, and Open CASCADE 7.9, the geometry kernel behind FreeCAD. The engine ships on PyPI as cadgen. The project is MIT licensed, had 18,586 stars at the time of writing, and released v0.7.19 on 9 October 2026.

One naming note: this is not Zoo's Text-to-CAD, a separate commercial product with the same name. This one is a free plugin, created by earthtojake, that runs locally inside the coding agent you already use.

CAD as Code: Why It Writes Python Instead of Generating a Mesh

This is the idea that separates Text-to-CAD from most "AI 3D model generators".

Typical text-to-3D tools output a mesh: thousands of triangles approximating a surface. That is fine for a figurine. It is useless for engineering, because a mesh has no true circles, no exact hole diameters and no parameters. You cannot reliably change a 6 mm wall to 8 mm in a triangle soup.

Text-to-CAD has the agent write code instead. A model is a plain Python script with a decorated function that returns a build123d shape:

from cadgen import build123d as bd
from cadgen import step

WIDTH = 40.0

@step(out="../STEP/bracket.step")
def bracket():
    body = bd.Box(WIDTH, 20, 6)
    body.label = "bracket"
    return body

Running the script writes a STEP file: exact boundary-representation geometry, the universal exchange format that FreeCAD, Fusion and SolidWorks all import. Want the bracket wider? Change WIDTH and rerun. Want a 3D-printable copy? Stack an @stl or @threemf decorator on the same function, and the mesh is derived from the exact model rather than the other way round.

Because the model is source code, everything good about code applies: it lives in git, a change shows up as a readable diff, and assemblies are built by calling child models. The skill enforces reproducibility too. Geometry "must not depend on untracked time, random values, environment variables or the working directory", so the same script always builds the same part.

The Agent Has to Prove the Part Is Right

An AI that says "done" is not the same as a part that fits. The CAD skill turns verification into an explicit step of the workflow.

After building, the agent is told to choose checks from the requested dimensions, clearances and topology, and to run them against the saved file, not the source. Measurements use native build123d geometry. Then it must render at least one snapshot of the result and read it itself, with the instruction to "always render and read them yourself, never rely on the viewer for it."

Two lines from the skill set the tone for the whole project:

A failed computation is not a pass.

Report units, thresholds, selected geometry and untested requirements.

The hand-off has to list output files, the checks actually run, and any assumptions. For unfamiliar dimensions, the agent records what it assumed. When missing information would materially change the result, it asks you instead of guessing. Failures are repaired in the source, and the affected checks rerun.

If you are working from a spec sheet in inches while the models default to millimeters, a unit converter settles the numbers before they reach the prompt.

Point at a Face in the Viewer and Ask for a Change

The plugin includes CAD Viewer, a local server that shows models where you are working. In Claude Desktop, models appear as viewer cards in the chat that you can orbit and open full size. In the Codex app there is a CAD tab beside each thread that the agent drives. In terminal agents, asking to see a model gives you a link that opens it in your browser.

The clever part is that selection flows back into the conversation. Click a face and the viewer copies a precise reference to it, such as assembly.step#o1.2.f7, which pins down that one face in that saved file. The agent opens the document with read_scene, resolves the reference to real geometry, and knows exactly which surface "this face" means.

A Quick Edit goes further: you describe the change, the viewer attaches the file and references, and if you sketched on the view, a PNG of your markup. The agent is instructed to look at that sketch before touching the model. It is the CAD equivalent of circling something on a printout and writing "make this thicker" next to it.

The agent also has its own eyes: cad_screenshot shows it what you are seeing, and cad_view reads what you have selected.

Twelve Skills, From Bolts to Bambu Lab Printers

Text-to-CAD is a library of focused skills. Install the plugin and the agent loads whichever one a request needs:

Skill	What it does
CAD	Creates and edits models from text or images; STEP first, plus STL, 3MF and GLB
step.parts	Finds off-the-shelf STEP parts: screws, bearings, motors, connectors
Engineering Drawing	Dimensioned PDF drawings with views, hidden lines, hole callouts and a title block
DXF	2D profiles, templates, gaskets and cut layouts
URDF	Robot structure files: links, joints, limits, inertials, meshes
SRDF	MoveIt planning groups, end effectors, poses and collision rules
SDF	Simulator models and worlds with physics, sensors and lights
SendCutSend	Checks DXF and STEP files before upload to SendCutSend
DfAM Check	3D-printability: wall thickness, overhangs, support volume, orientation
DFM	Sheet metal, CNC and injection molding review with cited rules
G-code	Slices models with OrcaSlicer using your own printer presets
Bambu Labs	Sends prints to Bambu Lab printers via Bambu Connect or Bambu Studio

The breadth matters because real projects cross these lines. A robot arm needs CAD parts, purchased servos, a URDF for ROS, and printed brackets. Text-to-CAD keeps the whole chain in one conversation.

Real Parts and Real Manufacturing Rules, Not Placeholders

Two skills keep designs grounded in the physical world.

step.parts is a hosted catalog of purchasable components with an API. When an assembly needs a named servo, motor or fastener, the agent is told to search it before inventing a placeholder, to try aliases and vendor names before giving up, and to verify each downloaded STEP file against its SHA-256 hash when the catalog publishes one. If it does fall back to a simplified envelope, it has to say so.

DFM reviews a part for sheet metal, CNC machining or injection molding, and its rules are strict about evidence:

It is "a guided review skill, not an automatic feature-recognition or manufacturing certification engine", and unavailable checks must be reported as unavailable.
Your actual supplier's specification beats general guidance, and conflicting specifications are recorded rather than silently resolved.
Every limit adopted must cite its source, version, access date and units. If a rule cannot be checked, the review reports it missing rather than making up a default.
It must never infer an alloy, resin, strength or stock thickness from a rendering's material or color.
For injection molding, a script measures draft, undercuts and projected area from the mesh.

3D printing has its own skill, DfAM Check, which measures printability per process, and the G-code and Bambu Lab skills take a checked model all the way to a print.

Robots Too: URDF, SRDF and SDF Files

Robotics is where Text-to-CAD quietly saves the most tedium. Robot description files are verbose, unforgiving and usually written by hand.

URDF describes a robot's links and joints, with limits, inertials and meshes, and is the standard format in ROS.
SRDF adds MoveIt's semantic layer: planning groups, end effectors, named poses and which collisions to ignore.
SDF describes models and whole worlds for simulators, including physics, sensors and lights.

Because the parts themselves come from the CAD skill, the meshes in these files can come from the real geometry rather than eyeballed stand-ins. All three formats are XML; when you want to inspect one programmatically or feed it into a web tool, an XML to JSON converter gives you a structure that is much easier to query.

How to Install Text-to-CAD in Claude Code, Codex or Cursor

The simplest install is to send your agent one message:

Install text-to-cad from https://github.com/earthtojake/text-to-cad

To do it yourself, first make sure uv, Astral's Python package manager, is installed (uv --version). Then, in Claude Code:

claude plugin marketplace add earthtojake/text-to-cad#latest
claude plugin install text-to-cad@earthtojake

Restart the app; the first start downloads the CAD runtime, so it needs a network connection. Codex installs from its plugin directory, Gemini as an extension with --auto-update, and Cursor and Grok Build can reuse the Claude Code plugin directly. Any agent that supports the skills framework can install the skills alone with npx skills add earthtojake/text-to-cad#latest.

Three tips from the README:

Install the plugin or the skills, not both, or every skill loads twice.
The commands use the latest branch, which only receives released versions. Leaving it out installs main, which can contain unreleased work.
When updating skills, rerun npx skills add rather than npx skills update, which silently misses newly added skills.

Windows 11 gotcha. The CAD kernel's Python binding ships an unsigned native module, and Windows 11's Smart App Control, on by default on fresh installs, blocks it. Every command then fails with ImportError: DLL load failed while importing OCP. There is no per-app exception: either turn Smart App Control off, which can only be reversed by reinstalling Windows, or run the CAD skills under WSL. cadgen doctor detects this case.

Telemetry Is On by Default: Here Is Exactly What It Sends

Text-to-CAD sends usage statistics and crash reports by default, and the README documents them in unusual detail, so it is worth knowing before you install.

What is sent: versions, install source, operating system and agent app, and counts, such as how often each CAD tool was called, how many models were built, and why a call failed, chosen from a fixed set of reasons rather than the error message. Crash reports include the error type and where in cadgen it failed. Everything is tagged with a random install ID and stored with PostHog. The server derives your country from your IP address and does not keep the address.

What is never sent: file names, paths, file contents or prompts.

How to turn it off: run uvx cadgen telemetry off (which also deletes what was already sent), use the menu in the viewer, or ask your agent. DO_NOT_TRACK=1 disables it for a single process. Nothing is sent in CI or from a development install, and everything works offline.

Separately, cadgen checks for a new version at most once a day with one anonymous request; CADGEN_UPDATE_CHECK=0 stops that too.

Repo Health: 18,586 Stars and a Fast Release Cadence

The repository was created on 22 April 2026 and had 18,586 stars, 1,848 forks, 1,453 commits and 20 contributors at the time of writing. Development is fast: v0.7.17, v0.7.18 and v0.7.19 all shipped between 8 and 9 October 2026, and the cadgen package has had 57 releases on PyPI. A test workflow runs in CI, documentation lives at texttocad.dev, and there is a Discord community.

Good fit if you design functional parts: brackets, enclosures, mounts, jigs, robot components or anything with dimensions that matter. It suits makers with a 3D printer, robotics developers tired of hand-writing URDF, and engineers who want a parametric starting point they can open in their usual CAD tool.

Poor fit if you want organic or sculpted shapes such as characters and figurines, where mesh-based text-to-3D generators are the better tool. It is also not a substitute for a manufacturer's sign-off: the DFM skill is explicitly a guided review, not certification. And on Windows 11, plan for the Smart App Control step above.

If you like the idea of agents doing serious engineering work, the mirror image of this project is REA, which points an agent at existing software and takes it apart instead.

FAQ

What is Text-to-CAD?

Text-to-CAD is a free, MIT-licensed plugin that gives AI coding agents like Claude Code, Codex, Cursor, Gemini and Grok a full CAD workflow. The agent writes parametric Python models with build123d that produce STEP files, and can export STL, 3MF and GLB, generate engineering drawings, run manufacturability checks and send parts to printers.

Is Text-to-CAD free?

Yes. The plugin and its cadgen engine are open source under the MIT license. You only need an AI agent you already use and uv to run it. Fabrication services and printers it connects to are paid separately as usual.

Is this the same as Zoo's Text-to-CAD?

No. Zoo's Text-to-CAD is a separate commercial product. earthtojake/text-to-cad is an independent open-source plugin that runs locally inside your coding agent.

What file formats does Text-to-CAD produce?

STEP is the main output, giving exact geometry you can open in FreeCAD, Fusion or SolidWorks. It also exports STL, 3MF and GLB meshes, DXF for 2D profiles, PDF engineering drawings, G-code for printers, and URDF, SRDF and SDF files for robotics.

Which AI agents support Text-to-CAD?

It has plugins or extensions for Claude Code, Claude Desktop, Codex, Cursor, Grok Build and Gemini, and any agent that supports the skills framework can install the skills with npx skills add.

Can I edit the models in other CAD software?

Yes. Models are saved as STEP files, the standard exchange format for mechanical CAD, so FreeCAD, Fusion, SolidWorks and most other CAD tools can import them. The Python source also stays editable, so changing a parameter and rerunning rebuilds the part.

Does Text-to-CAD upload my designs?

No. Models are built locally. By default it sends anonymous usage statistics and crash reports, but never file names, paths, contents or prompts, and you can turn that off with uvx cadgen telemetry off.

Why does Text-to-CAD fail with 'DLL load failed while importing OCP' on Windows?

Windows 11's Smart App Control blocks the unsigned native module in the CAD kernel's Python binding. Turn Smart App Control off, which can only be undone by reinstalling Windows, or run the CAD skills under WSL. Running cadgen doctor confirms the cause.

Originally published on DevPik.

Career-Ops: Open-Source AI Job Search Agent for Claude Code

Muhammad Tayyab — Thu, 15 Oct 2026 09:33:52 +0000

Career-Ops is a free, open-source AI job search agent that runs inside Claude Code, Codex and other AI coding CLIs. It checks that a posting is real, scores it 1 to 5 against your actual CV, tells you to skip anything below 4.0, and drafts a tailored CV and cover letter for the rest. It never presses Submit.

What Career-Ops Is: An AI Job Search Agent That Lives in Your Coding CLI

Career-Ops is an open-source AI job search agent that runs inside the AI coding CLI you already use: Claude Code, Codex, OpenCode, Antigravity, Qwen, Grok Build and several others. You paste a job posting. It checks that the posting is still live, scores the role from 1 to 5 against your real CV, and then either tells you to skip it or drafts a tailored CV, a cover letter and answers for the application form. Then it stops. You press Submit.

It was built by Santiago Fernández de Valderrama Aparicio (santifer) for his own job search, and the README states the result in one line: 740 listings evaluated, 68 applied, 12 interviews, 1 offer. The offer was a Head of Applied AI role. Six months later he left it to work on career-ops full time.

Two things are worth knowing before you read anything else about it:

The repository moved. It started as santifer/career-ops and now lives at career-ops-hq/career-ops. The old URL redirects, but a lot of what ranks for "career-ops" still describes the early version, which graded every job from A to F. The current system writes a structured A-H report with a single 1-5 global score. This page covers that version, v1.35.0, released on 1 October 2026.
It is not a hosted service. There is no account, no backend and no telemetry. It is a folder of markdown modes, Node.js scripts and a Go terminal dashboard on your own machine, released under the MIT license.

The Filter Is the Product: Only 68 of 740 Jobs Got an Application

The README opens with the line that explains the whole design: "Companies use AI to filter candidates. I just gave candidates AI to choose companies."

Most AI job tools compete on volume: more applications, sent faster, ideally automatically. Career-ops goes the other way. Look at the funnel again. Of 740 listings evaluated, 68 received an application, about 9%. The other 91% were turned down by the candidate before anyone spent an evening on a cover letter. Of the 68 applications, 12 became interviews, roughly 18%.

The mechanism is a single line in the scoring rules:

Global score	What career-ops tells you
4.5 and above	Strong match, apply immediately
4.0 to 4.4	Good match, worth applying
3.5 to 3.9	Decent but not ideal, apply only with a specific reason
Below 3.5	Recommends against applying

Below 4.0, it will tell you not to apply. You can override it, and it records that you did. The human stays in charge of the decision that matters most: whether this job deserves your night at all. The README puts it better than any feature list: "If it comes back do not apply, you just got the night back."

How Career-Ops Scores a Job: Five Dimensions, One Number, Eight Report Blocks

Before scoring, the agent classifies the role into an archetype. The defaults reflect the author's own search (LLMOps, Agentic, PM, Solutions Architect, Forward Deployed Engineer, Transformation), and the target roles you define in your own profile take precedence.

The 1-5 global score then integrates five dimensions:

Dimension	What it measures
Match with CV	Skills, experience and proof points
North Star alignment	Fit with the target roles you defined
Comp	Salary against the market, 5 being top quartile
Cultural signals	Culture, growth, stability, remote policy
Red flags	Blockers and warnings, applied as negative adjustments

There is deliberately no arithmetic formula. The global score is one holistic judgement across the five, and once decided, the same value goes into the report header, a machine-readable summary and your tracker.

Around that number sits the A-H evaluation report:

A. Role summary, including geo-mismatch and work-authorization checks. A posting that explicitly rules out visa sponsorship is flagged as a hard blocker.
B. Match with CV, one row per significant requirement, each mapped to an exact line of evidence.
C. Level and strategy.
D. Comp and demand, backed by salary research.
E. Customization plan for the CV.
F. Interview plan, built on STAR+R stories (STAR plus a Reflection).
G. Posting legitimacy: is this a real opening at all?
H. Draft application answers.

Two of those signals are kept out of the score on purpose: the requirement importance in Block B and the legitimacy tier in Block G. The reason is comparability. The 4.0 line has to mean the same thing across your entire history, so that analyze-patterns.mjs and stats.mjs can later tell you something true about where your applications stall.

It Reads the Job Description Before Your CV, to Avoid Flattering You

This is the most interesting engineering decision in the repository. It lives in modes/oferta.md as the "two-pass rule".

When the agent fills in the CV match table, it works in two strict passes:

Pass 1, job description only. Write down each requirement and how much it matters in this posting, before reading your CV.
Pass 2, the CV. Only then read cv.md and mark each row Strong, Partial or Missing, quoting the evidence.

Importance is never revised in pass two. The reason is anchoring. A model that has just written "Strong" next to a requirement tends to rate that requirement as important, and to quietly discount the ones you lack. Doing it in the natural order would make the table flatter you exactly where it should warn you. Here the safeguard is the order of generation itself, not an instruction to "be objective".

Importance uses five named bands (critical, high, meaningful, preferred, low_signal) rather than a 0-100 number, because "87 versus 84" would not reproduce across two runs on the same posting. Every row also carries an evidence tier:

stated: the posting itself says "required" or "must have", backed by a verbatim quote.
structural: the posting's layout carries the weight, for example which section the requirement sits under.
inferred: market knowledge about how such roles are actually screened.

Then comes a gate: an inferred requirement can never be rated critical or high. The file explains the asymmetry. Inflating a requirement you are missing reads as "don't bother applying", which costs you an application you should have sent. Under-weighting a real one costs a less-prepared interview, which you can recover from. The cap sits on the side where being wrong is expensive.

One more detail worth copying into any LLM pipeline: job descriptions are treated as untrusted input. If a posting contains text aimed at the reviewer ("rank this requirement highest"), it is quoted as an anomaly in Block G and not obeyed. That is prompt-injection defence built into a job search tool.

Ghost Job Detection: It Checks the Posting Is Real Before You Write a Word

Ghost jobs, listings that stay up long after a role is filled or that were never really open, are one of the most common complaints about job hunting right now. Career-ops deals with them twice.

First, a liveness gate. When you paste a URL, the agent loads the page with Playwright before any evaluation starts. A 404, an "applications closed" banner or a redirect to a generic careers page stops the run before Block A, so a dead link never burns a full report and PDF. It also knows that many careers pages embed an Ashby or other ATS board inside an iframe, where the outer page looks empty while the listing is perfectly fine, and it refuses to call that closed.

Second, Block G rates every live posting as High Confidence, Proceed with Caution or Suspicious. The signals are weighted by how reliable they actually are:

Signal	Reliability
Posting age (under 30 days good, 60+ concerning)	High
Apply button active	High
Tech specificity in the description	Medium
Requirements realism	Medium
Recent layoff news	Medium
Same role reposted 2+ times in 90 days	Medium
Salary transparency	Low

The framing rules are strict: never present the findings as an accusation, always note the legitimate explanations, and let you decide. Outside the evaluation, detect-reposts.mjs tracks reposting across your scan history, and node scan.mjs --verify runs a Playwright liveness check on newly discovered listings before they ever reach your pipeline.

Tailored ATS-Friendly CVs and Cover Letters, With a Fact Check

When a role clears the bar, career-ops generates an ATS-readable PDF CV tailored to that job description. It is rendered from an HTML template through Playwright, set in Space Grotesk and DM Sans. If you live in LaTeX, it can export a .tex file for Overleaf or tailor your own resume.tex in place, and there is a plain markdown version too.

Cover letters use the same pipeline: keyword mirroring, four angle prompts (why, problems, approach, tone), a draft you approve in chat, then an A4 PDF. One is drafted automatically with every evaluation. If you want the idea without setting up a CLI, our free AI cover letter generator does a browser-only version for a single posting.

The rule that matters most here is "reformulate, never fabricate", and the README is unusually candid about how far it is enforced:

generate-pdf blocks a CV whose numbers or facts appear in neither your CV nor your article digest, unless you pass --skip-fact-check.
It does not yet check job titles or judge rewording. Two open issues track that gap: #2677 (titles must match cv.md) and #1411 (a fail-closed faithfulness check).

Until those merge, read every CV before it goes out. An AI proofreader will catch the grammar, but only you can catch a claim you never made.

What Career-Ops Will Not Do: No Auto-Submit, No Email, No Telemetry

The README gives its refusals their own section, and each one is backed by something concrete:

Auto-submit an application. It drafts an answer for every field. The script that prepares applications, prepare-application.mjs, documents that it never POSTs anything; you open the apply URL and submit yourself.
Send an email. Drafts only. There is no mail transport anywhere in the codebase.
Phone home. No telemetry and no backend. Your CV goes from your machine to the AI provider you chose, and nowhere else.
Push you to apply below 4.0. It recommends against it, and notes your override.

Outreach follows the same rule. The contacto mode identifies the hiring manager, recruiter or peer worth messaging and drafts a LinkedIn note of 300 characters or fewer, but it never sends it. If you edit that draft, a word and character counter keeps it under the limit.

"Draft, never decide" is becoming the standard posture for serious agent tooling. Anthropic's financial services agents take exactly the same line: they prepare analyst work and stage every output for human sign-off.

The disclaimer adds the necessary caveat. The prompts instruct the model never to submit, but models can behave unpredictably, especially if you edit the prompts or switch models. Treat the guarantee as the project's design, and your own review as the backstop.

How to Install Career-Ops in One Command

The fastest path needs Node.js and an AI coding CLI:

npx @santifer/career-ops init
cd career-ops
claude   # or codex, opencode, qwen, grok

init clones the latest release into ./career-ops and installs the dependencies. On first launch the agent asks for your CV, what you want and what you refuse, all in chat, with nothing to configure by hand. The README is frank about the start: "The first runs are rough. It does not know you yet." Treat it like a recruiter's first week.

If you prefer manual setup, clone the repository, run npm install, then npx playwright install chromium (only needed for PDFs) and npm run doctor to validate the prerequisites. Configuration is plain files: cv.md holds your CV, config/profile.yml your profile, and portals.yml the companies to scan. YAML is strict about indentation, so a YAML formatter saves a confusing error when the scanner reads a broken file.

From there, paste a job URL or description and the auto-pipeline runs: evaluation, report, PDF and tracker entry. In CLIs that register slash commands, /career-ops lists around forty modes, including scan, pipeline, pdf, cover, tracker, interview-prep, apply and patterns. Codex does not guarantee slash commands, so there you ask for a mode in plain language: "Run the career-ops scan mode."

Two options worth knowing:

npm i -g @santifer/career-ops installs a global career-ops command once you have a project folder.
Setting CAREER_OPS_ROOT moves your personal data (CV, reports, tracker, PDFs) out of the code checkout, so updating or switching branches never touches it.

Running Career-Ops for Free, and the API Key That Quietly Bills You

Career-ops is free; the AI model behind it is where the cost lives, and you have several ways to control it.

A spend_tier setting in config/profile.yml picks the model that evaluates offers. In Claude Code, economy maps to Haiku 4.5, standard to Sonnet 5.5 and premium to Opus 5.5. Every tier produces the same A-H report format. For zero spend, the project documents OpenRouter's free models, Ollama or any OpenAI-compatible endpoint, a guide to running on Antigravity CLI's free tier, and a standalone gemini-eval.mjs script that works with a free Gemini API key and no CLI at all.

Discovery is cheap by design. node scan.mjs finds new listings across the configured portals without spending any tokens. The tokens go into evaluating them, which is exactly where you want the model's attention.

Now the trap, which the FAQ answers because so many people hit it. If you pay for Claude Pro or Max and still see API charges, an ANTHROPIC_API_KEY in your environment is taking precedence over your logged-in subscription, so the CLI bills per token instead. Run echo $ANTHROPIC_API_KEY; if it prints anything, remove it from your shell profile, restart the terminal and run /login. Batch mode is the exception: its headless claude -p workers do not use the interactive login, so run claude setup-token once and export the result as CLAUDE_CODE_OAUTH_TOKEN.

The Rest of the Pipeline: Scanner, Tracker, Dashboard and Interview Prep

Evaluation is the core, but the repository covers the whole search from discovery to offer:

Portal scanner. More than 100 companies are pre-configured (Anthropic, OpenAI, ElevenLabs, Retool, n8n and more) with 35+ search queries, across 55+ provider modules covering Ashby, Greenhouse, Lever, Wellfound and board-wide feeds.
Job application tracker. Every evaluated offer is registered automatically, with merging, de-duplication and status normalization handled by scripts rather than by hand.
Dashboard. A terminal UI written in Go with Bubble Tea, with six filter tabs, four sort modes and inline status changes. An experimental web UI exists but only runs if you start it.
Batch processing. Parallel evaluation through headless workers (claude -p or opencode run).
Interview suite. A STAR+R story bank built up across evaluations, time-blocked prep plans, practice sessions with feedback, post-interview debriefs and an employer red-flag detector.
Offer stage. A contract reading companion that walks the clauses and lists questions for a lawyer (explicitly not legal advice), plus a salary-gap analyzer and negotiation scripts.
Learning from outcomes. patterns analyzes where rejections cluster, and calibrate checks whether your scores actually predicted your results. It reports; it never changes the scoring.

Integrations such as Gmail, Notion and Apify exist as opt-in plugins, disabled by default.

Repo Health: 73,583 Stars in Six Months, and Who It Is For

The repository was created on 4 April 2026 and had 73,583 stars and 13,820 forks at the time of writing. The latest release, v1.35.0, shipped on 1 October 2026. The README is translated into 17 languages, the project has been covered by Business Insider and WIRED's Greek edition, and it reached number one on Trendshift's repository of the day.

The community signals are unusually concrete. A public HIRED.md wall had 13 hiring stories on the record, each one an issue you can open and read, and the CareerOps Manifesto ("Apply better to fewer. Signal over volume. Evidence over keywords. A human decides.") had 144 signatures, each one an auditable commit. The author says the repository is maintained by a fleet of AI agents with a human deciding every merge. SerpApi sponsors it, under a stated rule that sponsorship buys labelled visibility and never influences evaluations or rankings. The code is MIT; the career-ops name is covered by a separate trademark policy that reserves it for commercial product naming.

Good fit if you are applying to more roles than you can evaluate properly, you already use an AI coding CLI, and you want a second opinion that is willing to tell you no. It is strongest for tech roles, since that is where the default archetypes and pre-configured portals point, though the archetypes are fully customizable.

Poor fit if you want a tool that applies for you while you sleep. Career-ops is a filter, not a spray-and-pray auto-applier, and that is the entire point of it. It is also not for anyone unwilling to read every CV it produces before sending, because the fact check does not yet cover everything.

FAQ

What is career-ops?

Career-ops is a free, open-source AI job search agent that runs locally inside an AI coding CLI such as Claude Code, Codex or OpenCode. It checks that a job posting is live, scores it 1 to 5 against your CV, generates a tailored ATS-friendly CV and cover letter, and tracks every application. You make every decision and press Submit yourself.

Is career-ops free?

Yes. The code is MIT licensed and free for candidates. You pay only for the AI model you run it on, and it supports free and local options including OpenRouter free models, Ollama, any OpenAI-compatible endpoint and a free Gemini API key.

Does career-ops auto-apply to jobs?

No. It drafts answers for every field of the application, but the script that prepares applications never submits anything and there is no email sending anywhere in the code. It is designed as a filter, not an auto-applier.

What score should a job get before I apply?

Career-ops recommends applying at 4.0 out of 5 or higher. 4.5 and above is a strong match, 3.5 to 3.9 is worth applying only with a specific reason, and below 3.5 it recommends against applying. You can always override it.

Which AI CLIs does career-ops work with?

Claude Code, Codex, OpenCode, Antigravity CLI, Qwen, Kimi, GitHub Copilot, Grok Build CLI and Pi, through the open Agent Skill Standard. It is not locked to one vendor.

Does career-ops upload my CV anywhere?

No. There is no backend and no telemetry. Your CV and application data stay on your machine and are only sent to the AI provider you chose to run the agent.

Why is career-ops using API credits when I pay for Claude Pro or Max?

An ANTHROPIC_API_KEY set in your environment takes precedence over your logged-in subscription. Remove it from your shell profile, restart the terminal and run /login. For batch mode, run claude setup-token and export the result as CLAUDE_CODE_OAUTH_TOKEN.

Is career-ops-hq/career-ops the same project as santifer/career-ops?

Yes. The repository moved from santifer/career-ops to the career-ops-hq organization, and the old GitHub URL redirects to the new one. The npm package is still published as @santifer/career-ops.

Originally published on DevPik.

Open Dots: Self-Hosted, Open-Source OpenAI Dots Alternative

Muhammad Tayyab — Thu, 15 Oct 2026 09:32:08 +0000

Open Dots is a free, MIT-licensed AI agent workspace you run on your own machine: assistant personas, any Responses-compatible model, app connectors, web search and an optional computer runtime. Where OpenAI Dots screens actions with a second model, Open Dots stops every risky action and asks you first. It is an early prototype, and this page covers what works today.

What Open Dots Is: A Self-Hosted Take on OpenAI Dots

OpenAI announced Dots at DevDay on 29 September 2026: always-on personal agents, built on GPT-6 Astra, that pursue goals in the background. You can reach a dot from ChatGPT, Slack or Teams, and it launched for ChatGPT Pro and Business Premium subscribers in eligible markets (TechCrunch). Each dot works on a cloud computer with a browser and integrates with more than 4,000 apps, and NBC News reported it was not available in Europe or the UK at launch.

Open Dots is an open-source answer for everyone who wants the idea without the subscription, the region lock or someone else's cloud. It is a self-hosted AI agent workspace, released under the MIT license, that you run on your own machine. You create assistants, chat with them on the model of your choice, connect apps, search the web, and optionally hand them a sandboxed computer. Everything is stored locally, and any action with real consequences waits for you to approve it.

It is built by Anil Matcha and is independent of OpenAI. The README is unusually direct about where it stands: Open Dots is "an early prototype, not a feature-equivalent replacement" for OpenAI Dots, Meta Muse, Grok Bot, Manus Cue, Claude Cowork or ChatGPT agent, all of which it names as products it can be evaluated against. This page takes that at its word and covers what the code actually does today.

OpenAI Dots vs Open Dots: What You Get and What You Give Up

The two share a name and an idea, not a feature list. Here is the honest side-by-side:

	OpenAI Dots	Open Dots
Hosting	Managed by OpenAI	Self-hosted, on your machine or server
Model	GPT-6 Astra	Any model behind a compatible API
Always-on background work	Yes, the core feature	No, and no scheduled routines
Where you talk to it	ChatGPT, Slack, Teams	A web client
App integrations	4,000+	Composio connectors, GitHub issues, web search
Computer	A cloud computer with its own browser	Optional Docker/Playwright container, or a remote service
Action oversight	Auto-review by a second model, per the Astra system card	You approve risky actions, with an audit log
Your data	OpenAI's cloud	SQLite on your disk, credentials encrypted
Price	Part of premium ChatGPT plans	Free software; you pay your model provider
License	Proprietary	MIT
Maturity	Commercial launch	Prototype, single owner

If you want an agent that keeps working while you sleep and answers you on Slack, Open Dots does not do that yet. Where it wins is in the rows that matter most to a developer: you can read every line of the code that decides what your agent is allowed to do, choose the model, and keep the conversation history on your own disk.

The Real Difference: A Human Approves Every Risky Action

This is the design choice that makes Open Dots worth reading even if you never run it.

OpenAI's safety documentation for GPT-6 Astra, the model behind Dots, describes auto-review: a second model "evaluates the safety of certain commands that run outside a pre-specified sandbox," and blocks the ones it judges unsafe (OpenAI deployment safety). The safeguard it describes is a model screening a model.

Open Dots puts a person there instead. Every tool call goes through an action gateway in server/app/services/action_gateway.py, and the gateway is deny-by-default: an action that is not registered is refused outright, and a registered one must match its definition, pass its arguments as a JSON object and include a human-readable preview. Each action carries a risk class (read, write or external), and the dangerous ones pause for your approval:

Action	Risk	Waits for you?
Read or list files in the workspace	read	Yes
Write a file in the workspace	write	Yes
Navigate the computer's browser	external	Yes
Run a terminal command	write	Yes
Send keyboard or mouse input	write	Yes
Create a GitHub issue	write	Yes
List GitHub issues	read	No
Screenshot or list the computer's files	read	No
Web search you typed with `/search`	external	No, but audited

Three details show real care. Approvals expire after 120 seconds by default, and an expired request is never executed. An approval is consumed before the action runs, so one click allows at most one execution; a contributor fix (pull request #125) closed a gap where a cancelled, already-approved action could have been replayed. And every step (requested, approved, denied, expired, started, completed, failed) lands in an audit log, with anything that looks like an API key, token, password or cookie redacted before it is written.

Computer Use, Inside a Locked-Down Container

The computer is optional, and it is off by default: the default fake provider exists for development and returns deterministic results. To give your assistants a real browser, you build the bundled Docker image, which runs Playwright:

docker build -t open-dots-computer:1.62.1 ./runtime
export COMPUTER_PROVIDER=docker
export COMPUTER_DOCKER_IMAGE=open-dots-computer:1.62.1

Each assistant gets its own workspace, and the container launch flags in the source are conservative: a read-only root filesystem with small temporary mounts, dropped Linux capabilities, no-new-privileges, a non-root user, an optional seccomp profile, and limits of 2 CPUs, 2 GB of memory and 512 processes by default. A remote provider can point at a compatible external computer service instead.

The README is explicit that this is "not a hardened sandbox for hostile websites". Containers reduce what a compromised browser can reach; they do not make it safe to point an agent at arbitrary untrusted pages with your credentials loaded. Review network egress and what the container can see before you do anything serious with it.

Workspace file tools have their own boundary. Every path is resolved and rejected if it lands outside WORKSPACE_ROOT, and single files are capped at 128 KB by default.

Bring Your Own Model: How the Inference Adapter Works

OpenAI Dots runs on GPT-6 Astra and nothing else. Open Dots runs on whatever you point it at, within one constraint worth knowing before you install.

In Settings, Model provider, you enter an API base URL, an API key and the model IDs you want, and pick one of two wire protocols:

Responses API: any OpenAI Responses-compatible service. Requests stream from /responses, conversation roles are preserved, and attached images are sent as data URLs.
Prediction: the original adapter, which sends a request to {base_url}/{model_id} and uploads images separately.

The catch: the classic Chat Completions protocol is not implemented. A provider that only speaks /chat/completions will not work until that lands.

New assistants default to gpt-5-mini, and you can change the default in settings. API keys and custom headers are encrypted at rest with a Fernet key and never displayed again after saving. Because you bring the model, the cost is whatever your provider charges per token, with no subscription in the middle.

Each assistant is a persona with its own instructions, model and visual identity, so a cheap fast model can handle one assistant while a stronger one handles another.

Connectors and Web Search, Kept Deliberately Narrow

OpenAI Dots advertises 4,000+ integrations. Open Dots ships a short list on purpose, and says so.

Composio connectors handle app sign-in through explicit OAuth. The built-in actions are narrow: list GitHub issues (read-only, no approval) and create a GitHub issue (approval required). Arbitrary tool discovery and writes are not implemented.
Web search works from chat with /search <query>. It runs through the You.com MCP server, and no key is required: without YDC_API_KEY it uses You.com's keyless free profile with a reduced read-only tool set. Adding a key raises the limits. Because you typed the command yourself, it does not pause for approval, but it still writes audit events like every other action.

Chat itself covers the expected ground: streaming responses, Markdown rendering, image attachments, locally saved conversations and voice dictation in browsers that support speech input.

How to Install Open Dots, and Lock It Down

You need Python 3.10+, Node.js and an API key for a compatible model provider. Start the API:

git clone https://github.com/Anil-matcha/open-dots.git
cd open-dots/server
python -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt
python run.py

Then the web client in a second terminal:

cd open-dots/client
npm install
npm run dev

Open http://127.0.0.1:3000 and sign in with the owner token. On first start the server generates it into .auth-token under ~/.open-dots, alongside the encryption key, and writes both with permission mode 600 so only your user can read them. If you ever restore that folder from a backup, a chmod calculator confirms you have put the same owner-only permissions back. Your model provider's key is separate, and goes into App Settings after you sign in.

Sessions use HttpOnly cookies with server-enforced expiry, and restarting the API signs everyone out. Even loopback requests must authenticate.

Before exposing it beyond localhost, the README asks for four things: set APP_AUTH_TOKEN on the server only, serve it over HTTPS with AUTH_COOKIE_SECURE=1, keep CORS_ORIGINS narrow, and never put a credential in a NEXT_PUBLIC_* variable, because those are compiled into the JavaScript every visitor downloads. If you set your own token, make it long and random; a random string generator does that in one click. And since the project asks contributors never to commit credentials or local transcripts, start your fork with a .gitignore that excludes .env files before the first commit.

What Open Dots Cannot Do Yet

The README lists its own limitations, which saves you finding them the hard way:

One owner. No user accounts, roles or multi-user permissions.
Local SQLite only. No multi-instance storage or built-in backups, and sessions are not shared across API workers.
No Chat Completions and no generic provider plugin interface.
No always-on agents. No scheduled routines, no durable memory service.
No mobile or desktop client. No Slack, SMS or phone access, which is how many people reach OpenAI Dots.
Narrow connectors, by design.
The computer runtime is not a hardened boundary for hostile web content.

Read that list as the gap between Open Dots and the product it is named after. Background autonomy, long-term memory and messaging channels are exactly what makes OpenAI Dots a different kind of product. Open Dots today is closer to a well-governed agent workspace than an always-on assistant.

Three Projects Called OpenDots: Which One Is This?

OpenAI's announcement produced several open-source namesakes within minutes. Three GitHub repositories with the name gained their current code on 29 September 2026, about twenty minutes apart:

Repository	What it is
`Anil-matcha/open-dots` (this page)	Python and Next.js agent workspace with human approvals and an optional container computer. MIT.
`CopilotKit/OpenDots`	TypeScript template for always-on AI coworkers that move between text, calls and Slack. MIT, 3,773 stars at the time of writing.
`diggerhq/opendots`	TypeScript always-on personal agent built on OpenComputer Serverless Agents. MIT, an early project with a handful of stars.

If background, always-on behavior is what drew you to OpenAI Dots, CopilotKit's project is the closer match on paper. If what you want is a self-hosted workspace where you can inspect and gate every action, this one is built around exactly that. Also note that a pair of Shokz earbuds and a crypto token use the name too, so add "github" to your search.

Repo Health: A Week-Old Project in an Older Repository

The repository shows 5,483 stars and 649 forks at the time of writing, and that number needs context. The repository was created in May 2023, and its commit history shows the Open Dots code arriving on 29 September 2026 in a commit that swapped out a previous project. Most of those stars were earned by earlier projects in the same repository, not by Open Dots, which was one week old when this page was written.

The first week is still encouraging. An outside contributor landed five merged pull requests, including the approval-replay fix above, explicit owner login with revocable sessions, and fixes for silent record loss. More pull requests are open, including runtime hardening and an alternative search backend. The server ships with a test suite of 15 files covering the action gateway, authentication security, the Docker and remote computer providers, connectors and search.

Good fit if you want to study or build on a clean, readable implementation of approval-gated agent actions; you want a self-hosted assistant workspace where no conversation leaves your machine except to the model you chose; or you are outside the regions where OpenAI Dots launched.

Poor fit if you want an assistant that works unattended in the background, reaches you on Slack or by phone, or is ready for a team. It is a single-owner prototype, and the README says so on its first screen.

FAQ

What is Open Dots?

Open Dots is a free, open-source, self-hosted AI agent workspace released under the MIT license. It offers assistant personas, chat on a model you choose, app connectors, web search and an optional sandboxed computer, with a human approval step before risky actions. It positions itself as an open-source alternative to OpenAI Dots.

Is Open Dots made by OpenAI?

No. Open Dots is an independent project by Anil Matcha and is not affiliated with or endorsed by OpenAI. OpenAI Dots is OpenAI's own commercial personal agent, announced at DevDay on 29 September 2026.

Is Open Dots free?

Yes. The software is MIT licensed and free to run. You pay only your model provider for the tokens your assistants use, and web search works without a key through You.com's keyless free profile.

Can Open Dots work in the background like OpenAI Dots?

Not yet. Open Dots has no always-on agents, scheduled routines or durable memory service. It works when you use it through its web client, while OpenAI Dots is designed to pursue goals continuously in the background.

Which AI models does Open Dots support?

Any model behind an OpenAI Responses-compatible API, or a service matching its original prediction contract. The Chat Completions protocol is not implemented yet. New assistants default to gpt-5-mini, and you can set your own model IDs and default in settings.

Is Open Dots computer use safe?

It is guarded but not hardened. Browser navigation, terminal commands and input all require your approval, and the Docker runtime uses a read-only filesystem, dropped capabilities and a non-root user. The README still warns that it is not a hardened sandbox for hostile websites.

How is Open Dots different from CopilotKit's OpenDots?

They are separate projects that launched the same day. Anil-matcha/open-dots is a Python and Next.js workspace centred on human-approved actions. CopilotKit/OpenDots is a TypeScript template for always-on AI coworkers that you can reach by text, calls and Slack.

Can I use Open Dots from Slack or my phone?

No. Open Dots currently has a web client only. Slack, SMS, phone calls and mobile or desktop apps are not implemented.

Originally published on DevPik.

Hypit: Free Open-Source AI Video Cloning for Agents

Muhammad Tayyab — Thu, 15 Oct 2026 09:29:49 +0000

Hypit is a free, open-source system that gives AI agents like Claude Code and Codex a language and toolchain for video. Drop in any viral video and your agent clones it as a complete, editable workflow, then ships 100 variants from a single command.

What Hypit Actually Is

The pitch is one line: clone any viral video with AI agents. Hypit gives coding agents like Claude Code and Codex a language and a system for making video. Drop in a reference video, and your agent clones it as a complete workflow: the footage, the captions, the B-roll, the effects, all anchored to words instead of seconds.

The distinction the README insists on matters. This is not a script breakdown or a shot-list generator. You get an editable, re-runnable composition, the whole production pipeline as code, which means the clone is a starting point you can remix endlessly: swap the face, the words, the B-roll, ship 100 variants in one command.

And to be clear, cloning is the fastest way in, not the only one. You can start from the included templates, or just describe the video you want and your agent writes the workflow from scratch. Generation models are optional too: a workflow can compile captions, motion graphics and code-rendered visuals into a finished video without calling a generation model or incurring its service charges. That last point is doing quiet work in the background of every example below.

The Core Idea: Video Anchored to Words, Not Seconds

Traditional video editing is timeline editing: everything is pinned to a timestamp. Hypit pins everything to words instead. The composition is written in SVML, the project's markup language for video, where segments, hosts, captions and effects attach to the spoken text.

The payoff shows up the moment you change something. Rewrite a line and the timing re-flows itself, captions re-align, B-roll re-cues. WhisperX handles the word-level alignment, and the examples show speaker-aware karaoke captions driven by face bounding boxes, so the captions know who is talking, not just what was said.

Components are pluggable on top of that. Swap the host without touching the captions. Use the library, fork it, or write your own. The README's framing is deliberate: creating a component is ordinary video-production work, and the same package can be handed off as a versioned tarball or published under your own npm scope. The workflow stays yours and stays editable, which is the opposite of the one-off renders that most AI video tools produce.

The Receipts: Three Videos, About a Dollar Each

The README does something most AI video projects avoid: it publishes the production notes and the cost for three full examples.

UGC: "GOAT DEBATE". A 20-second football tier list putting Ronaldo in D and Messi in S. Two AI-generated A-rolls, a 2K portrait and ten 1K B-rolls, WhisperX word alignment, a sound-synced ranking board, color-box karaoke captions and background music, concurrently rendered in 64 headless Chromium processes. Three clones included: swap the narrator to a banana cat, flip the rankings so Ronaldo becomes GOAT, or replace all players with tech founders. Same viral structure, different viral video. Total cost: $1.15.

Podcast: "DAILY CREATINE". An 18-second podcast clip with split-screen interview layout, speaker-aware captions, a product-handoff moment and background music. Three clones: swap both hosts to Pepe and Doge, replace the creatine with retinol, or ditch the physical product for an app. Same podcast format, three ad verticals. Total cost: $1.07.

Street interview: "NICE RIDE". A 26-second interview with head-tracked speaker-colored captions, a sound-synced emoji reveal board with color flashes and reveal sound effects. Three clones: swap hosts to Wojak and Chad, translate everything to Spanish with the same punchlines, or swap the Lambo for an F1 car. Total cost: $1.09.

The pattern across all three is the product thesis in miniature: one composition, N variants, each a full production, each around a dollar in model-service charges.

What You Can Actually Build With It

The README's use-case list reads like a content agency's service menu, and each one maps to the clone-and-vary loop.

Paid social ads. Clone a winning ad from the Meta Ad Library, swap in your product, ship 50 hook variants the same day. When the creative fatigues in two weeks, re-run with fresh openings; the body never changes.

Viral clones. Any TikTok, Reel or Short becomes a template. Swap the host, the hook, the product, the language, the aspect ratio. If you are reformatting across surfaces, check the destination's preferred dimensions first with our Aspect Ratio Calculator: a vertical Short cropped wrong is just a tall wrong file.

TikTok Shop and affiliate videos. One format that converts, a new SKU every day. Swap the product, the price, the CTA; the structure that worked stays untouched.

AI UGC and talking heads. Narration, word-level captions, B-roll, comment stickers, beat-synced cuts, all wired automatically.

Podcast and interview clips. Split-screen layouts, speaker-aware captions, reaction overlays.

Code-rendered videos. Visuals driven entirely by front-end code, rendered locally without generation API calls, which is where the "generation models optional" claim earns its keep.

Localized versions. The same video in ten languages. Rewrite a line and the timing re-flows itself, which is the word-anchored editing idea paying off directly.

Getting Started: One Install, Then /hypit

Installation is a single command that installs Hypit as an agent skill:

npx skills add hypit-ai/hypit -g

On first use, your agent checks for the Hypit executable and helps prepare it if needed. Your video project can live anywhere. Then you talk to your agent in plain language:

/hypit Clone this video: /path/to/video.mp4, and replace the ranking content with a comparison of Hypit with other AI video products.

Or start without a reference at all:

/hypit Make a ranking video that puts Hypit in S tier.

Your agent checks the environment, requests the credentials the video needs, generates the material and builds the finished composition. Hypit itself is free to use; your coding agent and model services have their own accounts and charges. HypiHub is the recommended hosted model service, but you can also use your own API or local models by telling your agent the service name and its API documentation so it can set up the connection.

Prerequisites are modern but unremarkable: Node.js 22.15+, pnpm 10.33, TypeScript 5.9. There is a quickstart and a development guide at hypit.ai, plus Discord and Telegram communities linked from the README.

The Honest Limitation: License Wording and Real Costs

Two caveats, and both are about reading the fine print rather than the features.

First, the license. The README badge says "Apache-2.0 with conditions", but the LICENSE file itself is titled the Hypit Open Source License, and GitHub reports the license as unasserted. The README is explicit about one part: the videos and outputs you create belong to you, and third-party models and services may have their own terms. What the "conditions" amount to in practice needs the LICENSE file read, not the badge. If you plan to build a business on this, read it before you ship, the way you would with any source-available project that is not plain MIT or Apache-2.0.

Second, the costs are real even when they are small. The $1.07 to $1.15 figures are model-service charges for the documented examples, billed by the service you choose, not by Hypit. Your coding agent's own usage is separate. The counterweight is genuine: generation models are optional, local models are supported, and code-rendered videos cost nothing in API charges at all. The economics work best when you treat the agent as the director and keep the expensive generation calls to the parts that need them.

The third, softer caveat is youth. The repository was created on 29 July 2026. The documentation, examples and community channels are unusually polished for a two-month-old project, and the launch-partner table suggests real ecosystem momentum, but expect the edges that come with that age.

Repo Health: 19,103 Stars in Two Months

The repository was created on 29 July 2026 and sits at 19,103 stars with 2,150 forks at the time of writing; the latest push landed on 3 October 2026, the day before this page went up. It also holds Trendshift's #1 repository-of-the-day badge. For a project barely two months old, that is not organic discovery, it is a launch that landed, and the star history will tell you whether it compounds or fades.

Good fit if you produce short-form video at volume, ads, affiliate content, localized versions, UGC-style clips, and you want an agent-driven pipeline where one composition becomes a hundred variants without re-editing by hand.

Poor fit if you need long-form editing, you want a no-code tool rather than an agent skill, or you require a plain permissive license grant for commercial use. Read the Hypit Open Source License first, then decide.

FAQ

Is Hypit really free?

Yes. It is open source with no seat pricing, per-render fees or watermark. The costs that exist belong to your coding agent and the model services you choose, which have their own accounts and charges.

Do I need a reference video to start?

No. Cloning a video is the fastest way in, but you can also start from the included templates or just describe the video you want and your agent writes the workflow from scratch.

Do I need AI generation models to use it?

No, they are optional. A workflow can compile captions, motion graphics and code-rendered visuals into a finished video without calling a generation model or incurring its charges.

What license is Hypit under?

The README releases it under the Hypit Open Source License (the badge mentions Apache-2.0 with conditions). The videos and outputs you create belong to you; third-party models and services have their own terms. Read the LICENSE file before commercial use.

How much does it cost to make a video?

The README's documented examples cost $1.07 to $1.15 each in model-service charges. Your actual cost depends on the service you choose; local models and code-rendered videos can bring it to near zero.

Originally published on DevPik.

OpenVid: Free Open-Source Demo Video Maker

Muhammad Tayyab — Thu, 15 Oct 2026 09:26:25 +0000

OpenVid is a free, open-source web app that turns a screen recording or an uploaded clip into a studio-quality demo: device mockups, 3D transforms, cinematic zooms with a virtual camera, more than a hundred backgrounds, multi-track audio and export up to 4K MP4, all running in your browser.

What OpenVid Actually Is

Demo videos are the part of shipping nobody budgets for. You record your screen, and what you get is raw footage: a flat window, a dead background, no emphasis anywhere. Then comes the editing, the motion graphics, the export settings, and the three hours you did not have. OpenVid exists to collapse that whole pipeline into one browser tab.

It is a free, open-source web app, built with Next.js and TypeScript, purpose-built for one job: turning a screen recording or an uploaded video clip into a polished product demo. Record your screen directly in the browser or upload an MP4, WebM, QuickTime or MKV file, then add device mockups, 3D transformations, smooth cinematic zooms and one of more than a hundred pre-designed backgrounds. When it looks right, export up to 4K MP4.

The part that matters most is where the work happens. Everything renders in your browser. The video processing runs on FFmpeg.wasm, the 3D effects on Three.js, the preview on the Canvas API, with MediaBunny optimising the pipeline. Recorded videos are stored in IndexedDB on your own machine and settings live in LocalStorage. Nothing about the architecture requires your footage to travel to someone else's server, which is the correct default for a tool whose entire input is your unreleased product.

The Workflow: Record, Stage, Zoom, Export

OpenVid organises itself the way a demo actually gets made.

Video input. Two doors in: capture your screen straight from the browser with no installation, or upload an existing clip. Supported uploads are MP4, WebM, QuickTime and MKV, which covers screen recordings from every major OS.

Mockup creation. This is the stage most screen recorders skip. Drop your recording into a device mockup, apply 3D transformations to tilt and angle it, and the flat capture starts reading as a product shot. The README also lists mockups applied to still images, so the same stage works for screenshots you want to feature.

Visual customisation. More than 100 pre-designed backgrounds, plus the option to bring your own image, pull from Unsplash, or use solid colours and gradients. On top of the canvas you can layer shapes, text with custom fonts and colours, imported SVG graphics and image overlays in PNG, JPG and WebP. If you are matching a brand palette on a background or overlay, our Color Converter turns the hex you were handed into RGB and HSL without a round trip through a design tool.

Zoom. Zoom in and out at specific timeline moments with speed and easing control. Then the signature move: a 3D virtual camera that tilts and rotates dynamically based on points of interest. This is what separates a demo that looks recorded from one that looks directed.

Audio. Multi-track support with auto-trim that cuts the audio to the video duration, so the voiceover or music never dangles past the last frame.

Export. Quality from 480p up to 4K at 30fps, in MP4 (H.264), WebM (VP9, with transparent background support), GIF, or still frames in PNG, WebP, JPG and AVIF. The GIF and WebM-with-transparency options are the quiet winners here: they cover the looping demo clip on a README or landing page, which is where most demo videos actually end up being watched.

The 3D Camera Is the Killer Feature

Every demo tool has zoom. OpenVid's version deserves the paragraph because of how it moves.

A normal zoom is a scale animation: the frame gets bigger around a point. OpenVid's 3D camera, built on Three.js, adds tilt and dynamic rotation that follows points of interest across the timeline. The camera does not just magnify; it reframes, the way a person holding a camera would. Combined with the easing controls, the result reads as directed footage rather than a screen capture with effects bolted on.

This is also where the device mockups earn their keep. A flat recording zoomed in is just a bigger flat recording. A recording sitting inside a tilted device mockup, with the 3D camera sweeping across it, is a product shot. The combination is the whole pitch of the tool: it manufactures the production value that usually requires After Effects and an afternoon.

Everything Renders in Your Browser, Including the Privacy Story

The technology section of the README reads like a deliberate bet on the browser as a workstation: FFmpeg.wasm for fully in-browser rendering, Canvas API for the preview, MediaBunny for an optimised video pipeline, Three.js for the 3D effects, and an HTML-to-Image step for mockup export.

The practical consequence is privacy by architecture. Your recordings sit in IndexedDB, your settings in LocalStorage, and the render never has to leave your machine. Supabase cloud backups are listed as coming soon, which means today the tradeoff is explicit: no cloud project syncing, but also no upload step and no account required to start.

That same bet sets the ceiling. Browser-based rendering leans on your machine, so a 4K export of a long timeline will ask for real CPU and memory. For the tool's actual use case, short product demos and feature clips, that is the right tradeoff. If you are cutting a twenty-minute tutorial, this is not your editor, and it does not pretend to be.

Getting Started: Try It Live, or Self-Host in One Command

The fastest route needs no install at all: there is a live demo at openvid.dev, so you can record something and judge the output before touching a terminal.

Self-hosting is the standard Next.js drill:

pnpm install
cp .env.example .env (then add your Supabase credentials)
pnpm dev

Open http://localhost:3000 and you are in. The .env.example step is there for the planned Supabase cloud backups; the core editor runs without it.

Two practical notes before you export for a specific surface. If the demo is headed for a README or a social post, check the destination's preferred dimensions first with our Aspect Ratio Calculator: a 4K export cropped wrong is just a large wrong file. And if you need to embed a small asset as a data URI in a page, Base64 encode does it in one step.

The Honest Limitation: No License File, and a Young Project

Two caveats, and the first one is the important one.

The repository currently ships no license file. GitHub reports the license as unasserted, which means there is no explicit grant of reuse rights attached to the code, whatever the README's "open source" framing suggests. The source is public and you can read, run and learn from it, but if you plan to use it commercially, fork it, or build on it, that missing file is a real gap: check with the author first. This is worth stating plainly because the rest of the project invites you to treat it as freely reusable.

The second caveat is youth. The repository was created in February 2026, the contributor graph is small, and cloud backup is still a roadmap item. The Discord community exists and contributions are welcome, which is the right shape for a project at this stage, but expect the occasional rough edge and a feature set that is still growing into its ambition. The export format list already covers the realistic needs; the risk is in the long tail, not the core.

Repo Health: 2,684 Stars and a Steady Pulse

The repository was created on 10 February 2026 and sits at 2,684 stars with 384 forks at the time of writing; the latest push landed on 28 September 2026, five days before this page went up. The star count has roughly tripled since the spring, which for a niche dev-tool is the healthy pattern: slow, compounding discovery rather than a launch-day spike.

Good fit if you ship software and need demo videos, feature clips or landing-page loops, and you would rather do it in a browser tab than learn a video editor or pay for a cloud rendering service.

Poor fit if you need long-form editing, collaborative cloud projects today rather than when the Supabase backup lands, or you require a clear license grant for commercial use. Check the license situation first, then decide.

FAQ

Is OpenVid really free?

Yes, there is no paid tier: the source is public on GitHub and the live demo at openvid.dev runs without an account. One caution: the repository currently ships no license file, so if you plan commercial use, confirm the terms with the author first.

Do I need to install anything to use it?

No. It is a web app that runs entirely in your browser, and there is a live demo at openvid.dev. Installing is only for self-hosting: pnpm install, copy .env.example to .env, and pnpm dev.

What video formats can I import?

You can record your screen directly in the browser, or upload MP4, WebM, QuickTime and MKV files.

What can I export?

Video up to 4K at 30fps in MP4 (H.264), WebM (VP9, including transparent backgrounds) and GIF, plus still frames in PNG, WebP, JPG and AVIF.

Does my footage get uploaded to a server?

No. Rendering happens in your browser via FFmpeg.wasm; recordings are stored in IndexedDB and settings in LocalStorage on your own machine. Cloud backup via Supabase is listed as coming soon, not shipped.

How do I self-host OpenVid?

Clone the repository, run pnpm install, copy .env.example to .env and add your Supabase credentials, then pnpm dev and open http://localhost:3000. The Supabase step is only needed for the planned cloud backups.

Originally published on DevPik.