5 GitHub repos that turn AI slop into actual products

Most people scroll Twitter to find the next AI tool. The smarter move is scrolling GitHub, because that's where the actual working code shows up before it gets wrapped in a $29/month SaaS landing page. Right now there are at least five repos sitting in public that do things people are quietly charging for — cleaning AI writing, running a CRM on autopilot, editing video from a transcript, scanning agent skills for malware, and puppeting a real phone from a coding agent.

None of these require a computer science degree. They require Claude Code or Codex, a terminal, and about ten minutes per repo to get a first working demo. Here's what each one actually does, how to install it, and the first small workflow worth trying.

What is the No AI Slop skill and why does it matter?

If you've ever read a LinkedIn post and instantly known it was AI-written — the em-dashes, the "it's not just X, it's Y" structure, the fake enthusiasm — that's the pattern this skill was built to kill. No AI Slop is a free skill from Peter Yang, a product leader who's worked at Roblox, Reddit, Twitch, and Meta, and it's designed to strip those tells out of any draft while keeping the writer's actual voice.

It installs into AI coding environments like Claude Code or OpenAI Codex and runs as a slash command to detect and remove characteristic patterns of AI-generated writing from any piece of text. The skill isn't a wrapper app — it is not a standalone app or SaaS product; it is a reusable instruction set that runs inside an existing AI agent environment. It removes more than 20 named AI writing patterns, from binary contrasts to importance puffery, while preserving the writer's personal voice.

One detail worth knowing before you use it: the skill won't tell you whether a piece of text was written by AI. It deliberately avoids that claim — instead of guessing authorship the way AI detectors do, its detect mode names each slop pattern it finds and quotes the exact line, so you can verify every finding yourself.

How do you install and use it?

1. Head to the No AI Slop GitHub repo and clone it.
2. Drop the skill into your Claude Code or Codex skills directory following the repo's setup instructions.
3. Write a rough, messy first draft yourself — don't ask AI to invent the whole thing from scratch. Get your real points down even if they're unpolished.
4. Run the /no-ai-slop command on that draft and let it strip out the robotic patterns while keeping your voice intact.

This workflow matters because the skill works best as an editor, not a ghostwriter. Draft first, clean second — that order is the whole trick.

What does the agentic CRM from Comp AI actually do?

Most CRMs are just a database with a form bolted on front, and the "AI" version usually just tacks a chatbot onto that same form. Comp AI's CRM flips that model. Instead of a human doing data entry while an AI assistant watches, the agent is the primary user of the CRM.

Most CRMs are a database with a form in front of it. The AI ones bolt a chat box onto the side of that form. Both leave the actual work — finding out what is true, and writing it down — to a human who has better things to do. This is built the other way round. The agent is not a feature of the CRM; the CRM is where the agent keeps its notes. It runs on its own deployment, on its own schedule, against its own work queue. It decides what to look at next, books its own follow-ups, spends a research budget, and stops when the budget runs out.

It's also genuinely useful without hooking up a dozen paid APIs. Every outside source is optional, and it is designed to run with none of them. With no API keys at all it still works: read_crm_history reads your own threads, meetings and signature blocks, which is free and is the best evidence there is — no data vendor can sell you a reply from the person's own address. The project has picked up real traction fast — the GitHub org shows the repo sitting at over 9,000 stars with more than 1,100 forks.

How do you set it up?

The repo assumes you're comfortable with Bun and Docker, but the setup is short:

git clone https://github.com/trycompai/crm.git && cd crm
cp .env.example .env
bun install
docker compose up -d        # Postgres on :5432
bun run db:deploy           # apply migrations
bun run db:seed             # optional: a believable pipeline to look at
bun run dev

The app is on localhost:3000, the API on localhost:3001. Before you dump real customer data in it, know the security model: sign-in is the entire authorisation model — ALLOWED_SIGN_IN decides who gets in; after that, every signed-in person can read and write every record. There are no roles, no per-record permissions and no organizations — deliberately. That's fine for a small team's internal pipeline; it's the wrong tool if you need per-rep visibility restrictions.

The first small workflow: seed the demo data, let the agent enrich three contacts from your own inbox history, and watch what it decides to flag as unverified versus confirmed.

How does Video Use edit video without ever "watching" it?

This one from the browser-use team is the strangest and most clever repo on this list. Video Use lets a coding agent edit raw footage — but the trick is that the LLM never actually watches the video frame by frame. That would be absurdly expensive and slow.

The LLM never watches the video. It reads it — through two layers that together give it everything it needs to cut with word-boundary precision. Layer 1 — Audio transcript (always loaded). One ElevenLabs Scribe call per source gives word-level timestamps, speaker diarization, and audio events ((laughter), (applause), (sigh)). The efficiency gain is the whole point: naive approach: 30,000 frames × 1,500 tokens = 45M tokens of noise. Video Use: 12KB text + a handful of PNGs. Same idea as browser-use giving an LLM a structured DOM instead of a screenshot — but for video.

The pipeline is a loop, not a one-shot render: Transcribe → Pack → LLM Reasons → EDL → Render → Self-Eval, and if there's an issue, fix and re-render (max 3). The self-eval loop runs timeline_view on the rendered output at every cut boundary — catches visual jumps, audio pops, hidden subtitles. You see the preview only after it passes.

How do you get it running?

The setup is genuinely agent-friendly — you can hand the whole install off to your coding agent instead of typing every command yourself.

