Vibe Coding Forem: Mw234324324324Booklet AI Writer

How We Built an AI Pipeline That Turns Prompts into Print-Ready Booklets

Mw234324324324Booklet AI Writer — Mon, 27 Apr 2026 10:34:30 +0000

How We Built an AI Pipeline That Turns Prompts into Print-Ready Booklets

When we set out to build Booklet AI, the brief was deceptively simple: "Type a topic, get back a print-ready booklet — magazine layout, professional typography, downloadable as PDF."

In practice, that one sentence hides a small army of problems: prompt-to-content generation, layout decisions across variable content lengths, image sourcing, font fallbacks, headless rendering, PDF export, and an interactive editor sitting on top of it all. This post walks through the architecture we landed on, the parts that surprised us, and the pieces we'd build differently next time.

The shape of the problem

A "booklet" is not a slide deck and not a long-form article — it's somewhere in between. Think 8–24 A4 pages, magazine-style spreads, with a cover, table of contents, alternating image/text layouts, and pull quotes. Users feed in one of three input types:

A free-text prompt ("Make me a 12-page booklet about regenerative agriculture")
A PDF or DOCX upload (turn this report into a magazine)
A URL (turn this article into a designed spread)

The output is an HTML document that renders cleanly to PDF and is also editable inside a web editor.

High-level pipeline

User input
   │
   ▼
[Content extraction]   ← PDFBox / readability / GPT-4 cleanup
   │
   ▼
[Outline generation]   ← LLM, structured JSON output
   │
   ▼
[Per-page content gen] ← LLM with section-aware prompts
   │
   ▼
[Layout assignment]    ← rule-based template picker
   │
   ▼
[Image generation]     ← Replicate / DALL·E, async
   │
   ▼
[HTML assembly]        ← server-side templating (Thymeleaf)
   │
   ▼
[Headless render]      ← Puppeteer
   │
   ▼
[PDF export]           ← Puppeteer pdf() + post-processing

Each stage is its own service call, queued and retryable. The whole pipeline takes 30–90 seconds for a typical 12-page booklet.

Stage 1: Content extraction

For PDF and DOCX inputs, we tried three approaches before landing on the one we ship:

Pure PDFBox text extraction — fast but loses heading structure and reading order on multi-column layouts.
OCR-first (Tesseract) — slow and overkill for digital PDFs.
PDFBox + GPT cleanup — extract raw text, then run a small LLM call to restore structure ("split this into sections with heading levels"). This is what we ended up shipping. ~5–10s for a 30-page report.

For URL inputs, Mozilla's Readability.js wrapped in a tiny Node service does almost all the work.

The lesson: don't over-engineer extraction. The downstream LLM is going to rewrite this content anyway. You just need enough signal — headings, paragraphs, reading order — for the outline step to make good decisions.

Stage 2: Outline generation

This is where the pipeline either goes well or goes off the rails. The outline determines how many pages, what each page is about, and what kind of layout each page wants. We iterated a lot here.

The prompt enforces a structured JSON schema:

{
  "title": "...",
  "subtitle": "...",
  "pages": [
    {
      "page_number": 1,
      "type": "cover" | "toc" | "section_intro" | "content" | "quote" | "back",
      "heading": "...",
      "key_points": ["...", "..."],
      "suggested_layout": "image_left" | "image_right" | "full_bleed" | "two_column",
      "image_prompt": "..." 
    }
  ]
}

Three things made this reliable:

JSON schema validation in the prompt — we paste a small JSON Schema and ask the model to conform. Reject + retry on parse failure.
Length budgeting upfront — we tell the model the target page count and word budget per page. Without this, models love to write 800 words for a page that only fits 180.
Layout suggestions generated alongside content — letting the model pick suggested_layout based on the content type produces better-looking books than picking layouts post-hoc.

Stage 3: Per-page content generation

The outline is cheap to generate (one call). Per-page content is where the cost lives. We learned to:

