linkflow-content

Tuesday, 4:40 pm. The client wants to see the redesigned marketing site by Wednesday morning. The real copy is still being argued over word by word in a Google Doc, so every heading and paragraph in my HTML prototype is empty. This is a normal Tuesday, and the fix is filler text: obviously-not-final copy in believable paragraph shapes, so stakeholders argue about spacing instead of wording. Hand-typing fake Latin into a dozen <p> tags is a waste of an evening, so here are the three ways I actually reach for, from most to least control.

Method 1: a small Python script

When I need lots of filler with a consistent shape, I keep a 20-line script around. Python 3.11.1, standard library only:

# fill.py — generate lorem ipsum paragraphs
import random, sys

WORDS = ("lorem ipsum dolor sit amet consectetur adipiscing elit sed do "
         "eiusmod tempor incididunt ut labore et dolore magna aliqua").split()

rng = random.Random(20261119)   # fixed seed: same output on every run

def sentence():
    words = rng.choices(WORDS, k=rng.randint(8, 15))
    s = " ".join(words)
    return s.capitalize() + "."

def paragraph():
    return " ".join(sentence() for _ in range(rng.randint(3, 6)))

if __name__ == "__main__":
    count = int(sys.argv[1]) if len(sys.argv) > 1 else 3
    print("\n\n".join(paragraph() for _ in range(count)))

python3 fill.py 4 > copy.txt writes four paragraphs and takes two minutes to adapt. The seed matters more than it sounds: when a screenshot test compares renders between runs, identical filler is one less variable to debug. I construct the generator with random.Random(seed) rather than calling random.seed() globally, which the random module docs recommend when you don’t want to affect other code importing random.

The tradeoff is repetition. Twenty-two words start recycling fast; by the fifth paragraph “magna aliqua” shows up three times on one screen, and reviewers do notice that.

Method 2: curl, straight from the source

When I don’t want a script file at all, lipsum.com — the site that popularized this particular flavor of scrambled Cicero — offers a JSON feed:

curl -s "https://lipsum.com/feed/json?amount=3&what=paras&start-with-lorem=1" \
  | python3 -c "import json,sys; print(json.load(sys.stdin)['feed']['lipsum'])"

This returns the classic opening (“Lorem ipsum dolor sit amet, consectetur adipiscing elit…”) and needs an internet connection. It’s my choice when the mockup should look like every other lorem-based layout, which occasionally matters: some clients equate the familiar version with “done properly”. The downside is the third-party dependency. If the feed is slow at 5 pm on a deadline, I fall back to Method 1 and nobody can tell the difference.

Method 3: the browser, no terminal

Half of my filler requests happen on machines where I have no shell: the client’s laptop, a borrowed MacBook, or while I’m knee-deep in CSS and don’t want to context-switch to a terminal. For those moments a free online lorem ipsum generator beats both methods above. Pick a paragraph count, click generate, copy, paste into the prototype. Nothing installs, and since the whole thing runs client-side, nothing I paste near it leaves the browser — worth caring about when the machine belongs to someone else’s IT department.

I also open this browser-based generator when I need a single long paragraph to stress-test a hero section, or when I want to hand a non-technical PM a block of text they can drop into the CMS themselves. No npm, no venv, no ten-minute explanation of where the words came from. It has quietly replaced the other two methods on days when the deadline is measured in hours rather than days.

Three pitfalls that cost me real time

1. Two PyPI packages, one name. There is a package called lorem and another called loremipsum, and their APIs have nothing in common. A snippet from a tutorial written for one, run against the other, fails like this:

>>> import lorem
>>> lorem.get_paragraphs(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: module 'lorem' has no attribute 'get_paragraphs'

The lorem package (0.1.1) exposes paragraph(), sentence() and word(). The loremipsum package exposes a Generator class. Run pip show lorem before you copy anyone’s snippet, mine included.

2. Random filler breaks screenshot tests. I once wired a generator straight into a Next.js dev page and Playwright’s toHaveScreenshot() failed on every CI run, each time with a different pixel count, because random words changed the line wrapping. The fix that stuck: generate once, commit the output as a fixture, and treat it like any other test asset. If you must generate at runtime, seed the RNG exactly like Method 1 does.

3. Filler escaping into production. A teammate pasted my copy.txt into the CMS “just to test the workflow”, and two weeks later a customer emailed quoting “sed do eiusmod tempor” from the pricing FAQ. Now I grep the build output before shipping:

grep -rEn "eiusmod|adipiscing|consectetur" dist/

Empty output, then deploy. One check, learned the expensive way. The customer, to her credit, was polite about it. I was not polite to myself about it.

Quick recap

Method Best for Depends on
Python script repeatable, shaped filler; CI-safe with a fixed seed Python 3.11.1, stdlib
lipsum.com feed the classic Cicero text in one command internet access
Lorem ipsum generator, in the browser no terminal, no install, fast one-off any modern browser

Filler text is never the interesting part of a project, which is exactly why the workflow around it should be boring and fast. Pick whichever of the three fits the machine you’re sitting at, and get back to the layout.

More free browser-based utilities at utilvy.com.