git clone https://github.com/browser-use/video-use ~/Developer/video-use
ln -sfn ~/Developer/video-use ~/.claude/skills/video-use   # Claude Code
cd ~/Developer/video-use
uv sync                     # or: pip install -e .
brew install ffmpeg         # required
brew install yt-dlp         # optional, for downloading online sources
cp .env.example .env        # add ELEVENLABS_API_KEY=...

Or skip the manual steps entirely — paste a setup prompt telling your agent to read install.md first, install the repo, wire up ffmpeg, register the skill with whichever agent you're running under, and set up the ElevenLabs API key.

First workflow to try: drop in a 20-minute raw talking-head recording, ask the agent to cut it down to the tightest 3-minute version based on the transcript, and review the EDL before it renders.

What does NVIDIA's SkillSpector protect you from?

Here's the uncomfortable truth about the last few years of "agent skills": most people install them from a random GitHub repo without reading a single line of the code inside. SkillSpector exists because that habit is genuinely risky — a skill is just a folder that your agent trusts completely and runs "with everything you have."

SkillSpector is an open-source scanner from NVIDIA that reads an agent skill and tells you whether to install it. Point it at a directory, a zip file, a single SKILL.md, or a Git URL, and it returns a list of findings, a risk score, and recommendations. The folder it reads runs with everything you have. The danger concentrates in one specific place: a skill is Markdown instructing the agent, sometimes with a Python script beside it that reaches the shell, the environment variables, and the SSH directory. The script is where risk concentrates. The study behind the tool found skills that ship one are 2.12x more likely to be vulnerable.

The scanning itself is fast and layered. The first pass is static and takes seconds — an AST walk flags exec, eval, subprocess, and dynamic imports. A taint tracker follows environment variables and file contents to network sinks. YARA rules match known malware, webshells, and cryptominers. There's also an optional deeper pass: a second pass is optional, slower, and off until you configure it — wired up, an LLM reads the flagged code in context, drops false positives, and writes an explanation someone can act on, which the project puts at roughly 87% precision.

The scoring is blunt on purpose. Each finding adds points — a critical finding costs the most, a low one costs least, and anything past 50 on the scale comes back as do not install. Executable content multiplies the result by 1.3.

How do you run your first scan?

git clone https://github.com/NVIDIA/skillspector.git
cd skillspector
uv venv .venv && source .venv/bin/activate
make install
skillspector scan ./my-skill/ --no-llm   # fast static check
skillspector patterns                    # list all detection patterns

The obvious first move: point it at every skill you've already installed from a marketplace or a stranger's repo before you run any of them again. If you're pulling skills from anywhere other than a vetted catalog, this is the five-minute habit that prevents the worst kind of surprise.

What is Phone Harness and how does it control a real phone?

This is the repo that looks like it should require jailbreaking and doesn't. Phone Harness connects Claude Code, Codex, or any coding agent directly to a real iPhone or Android device — no special app, no developer certificate, no rooting.

Connect Claude Code, Codex, or any agent to your real phone — iPhone through the Mac's iPhone Mirroring window, Android over adb. The iPhone side works entirely through Apple's built-in mirroring feature: iPhone Mirroring renders the phone as a Mac window and forwards mouse and keyboard as touches. The harness captures that window, OCRs it with Apple's Vision framework for text with tap-ready coordinates, and posts HID-level events for taps, swipes, and typing. Android is even more direct: adb is the transport — screencap is the capture, the phone's accessibility tree is the text source, input is the hands. Works over USB or Wi‑Fi, no window needed.

And the barrier-to-entry objection people always raise gets addressed head-on in the repo itself: no jailbreak, no Xcode, nothing installed on the phone — the agent sees the screen, taps, types, and reads the result.

It's not magic, though — there are real limits worth knowing before you build a workflow around it: OCR sees text, not icons — unlabeled controls need a screenshot and a vision-capable model. No multi-touch, no camera or Face ID flows. DRM video renders black.

How do you set it up?

The fastest path is handing the whole thing to your agent as a setup prompt: "Set up phone-harness for me — clone https://github.com/ShawnPana/phone-harness into ~/.phone-harness, read install.md first, install it so phone-harness is a command on my PATH, and register it as an agent skill."

Once it's running, a basic action loop looks like this: agent wants to open Weather → find_text("Weather") returns coordinates → tap() → reads the screen → forecast is up, done.

First workflow to try: ask the agent to open a single app, find a piece of text on screen, tap it, and confirm the result — before trying anything with real accounts, payments, or 2FA involved.

What's the simplest way to actually use all five of these?

Don't try to master all five repos in one weekend. The pattern that actually works is the same three-step loop for each one:

1. Install it and get the demo running. Don't customize anything yet — just get the default example working end to end.
2. Make one small, real workflow work. Not a toy example from the README — something from your actual writing, your actual contact list, your actual footage, or your actual phone.
3. Decide whether to productize it or keep it as a personal lever. Some of these (the CRM, video editing) are strong enough to become the backbone of an actual product. Others (SkillSpector, No AI Slop) are better as a permanent habit you run quietly in the background.

The people building real leverage right now aren't waiting for these tools to show up polished in an app store. They're cloning the repo, running the install script, and treating a rough weekend project as a two-week head start on everyone else still waiting for the SaaS wrapper.

Go pick the one repo from this list that solves a problem you actually have this week — not the one that sounds coolest — and get it running before you move to the next.