{"id":"b858493a-7cfc-4757-872a-eece63b358ac","slug":"programloader","kind":"skill","name":"programloader","summary":"Load any course, link, or PDF into an AI that learns it, teaches you, and executes it.","owner":"programloader","repoUrl":"https://github.com/programloader/programloader","license":"MIT","licenseTier":"permissive","trust":"community","stars":1,"match":null,"fewStars":true,"format":"skill","createdAt":"2026-07-24T05:10:15.000Z","addedAt":"2026-10-21T11:17:03.986Z","logoUrl":"https://avatars.githubusercontent.com/u/308621743?v=4","linkOnly":false,"collection":null,"skillPath":null,"categories":["files-documents"],"tags":["ai","claude","education","learning","python"],"runtime":"python","local":true,"cloudCapable":false,"cloudCapability":"unknown","cloudReadyOnPlatform":false,"needsApiKey":false,"reviewed":false,"syncedAt":"2026-10-26T03:59:17.810Z","sample":false,"url":"https://conduits.dev/tools/programloader","language":"Python","transports":["stdio"],"install":{"pypi":"programloader"},"requirements":{"env":[],"upstreamMayCharge":false},"tools":null,"readme":"# 🧠 programloader\n\n**Load any course, link, or PDF into an AI that learns it, teaches you, and then works with you.**\n\n> *\"I know kung fu.\" — Neo, after a program was loaded into his head.*\n\nThere 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:\n\n1. **Teach you** — a task-by-task curriculum with checkpoints, in plain language, built for people with zero technical background.\n2. **Work for you** — the same pack becomes an executable skill an AI applies to your actual goals.\n\nLearn it, or delegate it. Ideally both.\n\n```\n  URL / PDF / notes ──▶ ingest ──▶ distill ──▶ 📦 Skill Pack\n                                                ├── SKILL.md         ◀── agents execute this\n                                                ├── curriculum.json  ◀── tutor mode runs on this\n                                                ├── GLOSSARY.md      ◀── plain-language definitions\n                                                ├── graph.json       ◀── what the pack KNOWS: typed\n                                                │                        entities + evidenced relations\n                                                └── source.md        ◀── the cleaned material\n```\n\nBonus: `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**.\n\n---\n\n## Try it in your browser — no install\n\n**[programloader.github.io/programloader](https://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.)\n\n## Quickstart\n\nYou 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.\n\n```bash\ngit clone https://github.com/programloader/programloader.git\ncd programloader\npip install -e .\n\ncp .env.example .env        # then paste your API key into .env\n```\n\n**Build your first pack** from any article, guide, PDF, notes file, or YouTube video (captions-first, timestamps preserved):\n\n```bash\nprogramloader load https://en.wikipedia.org/wiki/Compound_interest\n# or\nprogramloader load my-course-notes.pdf\n# or\nprogramloader load https://www.youtube.com/watch?v=VIDEO_ID\n```\n\n**Merge a whole reading list into one pack** — pass several sources and they compile together, each keeping its own provenance:\n\n```bash\nprogramloader load https://a.example/guide https://b.example/deep-dive notes.md\n```\n\n**Learn it** (interactive tutor, task by task — progress persists in the pack, so every session resumes where you left off):\n\n```bash\nprogramloader tutor compound-interest\n```\n\n**Keep it** — completed checkpoints become spaced-repetition cards (an SM-2-family scheduler, dependency-free; FSRS is the planned upgrade). When cards fall due:\n\n```bash\nprogramloader review compound-interest\n```\n\n**Use it** (the pack applies what it learned):\n\n```bash\nprogramloader run compound-interest \"Compare investing 5000 rupees monthly vs a lump sum of 3 lakh for 10 years\"\n```\n\n**See your library** (every pack you've built, with its source link, build date, and the model that built it):\n\n```bash\nprogramloader list\n```\n\n**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):\n\n```bash\nprogramloader search \"compound interest\"\n```\n\n**See what your library knows — as a knowledge graph:**\n\n```bash\nprogramloader graph                        # concepts shared between packs\nprogramloader graph \"compound interest\"   # look one concept up, 1-2 hops\nprogramloader graph --pack my-pack        # one pack's full concept graph\n```\n\nEach 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.\n\nDuplicates 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.\n\n**Install a pack as a Claude skill, or share it:**\n\n```bash\nprogramloader export compound-interest     # -> ~/.claude/skills/, ready to use\nprogramloader publish compound-interest    # -> dist/: a GitHub-ready skill folder\n                                           #    (npx skills add <owner>/<repo>)\n                                           #    + a single-file \"idea card\"\n```\n\nExports 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.\n\n### Teach it to improve itself\n\n```bash\nprogramloader evolve https://example.com/guide-to-loop-engineering\nprogramloader self\n```\n\n`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.\n\n**Gated auto-apply** closes the loop with tests as the merge gate:\n\n```bash\nprogramloader apply 1            # proposal 1 -> code patch -> lint + FULL test\n                                 #   suite in a sandbox copy; stays staged\nprogramloader apply 1 --live     # gate passed? only then write the real tree\n```\n\nThe 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.\n\nBe 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.\n\n### No terminal? Use the web app\n\n```bash\npip install -e \".[web]\"\nstreamlit run web/app.py\n```\n\nThree tabs: **Load** (paste a link or drop a file) → **Learn** (chat with your tutor) → **Do** (put the skill to work).\n\n### Try it without an API key\n\n```bash\nPROGRAMLOADER_MOCK=1 programloader load examples/sample-source.md\n```\n\nMock mode runs the full pipeline with placeholder output so you can see the mechanics for free.\n\n---\n\n## Built as a graph, not a chain\n\nDistillation 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.\n\n## Why this exists\n\nTools already exist for the two halves of this problem:\n\n- **Docs → agent skill** compilers exist, but they assume you live in a terminal.\n- **Material → quizzes/summaries** tools exist, but they stop before *doing* anything.\n\nprogramloader is the bridge: **learn → practice → execute**, in one loop, packaged so a non-technical person can use it.\n\n## What it's good at (and honest limits)\n\n**Great for:** articles, guides, documentation pages, text-heavy PDFs, your own notes — conceptual and procedural material.\n\n**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.\n\n## Works with any model\n\nprogramloader 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`):\n\n```bash\n# A. Anthropic (default when its key is present)\nANTHROPIC_API_KEY=sk-ant-...\n\n# B. OpenAI\nOPENAI_API_KEY=sk-...\n\n# C. Anything OpenAI-compatible: Groq, OpenRouter, Gemini, DeepSeek, Mistral, xAI...\nPROGRAMLOADER_BASE_URL=https://api.groq.com/openai/v1\nPROGRAMLOADER_API_KEY=gsk_...\nPROGRAMLOADER_MODEL=llama-3.3-70b-versatile\n\n# ...including a local Ollama, free, no key:\nPROGRAMLOADER_BASE_URL=http://localhost:11434/v1\nPROGRAMLOADER_MODEL=llama3.2\n```\n\n## Configuration\n\n| Variable | What it does | Default |\n|---|---|---|\n| `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` | Provider keys (keep them in `.env`, never commit them) | — |\n| `PROGRAMLOADER_BASE_URL` | Any OpenAI-compatible endpoint | — |\n| `PROGRAMLOADER_API_KEY` | Generic key for the chosen endpoint | — |\n| `PROGRAMLOADER_PROVIDER` | Force `anthropic` or `openai` when auto-detection isn't enough | auto |\n| `PROGRAMLOADER_MODEL` | Model to use | `claude-sonnet-4-6` / `gpt-4o` |\n| `PROGRAMLOADER_FAST_MODEL` | Cheaper model for low-stakes pipeline nodes (glossary) | main model |\n| `PROGRAMLOADER_HOME` | Where self-skills live | `~/.programloader` |\n| `PROGRAMLOADER_MOCK` | `1` = run offline with placeholder output | off |\n\n## Roadmap\n\n- [x] Any-model support (Anthropic, OpenAI, and every OpenAI-compatible endpoint) — v0.2\n- [x] Pack library with dedupe (`packs/index.json`, `--force`) — v0.2\n- [x] Self-learning loop (`evolve` + self-skills + evolution proposals) — v0.2\n- [x] Parallel graph distillation with verification + error isolation — v0.3\n- [x] Library full-text search (`search`, `packs/INDEX.md`) + source citations — v0.3\n- [x] Concept graphs per pack + cross-pack fusion (`graph`) + graph-grounded execute — v0.4\n- [x] YouTube/video transcript ingestion (captions-first, timestamped) — v0.5\n- [x] Multi-source packs (`load url1 url2 notes.md`) — v0.5\n- [x] Progress tracking + spaced-repetition review (`review`, resumable tutor) — v0.5\n- [x] One-click export to installed Claude skills (`export`) — v0.5\n- [x] Gated auto-apply for evolution proposals (`apply`, tests as the merge gate) — v0.5\n- [x] Pack sharing (`publish`: skills.sh-ready bundle + idea file) — v0.5\n- [x] Independent artifact review node (`load --review`) — v0.6, *proposed by programloader's own evolve loop*\n- [ ] FSRS scheduler upgrade for review mode\n- [ ] Whisper fallback for caption-less videos\n- [ ] Multi-source packs in the web app\n\n## Contributing\n\nIssues and PRs welcome — see [CONTRIBUTING.md](CONTRIBUTING.md). If you build a pack from a public source and it's good, we'd love to see it.\n\n## License\n\n[MIT](LICENSE) — do anything, just keep the notice.\n"}