I did something like this once already, turning scanned sermon pages into a searchable PDF. That project made an existing book easier to search. This one is different: I’m not searching a book, I’m deciding what belongs in one — turning years of sermon transcripts into a small printed booklet of verses worth memorizing.

The Need: A Sermon Doesn’t Split Cleanly Into Verses

I have transcripts of a few hundred sermons from a pastor whose talks I’ve been transcribing and correcting for years, and I wanted to turn them into a different kind of book: not a record of what was said, but a short list of verses worth carrying around in your head. The reason is a familiar one to anyone who grew up in church — a verse you’ve actually memorized becomes the sword of the Spirit, something to meditate on, something to reach for when you’re tempted. A verse you’d have to go look up doesn’t work the same way.

My first plan was to organize the whole book around Scripture: read a sermon start to finish, and file every paragraph under whichever verse it belonged to. It sounded right — these are Scripture-centered sermons, after all. It didn’t survive contact with the actual transcripts. A sermon doesn’t split cleanly into verse-sized pieces. There’s a personal story here, a tangent there, a closing thought that touches three different verses at once. Forcing every sentence into a “which verse does this belong to” bucket turned editing into a puzzle with no correct answer, and it still wasn’t solving the actual problem — nothing in that process was choosing verses for memorization. It was just reorganizing the sermon.

💬 Prompt that worked “I’ve been trying to organize these sermons into a book built around Scripture, but I keep running into a contradiction. The sermons are Scripture-centered, sure, but the actual content doesn’t split cleanly verse by verse — so ‘organize everything around Scripture’ turns out to be an impossible goal. And the real reason I wanted a Scripture-centered book in the first place was to memorize verses I can use every day: as the sword of the Spirit, as something to meditate on, as a shield against temptation. But nothing in the process was actually selecting verses for memorization. So I’m changing the goal. I want verses that are easy to memorize — sermons that focus mainly on a single verse, with two verses allowed at most — pulled out, organized, and explained with real warmth, heart to heart.”

That message threw out the “cover every sentence” rule entirely. The new goal: find the one or two verses each sermon actually camps on, quote them exactly, and pair each one with the pastor’s own explanation of why it matters — not a summary of the sermon.

The Proof: A Real Booklet, Checked Page by Page

For the first sermon I reworked this way, the sermon settled into 15 verses instead of the roughly 30 loosely-grouped sections my first attempt had produced. Each one became an entry like this (verse text below is the public-domain KJV, standing in for the Korean original):

6. Genesis 18:22 — On staying in someone’s presence

“And Abraham stood yet before the LORD.”

— then a paragraph, in the pastor’s own words, kept close to how he actually said it, on what it means that Abraham was still standing there after everyone else had already left.

That whole list — reference, exact verse, the pastor’s own reflection — turns into a print-ready PDF: a cover page, a one-page summary of every verse in the booklet, and then one typeset page per verse with the quote in a highlighted block and the reflection underneath. I checked the actual output, not just the numbers reportlab reported back:

  • Mirrored margins for binding. Right-hand and left-hand pages have their wide margin on opposite sides, the way a bound book needs it. I rendered pages 3 and 4 to PNG and looked at them side by side to confirm the mirroring was really happening, not just correct in the code.
  • A4 or A5, actual size, no print-dialog guesswork. Both are built at their real physical dimensions, so “print at 100%” just works — no relying on a printer’s “fit to page” setting, which is what caused the lopsided margins I noticed in an earlier version.
  • No page numbers, on purpose. With a few hundred sermons eventually going into one bound book, a page-numbered table of contents in every individual episode file made no sense — that numbering has to happen once, across the whole finished book, not per file.
  • Korean serif for Scripture, sans-serif for headings — two font families embedded straight from Windows’ own font folder, so nothing extra to install.

Total cost: $0. Python, reportlab, and PyMuPDF (for checking my own output) all ran locally; the only fonts used were already on the machine.

The Story: Two Earlier Attempts That Lost the Sermon

