GitHub repos that actually help with AI coding: tokens and productivity

You open Cursor or Claude Code, type one line — the agent replies with half a page, then edits twelve files when you wanted one prop changed. End of month, usage spikes, diffs get noisy, and it feels like you're working with AI without steering AI.

This isn't a "top 10 trending" list. It's a small set of GitHub repos I use or have tested carefully, aimed at three jobs:

1. Talk short — less filler, faster reading, sometimes cheaper output tokens.
2. Aim the code — fewer silent assumptions, less over-engineering.
3. Skills on time — ready workflows, without dumping every rule into every message.

For: people building side projects or shipping daily in Cursor, Claude Code, or Codex — who want a small, intentional stack.

Core idea: Cheaper tokens ≠ better decisions. The best repos teach the agent when to stop and ask, not only how to grunt shorter.

Related build notes: Building a side project with AI agents.

Quick map · Which repo for which job

You don't need everything. Two base layers (Karpathy + one skill pack) + one mouth layer (caveman if you hate filler) covers most people.

1 · Caveman — small mouth, big brain

Repo: JuliusBrussee/caveman

Caveman is a skill/plugin: tell the agent to drop filler, keep full technical substance. Code, commands, error strings — byte-exact.

Before / after (idea)

Before (~69 tokens):
The reason your React component is re-rendering is likely because you're creating a new object reference on each render… I'd recommend using useMemo…

After (~19 tokens):
New object ref each render. Inline object prop = new ref = re-render. Wrap in useMemo.

Same fix. Far fewer words.

The numbers (and the honest part)

Their Claude API benchmarks (10 prompts): ~65% output vs default verbose agents. But Honest Numbers is blunt:

• Only shrinks output. Input + thinking stay.
• The skill adds ~1–1.5k input tokens per turn.
• Real sessions often land around 14–21% total on chatty workloads; already-terse Q&A can go net-negative.
• For many people the real win is faster reading, not a guaranteed 65% bill cut.

Cursor install (short)

# Skill for Cursor
npx skills add JuliusBrussee/caveman -a cursor

# Optional always-on rule in the repo
# → .cursor/rules/caveman.mdc

On: /caveman or "talk like caveman". Off: "normal mode". Levels: lite | full | ultra | wenyan.

Use when: long explanations, reviews, debug walkthroughs.
Skip when: replies are already short; or you pay per request (shorter ≠ fewer requests).

I keep an always-on rule in mylittleworld.dev because I want agent chat easy to scan during late-night debugging. Tokens are a bonus; reading speed is the main reason.

2 · Karpathy skills — against "assume and run"

Repo: multica-ai/andrej-karpathy-skills

Drawn from Andrej Karpathy's notes: models silently assume, hide confusion, over-engineer, and touch unrelated code.

Four principles in one file (CLAUDE.md / Cursor rule):

Cursor

The repo ships .cursor/rules/karpathy-guidelines.mdc. Copy it in, or read CURSOR.md.

Signs it's working

• Diffs match only what you asked
• Clarifying questions before 400 lines of code
• Fewer "rewrite because it got too complex" loops
• Cleaner PRs — no "while I'm here, reformat the file"

Their tradeoff note: bias caution over speed. One-line typos don't need the full ritual. Goal: fewer expensive mistakes on non-trivial work.

On a side project, this saves me more than caveman: agents love inventing a "service layer" for one function. Karpathy rules = pushback is allowed.

3 · Addy Osmani Agent Skills — workflows with gates

Repo: addyosmani/agent-skills

Not one short prompt. A production engineering skill pack: steps, verification gates, anti-patterns — senior checklists wired into the agent.

Quick install (skills CLI):

npx skills add addyosmani/agent-skills

Cursor: skills under .cursor/skills/; short policies in .cursor/rules/*.mdc — don't paste full long skills into always-on rules (you pay input tokens every message).

Productivity value: less "read 40 files to discover the world" when a skill already encodes patterns + gates (security, performance, a11y…). You spend tokens on doing the process, not wandering.

4 · JuliusBrussee/skills — grill first, build second

Repo: JuliusBrussee/skills

Same "cave" as caveman. One command:

npx skills@latest add JuliusBrussee/skills

grill-me pairs well with Karpathy: one forces think first, one forces keep it simple. Together they cut the worst token sink — "built it, then learned the requirement was wrong".

5 · Skills CLI — the install pipe

Repo: vercel-labs/skills

Many repos above use npx skills add …. This CLI is the transport layer: one skill → Cursor / Claude Code / Codex / Cline / …

When the skill stack grows:

• On-demand skills beat dumping everything into the system prompt each session.
• Always-on rules stay short (Karpathy, "never commit secrets").
• Long skills (security audit, performance) — load when triggered.

This is where input token savings get real: less dead context every turn.

6 · Optional pieces in the same ecosystem

Not required, useful if you go deeper:

Suggested stack · 15-minute Cursor setup

Ramp up — don't install 30 skills on day one:

Step 1 — Brain (do this if you work seriously)

Copy karpathy-guidelines.mdc into .cursor/rules/, alwaysApply: true.

Step 2 — Mouth (optional taste)

npx skills add JuliusBrussee/caveman -a cursor

Try a week. Hate the voice → turn it off, keep Karpathy.

Step 3 — One quality skill pack

Pick one (not both on day one):

• npx skills add addyosmani/agent-skills — engineering gates
• npx skills@latest add JuliusBrussee/skills — grill-me + caveman siblings

Step 4 — Your project rules

A short file: stack (Next, Hono, Drizzle…), "lint before commit", "don't touch .env". Same idea as the pre-push-lint rule in this repo.

Self-check after one week

• Are average diffs leaner?
• Does the agent ask when unclear — or still guess?
• Token usage this week vs last (similar tasks)?
• Did you disable a skill because it was noise?

Common mistakes

1. Install every trending skill → bloated context, slower agent, higher bill. Few and sharp.
2. Believe "65%" is whole-session → read Honest Numbers; A/B on your own usage page.
3. Optimize mouth, not behavior → terse answers that still ship an 800-line abstraction. If you pick one: Karpathy > caveman.
4. Always-on long skills → pay 1–2k tokens every message unused. Skills = on demand; rules = short.
5. Skip reading diffs → fake productivity. Speed ≠ ownership (side project post).

Closing

GitHub is full of "AI skills". The useful layer usually splits three ways:

• Behavior: Karpathy guidelines — fewer expensive mistakes.
• Mouth / output tokens: Caveman — less filler (when the workload fits).
• Process: Agent skill packs + skills CLI — right job, right time.

You don't need a full cave. You need a frame so the agent doesn't run wild, and a few valves so context doesn't inflate for free.

Token savings are the bonus. Fewer redo loops is the productivity.

---

If you try this stack in Cursor — log one week of usage and how diffs feel. Your numbers beat marketing benchmarks.