skill

programloader

Load any course, link, or PDF into an AI that learns it, teaches you, and executes it.

programloader/programloadercommunitylistedunreviewed

Set up

Skills are installed by placing their folder where your agent loads skills.

Download ZIP from GitHub Open the repository

The download comes from github.com/programloader/programloader itself, not from our server, so what you get is exactly what its author published.

Install instructions come from the README

Skills do not use an MCP config. Follow the steps in the README below.

README

synced Oct 26, 2026

🧠 programloader

Load any course, link, or PDF into an AI that learns it, teaches you, and then works with you.

"I know kung fu." — Neo, after a program was loaded into his head.

There are brilliant guides out there — on agent loops, graph engineering, marketing, gardening, anything. But a guide is not an ability. programloader closes that gap: feed it material, and it compiles a Skill Pack that can do two things:

Teach you — a task-by-task curriculum with checkpoints, in plain language, built for people with zero technical background.
Work for you — the same pack becomes an executable skill an AI applies to your actual goals.

Learn it, or delegate it. Ideally both.

  URL / PDF / notes ──▶ ingest ──▶ distill ──▶ 📦 Skill Pack
                                                ├── SKILL.md         ◀── agents execute this
                                                ├── curriculum.json  ◀── tutor mode runs on this
                                                ├── GLOSSARY.md      ◀── plain-language definitions
                                                ├── graph.json       ◀── what the pack KNOWS: typed
                                                │                        entities + evidenced relations
                                                └── source.md        ◀── the cleaned material

Bonus: SKILL.md follows the open agent-skills format, so a pack you generate can be dropped straight into Claude Code, Claude.ai, or any agent that supports skills. programloader is, in effect, a course-to-skill compiler.

Try it in your browser — no install

programloader.github.io/programloader — paste any content, add your own API key (Anthropic, OpenAI, or any compatible endpoint), and build a Skill Pack right in the browser. Fully client-side: there is no server, and your key is used only for direct browser-to-provider calls. A Demo mode shows the mechanics with no key at all. (URL/YouTube/PDF ingestion and everything else below need the CLI.)

Quickstart

You need Python 3.10+ and an API key for any model provider — Anthropic, OpenAI, Groq, OpenRouter, Gemini, DeepSeek, Mistral… or a local Ollama with no key at all.

git clone https://github.com/programloader/programloader.git
cd programloader
pip install -e .

cp .env.example .env        # then paste your API key into .env

Build your first pack from any article, guide, PDF, notes file, or YouTube video (captions-first, timestamps preserved):

programloader load https://en.wikipedia.org/wiki/Compound_interest
# or
programloader load my-course-notes.pdf
# or
programloader load https://www.youtube.com/watch?v=VIDEO_ID

Merge a whole reading list into one pack — pass several sources and they compile together, each keeping its own provenance:

programloader load https://a.example/guide https://b.example/deep-dive notes.md

Learn it (interactive tutor, task by task — progress persists in the pack, so every session resumes where you left off):

programloader tutor compound-interest

Keep it — completed checkpoints become spaced-repetition cards (an SM-2-family scheduler, dependency-free; FSRS is the planned upgrade). When cards fall due:

programloader review compound-interest

Use it (the pack applies what it learned):

programloader run compound-interest "Compare investing 5000 rupees monthly vs a lump sum of 3 lakh for 10 years"

See your library (every pack you've built, with its source link, build date, and the model that built it):

programloader list

Search everything you've ever loaded (plain full-text across every pack's skill, glossary, curriculum, and source — no embeddings, nothing to go stale; packs/INDEX.md is the same library as one readable page):

programloader search "compound interest"

See what your library knows — as a knowledge graph:

programloader graph                        # concepts shared between packs
programloader graph "compound interest"   # look one concept up, 1-2 hops
programloader graph --pack my-pack        # one pack's full concept graph

Each pack built since v0.4 carries a concept graph (graph.json) when extraction succeeds — the graph node is optional, so a pack still builds without one (and load tells you when that happened). The graph holds typed entities and relations, each backed by a verbatim evidence quote from the source — a relation must be asserted by the text, not just co-occur, and the structure is validated in code both at build time and again on load. Cross-pack fusion (which concepts your packs share) is derived at read time by canonical name with provenance kept, so it can never corrupt a stored pack. Execute-mode sessions receive the graph as compact triples: grounded context, not raw dumps.

Duplicates are caught automatically: load keeps a registry (packs/index.json) of every source's origin and content hash, so loading the same material twice — even from a different URL — points you at the existing pack instead of paying to rebuild it. Use --force to rebuild deliberately.

Install a pack as a Claude skill, or share it:

programloader export compound-interest     # -> ~/.claude/skills/, ready to use
programloader publish compound-interest    # -> dist/: a GitHub-ready skill folder
                                           #    (npx skills add <owner>/<repo>)
                                           #    + a single-file "idea card"

Exports follow the agent-skills layout with progressive disclosure: a lean SKILL.md up front, glossary/curriculum/concept-graph under references/ loaded on demand. The raw source stays out of bundles by default — only publish packs built from openly licensed material.

Teach it to improve itself

