Book-to-Skill: The Open-Source Tool With 12,000+ GitHub Stars That Turns Any Technical Book Into an AI Agent Skill

Why Developers Are Obsessed With Book-to-Skill

You buy a great technical book. You read it cover to cover. Three months later, you can't remember if chapter 7 covered that one pattern you need right now.

The usual workarounds don't help:

• Search the PDF — you get a list of pages, not answers
• Ask your AI agent about the book — it either hallucinates or says it doesn't have the content
• Take notes as you read — you end up with a 200-line document you never open again

Book-to-skill, created by Virgilio Jr, solves this by turning the book into a structured skill your AI agent loads on demand. It follows the open Agent Skills standard, meaning a single install works across GitHub Copilot CLI, Amp, and Claude Code.

With over 12,256 GitHub stars, 1,389 forks, and 1,428 stars earned in a single day on GitHub Trending, book-to-skill has become one of the most talked-about developer tools of 2026. Let's break down why.

How Book-to-Skill Works (The 3-Step Process)

The workflow is remarkably elegant:

1. Point it at your source — run /book-to-skill ./my-book.pdf (or a folder, glob, or list of files)
2. It distills the book into a skill — extracting frameworks, decision rules, anti-patterns, and per-chapter files. Structure, not a summary.
3. Your agent loads it on demand — type /my-book replication and the agent reads the right chapter, answering from the real content with no hallucination.

The output is a complete skill directory:

File	Purpose	Size
SKILL.md	Core mental models + chapter index	~4,000 tokens
chapters/ch01-*.md	One file per chapter, loaded on-demand	~1,000 tokens each
glossary.md	Every key term, alphabetically sorted	~1,500 tokens
patterns.md	All techniques, algorithms, and design patterns	~2,000 tokens
cheatsheet.md	Decision tables and quick-reference rules	~1,000 tokens

Chapter files are loaded on-demand — they don't count against your token budget until you ask about that specific topic.

The Token Efficiency Breakthrough: 24×–51× Fewer Tokens

The killer feature isn't just organization — it's token efficiency. The project includes a benchmarking tool (tools/discovery_tax.py) that measures the actual token cost of answering a single targeted question from a book:

Book	Context Dump	Discovery Loop	Book-to-Skill	Savings
Think Python 2 (119K tokens)	119,264	12,152	~5,000	24× / 2.4×
Working Backwards (175K)	175,253	33,444	~5,000	35× / 6.7×
AI Engineering (256K)	256,287	77,866	~5,000	51× / 15.6×

The advantage scales with chapter size. Against a context-dump it's consistently 24–51× (and that cost recurs every turn). Against a one-time discovery loop, savings range from 2.4× on books with small chapters to 15.6× on those with large chapters.

The core insight: a PDF-reading agent doesn't just read — it navigates. Ask it one question and it fetches the table of contents, notices a term it can't define, pulls more pages, backtracks. Every hop lands in the conversation history and gets re-processed on every subsequent turn. Book-to-skill pays that navigation cost once, at compile time.

Beyond Books: What Else Can You Convert?

Despite the name, book-to-skill works on any structured prose. The same extraction pipeline applies to:

• Internal documentation — architecture decision records, runbooks, onboarding guides. Fold a whole docs/ folder into one skill and query it while you code.
• Brand & design systems — voice guidelines, tone-of-voice docs, component principles. Turn a brand book into a skill your team queries instead of skimming a 60-page PDF.
• Research clusters — a stack of papers plus your own notes, merged into a single unified skill and updated as new material lands.
• Specs & standards — RFCs, API contracts, compliance docs you reference but never memorize.

The rule of thumb: if you re-open a document often enough to wish you'd memorized it, it's a candidate.

Real-World Example: Converting "Designing Data-Intensive Applications"

Let's walk through a practical example using Martin Kleppmann's classic Designing Data-Intensive Applications (DDIA), one of the most recommended books in backend engineering:

# Step 1: Install the skill
git clone https://github.com/virgiliojr94/book-to-skill.git ~/.claude/skills/book-to-skill

# Step 2: Convert the book
/book-to-skill ~/books/ddia.pdf designing-data-intensive-apps

# Step 3: Use it while coding
/designing-data-intensive-apps
# → loads core mental models (~4K tokens)

/designing-data-intensive-apps replication
# → finds and explains the replication topic from the right chapter

/designing-data-intensive-apps ch05
# → dives into chapter 5 specifically

The extraction takes about $0.88 in API costs (on Claude Sonnet 4.5 at $3/$15 per MTok for a 244-page book) and produces a skill that loads only the relevant ~5,000 tokens per query instead of the full 119K tokens every turn.

For teams, this means every engineer gets instant access to the book's frameworks and patterns inside their coding workflow — no context switching, no PDF searching, no hallucinated answers.

Book-to-Skill vs. RAG: Key Differences

A common question: "Isn't this just RAG?" The answer is no, and the distinction matters:

RAG works at query time: chunk the book → embed everything → find similar vectors → inject into prompt. It's optimized for "find me the part that talks about X."