This wasn’t the first try. Twice before, I’d used a general-purpose AI chatbot for the same job, telling it to pull out the parts of the sermon connected to a Bible verse. Both times, whole stretches of the sermon went missing — a personal story used to explain a hard idea, an aside about something in the pastor’s own life, the closing thought before the closing hymn. The tool had quietly decided anything without a verse attached wasn’t worth keeping. Comparing its output to the original transcript, I could see exactly where the cuts were, in some cases entire paragraphs simply gone.

So the working rule became: read the transcript straight through, start to finish, and account for every sentence somewhere — no skipping ahead to “the parts with verses in them.” That fixed the missing-content problem, but it created a new one: forcing every sentence into a verse-shaped bucket, even the ones that were just a story, or a closing thought, or a hello to the room. The book grew to match the sermon’s own length, which is the opposite of what a memorization booklet needs to be.

The fix wasn’t a better extraction technique. It was admitting the goal itself was wrong — going back to why I wanted verses organized by Scripture in the first place, which was never “capture everything,” it was “give me something short enough to actually memorize.” Once that was the stated goal, the editing rule became simple: keep the sermon’s own center of gravity — the verse (or two, at most) it spends real time on — and let everything else, however good, stay in the transcript instead of the book.

The How: A Plain-Text Draft In, a Bound Book Out

The pipeline has two stages. First, working from the transcript, I write a plain .txt file with one predictable block per verse — a heading line, the exact verse quote, and the reflection paragraph. Second, a Python script (reportlab) turns that text file into the finished PDF. Keeping the content in plain text instead of writing it straight into layout code means the same script runs unchanged for the next sermon, and the one after that.

The one piece worth explaining is the mirrored margins, because it’s not obvious how to do it without manually tracking which page number is coming next:

🗂 Claude.md Rule To mirror margins for a duplex-printed, bound booklet in reportlab: build two PageTemplates — one with the wide margin on the left (right-hand pages), one with it on the right (left-hand pages) — and link them with autoNextPageTemplate pointing at each other. reportlab then alternates them automatically as pages fill up; there’s no need to track odd/even yourself or insert a NextPageTemplate flowable by hand at every page break. Verified by rendering actual pages to PNG with PyMuPDF and checking the margins were really mirrored, not just correct-looking in the frame coordinates.

A few other decisions that shaped the file:

  1. A page-number-free summary page, not a table of contents. The first draft had a normal table of contents with page numbers — which looks wrong once you remember this file is one of a few hundred that’ll eventually sit inside a single bound book, numbered once, from the front. It became a plain list instead: verse reference and exact quote, in order, no page numbers anywhere in the file.
  2. A4 and A5 as two real page-size presets, not one size scaled at print time. A printer’s “fit to page” setting is exactly the kind of thing that goes wrong quietly — mine had been anchoring the smaller page to a corner instead of centering it, which is what made the margins look uneven in the first place.
  3. The scripture text always comes from a verified Bible data file, looked up by book, chapter, and verse — never typed by hand from what the pastor said out loud, since a spoken quotation can drift slightly from the exact wording.

The Honest Limit

The booklet only exists for one sermon so far. The real test is whether the same script, unchanged, holds up cleanly across a few hundred more — different sermon lengths, different numbers of verses per talk, the odd sermon that resists landing on just one or two. I won’t know that until I’ve run it a few dozen more times.

Key Takeaways

  • A sermon doesn’t divide cleanly by verse — trying to force full coverage around Scripture produces either missing content (skip anything without a verse) or bloated content (force every sentence into some verse’s bucket).
  • The fix wasn’t a smarter extraction rule. It was going back to the actual reason for the project — memorization — and selecting for that directly, instead of for completeness.
  • Mirrored binding margins in reportlab: two PageTemplates with swapped inner/outer margins, linked by autoNextPageTemplate, alternate automatically.
  • Build at the printer’s actual page size (A4 or A5) instead of relying on “fit to page” — it removes a whole class of margin bugs.
  • If a file is one of many that’ll be bound into a single book later, don’t number its pages — that has to happen once, across the finished book.
  • Total cost: $0.