programloader evolve https://example.com/guide-to-loop-engineering
programloader self

evolve is the self-learning loop: programloader studies the source, installs the distilled skill into its own skill store (~/.programloader/selfskills), then re-reads its own codebase and drafts a concrete improvement proposal — new features, functions, options that the learned material justifies — into evolution/NNN-<pack>/PROPOSAL.md. Installed self-skills genuinely change behavior: every later run composes them in. self shows everything it has learned and proposed so far.

Gated auto-apply closes the loop with tests as the merge gate:

programloader apply 1            # proposal 1 -> code patch -> lint + FULL test
                                 #   suite in a sandbox copy; stays staged
programloader apply 1 --live     # gate passed? only then write the real tree

The patch is generated once, staged as patch.json (later runs — including --live — reuse it, so the patch you reviewed is exactly the patch that ships), applied to a sandbox copy of the repo, and the entire test suite must pass there before --live will touch anything real. Even then nothing is committed — review the diff and commit yourself.

Be clear about what the sandbox is: a scratch directory, not a security boundary. Running the gate executes the generated code (imports and tests) with your user privileges. Read PROPOSAL.md before apply, and treat apply like running any code a stranger handed you.

No terminal? Use the web app

pip install -e ".[web]"
streamlit run web/app.py

Three tabs: Load (paste a link or drop a file) → Learn (chat with your tutor) → Do (put the skill to work).

Try it without an API key

PROGRAMLOADER_MOCK=1 programloader load examples/sample-source.md

Mock mode runs the full pipeline with placeholder output so you can see the mechanics for free.

Built as a graph, not a chain

Distillation is a diamond: the four artifacts (curriculum, skill, glossary, concept graph) are independent, so their model calls run in parallel and merge at the pack writer. Add --review to load and an independent review node runs at the tail — a separate model call that judges each finished artifact against explicit criteria (never the raw source, so its context and its judgment stay clean) and records the verdict in pack.json; it can flag a weak pack but never block a build. Opt-in, because it adds model calls. This node was designed by programloader's own evolve loop and implemented after human review of its proposal — the loop working as intended. The curriculum passes through a code-level verification node with one bounded feedback-retry; a failed glossary degrades the build instead of killing it; malformed SKILL.md frontmatter is repaired by code, not by another model call. Set PROGRAMLOADER_FAST_MODEL to run the glossary node on a cheaper model. Tutor and execute sessions always know — and cite — which source each pack was distilled from and when.

Why this exists

Tools already exist for the two halves of this problem:

Docs → agent skill compilers exist, but they assume you live in a terminal.
Material → quizzes/summaries tools exist, but they stop before doing anything.

programloader is the bridge: learn → practice → execute, in one loop, packaged so a non-technical person can use it.

What it's good at (and honest limits)

Great for: articles, guides, documentation pages, text-heavy PDFs, your own notes — conceptual and procedural material.

Not (yet) for: videos without captions (transcribe first — a Whisper fallback is on the roadmap), scanned PDFs without OCR, paywalled pages, or material requiring hands-on tools the AI can't touch. Extraction quality depends on the source; garbage in, garbage pack out. And a Skill Pack is a distillation, not a replacement for deep expertise — verify important outputs.

Works with any model

programloader speaks two wire protocols — Anthropic's and OpenAI's — and since virtually every provider exposes an OpenAI-compatible endpoint, that covers the whole field. Three setups (see .env.example):

# A. Anthropic (default when its key is present)
ANTHROPIC_API_KEY=sk-ant-...

# B. OpenAI
OPENAI_API_KEY=sk-...

# C. Anything OpenAI-compatible: Groq, OpenRouter, Gemini, DeepSeek, Mistral, xAI...
PROGRAMLOADER_BASE_URL=https://api.groq.com/openai/v1
PROGRAMLOADER_API_KEY=gsk_...
PROGRAMLOADER_MODEL=llama-3.3-70b-versatile

# ...including a local Ollama, free, no key:
PROGRAMLOADER_BASE_URL=http://localhost:11434/v1
PROGRAMLOADER_MODEL=llama3.2

Configuration

Variable	What it does	Default
`ANTHROPIC_API_KEY` / `OPENAI_API_KEY`	Provider keys (keep them in `.env`, never commit them)	—
`PROGRAMLOADER_BASE_URL`	Any OpenAI-compatible endpoint	—
`PROGRAMLOADER_API_KEY`	Generic key for the chosen endpoint	—
`PROGRAMLOADER_PROVIDER`	Force `anthropic` or `openai` when auto-detection isn't enough	auto
`PROGRAMLOADER_MODEL`	Model to use	`claude-sonnet-4-6` / `gpt-4o`
`PROGRAMLOADER_FAST_MODEL`	Cheaper model for low-stakes pipeline nodes (glossary)	main model
`PROGRAMLOADER_HOME`	Where self-skills live	`~/.programloader`
`PROGRAMLOADER_MOCK`	`1` = run offline with placeholder output	off

Roadmap

Contributing

Issues and PRs welcome — see CONTRIBUTING.md. If you build a pack from a public source and it's good, we'd love to see it.

License

MIT — do anything, just keep the notice.