Book-to-skill works at compile time: one deep analysis run extracts the author's actual frameworks, names them, describes when to use each, and captures anti-patterns. The output is structure the author spent years building — not a similarity search over their sentences.

The decision framework:

• Wide and shallow — a library of dozens of books, "find the part that mentions X" → RAG wins
• Narrow and deep — one book or a tight cluster of related sources, frameworks you apply while working → book-to-skill wins

They're complementary, not competing: RAG indexes a shelf, book-to-skill masters a spine.

Supported Formats and Extraction Tools

Book-to-skill supports a wide range of input formats:

• PDF — via pdftotext (fast, text-heavy), Docling (technical books with code/tables), pypdf, or pdfminer.six
• EPUB — via ebooklib + beautifulsoup4 (best quality) or stdlib zipfile (always available)
• DOCX — via python-docx with stdlib ZIP/XML fallback
• HTML — via beautifulsoup4 with stdlib html.parser fallback
• RTF — via striprtf with regex fallback
• MOBI/AZW/AZW3 — via Calibre's ebook-convert
• TXT/Markdown/reStructuredText/AsciiDoc — built-in, no dependencies needed

The tool automatically detects whether your book is technical or text-heavy and picks the right extraction engine. A single bad source is skipped with a warning — the rest still process.

Key Benefits of Book-to-Skill

• 24–51× token savings per query compared to context-dumping the entire book
• Zero hallucination — answers come from the actual extracted text, grounded in your copy
• Cross-agent compatible — one install works for Claude Code, GitHub Copilot CLI, and Amp via the open Agent Skills standard
• Incremental updates — fold new material into an existing skill without re-processing everything
• Cost-effective — ~$1 per book conversion, saving thousands of dollars in recurring token costs
• Open source (MIT license) — fully auditable, community-driven, and free
• On-demand loading — only relevant chapters load, keeping context windows clean and focused
• Works beyond books — internal docs, research papers, specs, brand guidelines, and any structured prose

Getting Started in Under 5 Minutes

# For Claude Code:
git clone https://github.com/virgiliojr94/book-to-skill.git ~/.claude/skills/book-to-skill

# For GitHub Copilot CLI:
git clone https://github.com/virgiliojr94/book-to-skill.git ~/.copilot/skills/book-to-skill

# For Amp (or cross-agent):
git clone https://github.com/virgiliojr94/book-to-skill.git ~/.agents/skills/book-to-skill

# Or install just the CLI engine:
pip install "book-to-skill[pdf,epub,docx]"
book-to-skill --check  # see which extractors are available

Then convert any book:

/book-to-skill ~/books/my-book.pdf my-book-skill

# Process multiple sources into a unified skill:
/book-to-skill ~/papers/paper1.pdf ~/notes/export.txt unified-research

# Update an existing skill with new material:
/book-to-skill ~/articles/new-paper.pdf ~/.claude/skills/my-book-skill

Frequently Asked Questions

1. Can't I just dump the PDF into my AI agent's context?

You can, but every conversation will burn that token budget upfront. A 400-page book is ~200K tokens. With a skill, only the chapters relevant to your question load — typically ~4K core + ~1K per chapter. The rest stays on disk until you need it. The economics are about amortization: pasting the book pays the full token bill on every turn of every session, forever.

2. AI models have 1M-token context windows now — can't I just keep the whole book loaded?

A bigger window changes what fits, not what's smart. You still pay per token per call. Recall degrades with fill (the "lost in the middle" problem). And a full book in context is still raw text the model must re-parse every turn. A skill ships pre-extracted frameworks — reasoning, not retrieval. Use the big window for one-off passes; use a skill for knowledge you'll reach for repeatedly.

3. How much does it cost to convert a book?

Approximately $1 per book using Claude Sonnet 4.5 pricing ($3/$15 per MTok). A 244-page book costs ~$0.88, a 371-page book costs ~$0.96, and a 501-page book costs ~$1.23. This is a one-time cost — every future query loads only the relevant ~5,000 tokens instead of the full book.

4. Which AI coding agents does book-to-skill support?

Book-to-skill follows the open Agent Skills standard, so a single install works across GitHub Copilot CLI, Amp, and Claude Code. All three hosts read the same SKILL.md format, so your converted book skills are portable across tools.

5. What document formats does book-to-skill support?

PDF, EPUB, DOCX, TXT, Markdown, reStructuredText, AsciiDoc, HTML, RTF, and MOBI/AZW/AZW3. The tool automatically detects whether your book is technical or text-heavy and picks the right extraction engine. You can also process multiple formats together into a single unified skill.

6. Is this just RAG (Retrieval-Augmented Generation)?

No. RAG works at query time with vector similarity search — it finds chunks close to your query. Book-to-skill works at compile time, extracting the author's actual frameworks, decision rules, and mental models into structured, reusable knowledge. RAG is great for wide-and-shallow search across many books; book-to-skill is ideal for narrow-and-deep mastery of specific material.

7. Can I update a skill with new material later?

Yes. Book-to-skill supports incremental updates — you can fold new papers, articles, or chapters into an existing skill without re-processing everything from scratch. Just point it at the new source and the existing skill directory.