Generate pages in parallel — pages are independent given the outline, so we fire 6–8 LLM calls concurrently with a small connection pool.
Pin the model per booklet — switching models mid-booklet creates jarring tone shifts. We pick one model per generation job and stick with it.
Keep the outline in every prompt's system message — gives each page-level call awareness of what comes before and after, which prevents repetition.

Streaming responses don't help here — the user is waiting on the entire booklet, not page-by-page text appearing.

Stage 4: Image generation (the surprising bottleneck)

Images turned out to be the slowest, flakiest stage. Why:

Image gen APIs have wildly different latencies (Replicate model cold starts can be 30s+).
Failure rates are non-trivial (~3–5% per image), and a 12-page booklet needs 6–10 images.
Quality is inconsistent on style adherence — "magazine editorial photography" means different things to different models.

What worked:

Async-from-the-start — image gen runs in parallel with HTML assembly. We render the booklet with placeholder gradients first; images stream in as they're ready.
Per-image timeout + fallback — if image gen for page 7 fails or takes >40s, we substitute a curated stock image keyed off the page's image_prompt. Better a relevant photograph than a broken booklet.
Cropping happens server-side — we ask for square (1024x1024) images and crop to the layout's aspect ratio in the same service that handles the upload to OSS. This avoids round-trips and lets us cache aggressively.

Stage 5: HTML assembly

The booklet template is server-rendered HTML with a CSS-paged-media stylesheet. Each layout type (image_left, image_right, etc.) is a small Thymeleaf fragment composed into a full page.

Key decisions:

A4 dimensions hardcoded into CSS (@page { size: A4; } plus width: 210mm; height: 297mm on each page wrapper). Makes the PDF predictable.
Print-aware CSS — fonts loaded via @font-face, page breaks via break-after: page, no position: fixed (Puppeteer pdf() handles it inconsistently across pages).
One HTML document per booklet, not one per page — easier to navigate in the editor, easier to render in one Puppeteer pass.

Stage 6: Headless render + PDF export

Puppeteer is the unsung hero here. The export endpoint:

const browser = await puppeteer.launch({
  args: ['--no-sandbox', '--disable-setuid-sandbox', '--font-render-hinting=none'],
});
const page = await browser.newPage();
await page.goto(bookletUrl, { waitUntil: 'networkidle0', timeout: 60_000 });
await page.evaluateHandle('document.fonts.ready');

const pdf = await page.pdf({
  format: 'A4',
  printBackground: true,
  preferCSSPageSize: true,
  margin: { top: 0, right: 0, bottom: 0, left: 0 },
});

await browser.close();
return pdf;

Things we learned the hard way:

document.fonts.ready matters. Without it, you ship PDFs with fallback fonts on the first page.
networkidle0 is not enough for image-heavy pages — we explicitly await Promise.all(images.map(img => img.complete || new Promise(r => img.onload = r))) before calling pdf().
preferCSSPageSize: true is the difference between "the PDF respects my A4 layout" and "Chrome guesses the page size".
--font-render-hinting=none produces cleaner text in PDFs across font weights.

Post-processing (page numbering, bookmarks, link annotations) we do with pdf-lib after Puppeteer hands back the buffer.

What we'd build differently

Three things, in priority order:

A real document model, not HTML-as-source-of-truth. Storing the booklet as JSON (structured content + layout decisions) and rendering to HTML on demand would make collaboration features and version diffing dramatically simpler. We're paying interest on this every sprint.
A proper image queue with priority. Right now image gen is a fire-and-forget per booklet. Sharing one queue across all jobs with priority tiers (paid users first, retries scheduled) would smooth out tail latency.
Server-side font subsetting. Booklets ship with the full webfont files embedded in the PDF. For a 12-page booklet using one weight of one font, that's hundreds of KB of unused glyphs. fontTools subsetting in the export step would cut PDF size by 60–80%.

Try it

If you want to see the output of this pipeline, the live tool is at bookletai.org — paste a topic or upload a PDF and you get a booklet in about a minute. The first one is free; we'd love feedback on the layout decisions, especially what the AI gets wrong.

This is a write-up of decisions made on the Booklet AI team. Questions, critiques, or "you should have done X instead" comments very welcome.

How AI Turns a One-Line Prompt Into a Full A4 Booklet

Mw234324324324Booklet AI Writer — Sat, 25 Apr 2026 01:39:00 +0000

A few months ago I wanted a 12-page printable guide for a workshop. The choices were ugly: open InDesign and lose two days, drop content into Canva and fight templates, or paste everything into ChatGPT and copy the result back into Word.

That gap is what got me building Booklet AI. The idea is simple: describe what you want in chat, the AI asks clarifying questions about audience and tone, gathers material from the web and any files you upload, generates an outline you can tweak, then writes and lays out 8 to 15 A4 pages with images and text mixed in a magazine-style flow.

Three things I learned while building it:

Layout is the hard part, not text. Anyone can produce 1500 words; making them fit a fixed A4 grid with figures, captions, and section breaks is where most AI tools quit. Generating each page as a self-contained HTML block instead of streaming Markdown made the layout problem tractable.
Source quality beats prompt cleverness. Letting users upload their own PDF, Word, or image and feeding that into the model gave a much bigger lift than tweaking system prompts.
Edit modes matter. Two flows on every page (natural-language AI Edit and visual drag Quick Edit) cover both kinds of users — those who can describe what they want and those who only know it when they see it.

Free to try at bookletai.org. Curious to hear what people use it for.

BookletAI for turning long content into shareable booklet pages

Mw234324324324Booklet AI Writer — Fri, 17 Apr 2026 15:13:30 +0000

BookletAI helps turn long docs, articles, and reports into clean, shareable booklet pages.

https://bookletai.org

From Research Chat to a Shareable Booklet in Minutes

Mw234324324324Booklet AI Writer — Fri, 27 Mar 2026 07:51:37 +0000

I've been experimenting with a workflow for turning messy research into something a client or teammate can actually read.

The result is Booklet AI: https://bookletai.org

It takes a topic in plain language, searches the web for supporting material, builds a page-by-page outline, and turns the result into a polished A4 booklet you can preview, share, and export.

What it does well:

asks follow-up questions before generating
gathers source material from the web
creates a structured outline first
generates multi-page visual booklet layouts instead of a long wall of text
lets you edit one page at a time
exports to shareable HTML and PDF

A few use cases I think are interesting for builders:

product explainers
training handbooks
research summaries
proposal-style docs for demos or sales

If you are building AI products for communication rather than just raw text output, I'd love feedback on the workflow and where this could fit into your stack.

Try it here: https://bookletai.org

Create Professional Booklets in Minutes with Booklet AI

Mw234324324324Booklet AI Writer — Wed, 25 Mar 2026 00:23:19 +0000

If you've ever needed to create a professional-looking booklet, brochure, or presentation quickly, you know how time-consuming the design process can be. Between finding the right template, gathering research, writing content, and arranging layouts — it can take hours or even days.That's exactly the problem Booklet AI was built to solve.## What is Booklet AI?Booklet AI is an AI-powered tool that creates professional booklets through conversation. You simply describe what you need, and the AI takes care of everything: research, outline, design, and content generation.## How It Works1. Describe your topic — Just tell the AI what you need in plain language2. AI confirms requirements — It asks about your audience, purpose, and style preferences3. Automatic research — The AI searches the web and scrapes 3-5 high-quality sources4. Outline preview — See the planned structure before generation begins5. Page-by-page generation — Each A4 page is generated with text and images, displayed in real-time6. Edit and share — Fine-tune any page, then share via link or download as HTML/PDF## Key Features- Fixed A4 layout (794×1123 px) with magazine-style formatting- Real images + AI-generated images for each page- Single-page editing — modify one page without affecting others- Shareable links — no login required for viewers- Export to PDF via Playwright rendering## Use Cases- Product brochures for sales teams- Training manuals for HR- Research summaries and industry reports- Pitch decks and proposals- Course materials for educators## Why It's DifferentUnlike regular AI writing tools that output plain text, Booklet AI delivers ready-to-use, print-quality A4 pages with proper layouts. No design skills required — just describe what you want.Check it out at bookletai.org and create your first professional booklet in minutes.