Skip to main content
skill CX Codex

lorem-ipsum — Claude Code skill: what it does, how to install

Generates structured lorem ipsum filler text using a bundled Python script. Helps populate mockups and test files with precise word, character, or token counts.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add intellectronica/agent-skills --skill lorem-ipsum -a claude-code
Open on GitHub

What lorem-ipsum does

This skill forces the agent to generate placeholder text through scripts/generate.py instead of writing pseudo-Latin inline. Every output element, including headings, bullet lists, and table cells, is strictly lorem ipsum. This keeps layout mockups clean and free of accidental English words.

Running the generator requires uv. The script provides fine-grained sizing flags: paragraph counts (--paragraphs, default 3), sentences per paragraph (--sentences, default 5), raw word targets, exact character counts, or estimated LLM tokens. The --continuous flag produces unbroken text without paragraph splits.

Output formats include markdown by default, HTML, or plain text via --format. Using --mixed generates multi-section documents with varied structures like nested h3 headings and numbered lists. Results can be written straight to disk with --output or piped into tools like pbcopy.

What it helps with

  • fill interface layouts with structured sections, headings, and lists
  • generate placeholder copy constrained to exact character or token limits
  • export dummy text directly to HTML or Markdown files
  • build mock multi-section documents with varied list and heading structures

Example prompts for the agent

  • Generate 5 paragraphs of lorem ipsum with 4 sentences each
  • Create lorem ipsum with 3 headings and numbered lists in HTML format
  • Generate 500 characters of lorem ipsum and save to ~/Desktop/placeholder.txt

How to install lorem-ipsum

1Skills CLI (Vercel)

npx skills add intellectronica/agent-skills --skill lorem-ipsum -a claude-code

2Manually: put the files in place

~/.claude/skills/lorem-ipsum/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/lorem-ipsum/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about lorem-ipsum

How to install lorem-ipsum in Claude Code?

Run npx skills add intellectronica/agent-skills --skill lorem-ipsum -a claude-code in your terminal to install the skill.

What does the lorem-ipsum skill do?

It executes the bundled scripts/generate.py script to produce authentic placeholder text. All structural elements, including headings and list items, are rendered entirely in lorem ipsum.

What dependencies are required to run this skill?

The generator executes via uv run scripts/generate.py. You need uv installed in your environment so Claude Code can run the script.

Source text

SKILL.md · CC0-1.0
---
name: lorem-ipsum
description: Generate lorem ipsum placeholder text. This skill should be used when users ask to generate lorem ipsum content, placeholder text, dummy text, or filler text. Supports various structures including plain paragraphs, headings with sections, lists, and continuous text. Output can be saved to a file or used directly as requested by the user.
---

# Lorem Ipsum Generator

## Overview

Generate lorem ipsum placeholder text using the bundled generator script. **Always use the script** to generate content rather than writing lorem ipsum directly.

**Critical requirement**: ALL text in the generated output must be lorem ipsum, including headings, bullet points, list items, table cells, and any other textual elements.

## Generator Script

Use `scripts/generate.py` to produce lorem ipsum content. The script handles all text generation to ensure consistent, authentic lorem ipsum output.

### Basic Usage

```bash
# Generate 3 paragraphs (default)
uv run scripts/generate.py

# Generate 5 paragraphs with 4 sentences each
uv run scripts/generate.py --paragraphs 5 --sentences 4

# Generate approximately 500 words
uv run scripts/generate.py --words 500

# Generate exactly 1000 characters
uv run scripts/generate.py --characters 1000

# Generate approximately 200 LLM tokens (~800 characters)
uv run scripts/generate.py --tokens 200

# Continuous text without paragraph breaks
uv run scripts/generate.py --paragraphs 4 --continuous
```

### Structured Content

```bash
# 3 sections with headings and 2 paragraphs each
uv run scripts/generate.py --headings 3 --paragraphs 6

# 4 sections with bullet points (5 bullets each)
uv run scripts/generate.py --headings 4 --bullets 5

# Numbered lists instead of bullets
uv run scripts/generate.py --headings 3 --bullets 6 --numbered

# Realistic mixed document with 5 sections (varied content types)
uv run scripts/generate.py --mixed 5
```

The `--mixed` option generates realistic documents with varied structure per section:
- Some sections have paragraphs only
- Some have bullet or numbered lists
- Some have subheadings (h3) with nested content
- Some combine paragraphs with lists

### Output Options

```bash
# Write to file
uv run scripts/generate.py --paragraphs 3 --output ~/Desktop/placeholder.txt

# HTML format
uv run scripts/generate.py --headings 2 --format html --output page.html

# Plain text (no markdown formatting)
uv run scripts/generate.py --format text

# Copy to clipboard
uv run scripts/generate.py --words 200 | pbcopy
```

### All Options

| Option | Description |
|--------|-------------|
| `--paragraphs N` | Number of paragraphs (default: 3) |
| `--sentences N` | Sentences per paragraph (default: 5) |
| `--words N` | Approximate total word count |
| `--characters N` | Exact character count (truncates to match) |
| `--tokens N` | Estimated LLM token count (~4 chars/token) |
| `--continuous` | Output without paragraph breaks |
| `--headings N` | Number of sections with headings |
| `--bullets N` | Bullet points per section |
| `--numbered` | Use numbered lists instead of bullets |
| `--mixed N` | Realistic document with N sections, varied content types |
| `--output FILE` | Write to file instead of stdout |
| `--format FORMAT` | Output format: text, markdown, html (default: markdown) |

## Workflow

1. Interpret the user's request for length and structure
2. Run `scripts/generate.py` with appropriate options
3. If the user wants the output saved, use `--output` or redirect/pipe as needed
4. If the user wants it in clipboard, pipe to `pbcopy`
5. Display the result or confirm the file was written

## Examples

**"Generate 3 paragraphs of lorem ipsum"**
```bash
uv run scripts/generate.py --paragraphs 3
```

**"Create lorem ipsum with 3 headings and 2 paragraphs under each"**
```bash
uv run scripts/generate.py --headings 3 --paragraphs 6
```

**"Give me a document with bullet points"**
```bash
uv run scripts/generate.py --headings 3 --bullets 5
```

**"500 words of continuous lorem ipsum saved to ~/Desktop/placeholder.txt"**
```bash
uv run scripts/generate.py --words 500 --continuous --output ~/Desktop/placeholder.txt
```

**"Lorem ipsum with numbered lists in HTML format"**
```bash
uv run scripts/generate.py --headings 4 --bullets 5 --numbered --format html
```

**"Exactly 500 characters of lorem ipsum"**
```bash
uv run scripts/generate.py --characters 500
```

**"About 100 tokens worth of lorem ipsum with headings"**
```bash
uv run scripts/generate.py --tokens 100 --headings 2
```

**"A realistic document with mixed content"**
```bash
uv run scripts/generate.py --mixed 5
```

© intellectronica · CC0-1.0 · intellectronica/agent-skills

Similar skills

Everything for Frontend and UI →

From the same set20

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor