Prompt-to-font AI tools let you start from exactly that: a written spec. I find it helps to treat the result the way I treat any generated code. It is an artifact that comes out of a pipeline, and it has to pass review and tests before it ships. This post walks through that pipeline using MakeFont, which accepts a text prompt, an image, or both, and exports a TTF.

The pipeline at a glance

1. Spec: write a prompt with explicit parameters.
2. Generate: pick a character set and run one AI task.
3. Review: inspect the output glyph by glyph.
4. Patch: fix individual glyphs instead of re-running everything.
5. Build and test: download the TTF and test it in your real stack.

Stage 1: Write the spec like a config file

A vague prompt ("cool techy font") is like a vague ticket: you will get something, but not what you meant. Break the prompt into fields and fill in every one:

category:   monospace-feeling display sans
weight:     bold
width:      slightly condensed
details:    square terminals, low contrast, tall x-height
mood:       retro terminal, 1980s arcade
use case:   game title screen and HUD labels

Then flatten it into one sentence: "Bold, slightly condensed display sans with square terminals, low stroke contrast and a tall x-height, retro 1980s arcade mood, for a game title screen and HUD labels."

Every concrete detail removes a guess the model would otherwise make.

If you have a reference, such as a sketch of a few letters, a photo of a sign you drew or a scrap of your own lettering, attach it (PNG, JPG or WEBP, up to 20 MB). Prompt plus image is usually the clearest input: the image shows shape, the text states intent ("keep these corners, but make it heavier"). Keep in mind the image is a style reference, not a tracing template: supplied letters may be redrawn.

Stage 2: Generate against the right character set

Choose the language before you submit, because it defines which glyphs are required. MakeFont's new AI projects currently support English, Spanish, French, German and Portuguese, all Latin script. That means accented letters like ñ, ç, ã, é, ä, ö, ü and ß are covered when you pick the right language. Chinese, Cyrillic, Arabic and other scripts are not supported for output, so if your project needs them, this is not the tool for that part.

Sign in with Google or an email one-time code. Budget-wise, a free account gets 50 lifetime credits. One AI font creation task costs 20 credits and language detection costs 1 credit per run. Credits are only kept after glyph correction succeeds; failed tasks release them. Editing, building and downloading cost nothing.

Stage 3: Review the output like a pull request

The generated sheets are traced into vector outlines and collected in a Font Profile in your browser. Don't download yet. Go through it the way you would read a diff:

• Consistency checks: do the round letters (o, c, e, d, b) share one curve? Do the stems of n, m, h and l have the same thickness?
• Alignment: type "hamburgefonstiv" and look at the baseline and x-height.
• Known hotspots: g, a, k, R, Q, S and & are where generated fonts most often go wrong.
• Locale test: type a real sentence in your chosen language with its accents.

Stage 4: Patch, don't re-run

When one glyph is off, re-running everything is like rebuilding from scratch to fix a typo. Patch the glyph in the editor instead: repair a failed outline, adjust bounds and baseline, draw or erase strokes, transform the shape, and undo or redo as needed.

Useful guardrail: if a required glyph has no usable outline, the TTF build waits until it is fixed. Think of it as a failing check that blocks the merge.

Re-run only when the overall direction is wrong ("too thin", "too formal"), and change one parameter in your spec at a time so you know what caused the difference.

Stage 5: Build, download and test in your stack

Once every required glyph builds, type your real strings in the preview (the game title, the product name) and download the TTF. The in-browser preview uses WOFF2, but the download is a TTF.

Install and inspect on Linux:

mkdir -p ~/.local/share/fonts
cp MyFont.ttf ~/.local/share/fonts/
fc-cache -f
fc-list | grep -i myfont        # confirm it registered

On macOS, double-click the file and choose Install Font in Font Book. On Windows, right-click and choose Install.

On the web, you can serve the TTF directly with @font-face, or convert it to WOFF2 yourself with your usual tooling for smaller files:

@font-face {
  font-family: "ArcadeTitle";
  src: url("/fonts/MyFont.ttf") format("truetype");
  font-display: swap;
}
h1 { font-family: "ArcadeTitle", system-ui, sans-serif; }

Then test it at your smallest size and next to your body font.

Where this workflow fits, and where it doesn't

Good fit: prototypes, game jams, hackathon branding, personal sites, zines.

Poor fit: brand systems that need multiple weights and licensing guarantees, long-form body text that needs careful spacing work, and non-Latin scripts.

And check the license before shipping. MakeFont does not promise that outputs are original, exclusive, copyrightable or cleared for commercial use, so read the terms if the font is going into a logo or a product.

Takeaway

Prompt-to-font AI is useful once you treat the output as a draft artifact: precise spec in, careful review, small patches, real tests before shipping. If you'd rather start from your own pen strokes than a prompt, the handwriting-to-font workflow goes through the same review-and-patch loop.