Why your AI keeps blowing the limit.

Ask an AI model for a "30-character App Store subtitle" and it will confidently hand you one that's 34 characters long — and if you ask it to double-check, it'll often tell you it's exactly 30. This isn't the model being careless. It's a direct, structural consequence of how language models actually read text, and it doesn't go away no matter how firmly you word the prompt.

Tokens aren't characters, and they aren't words either

A language model never sees the letters "a," "p," "p." Before your prompt reaches the model, a tokenizer chops it into tokens — subword chunks pulled from a fixed vocabulary the model was trained on. Common words like "the" or "app" are usually a single token. Rarer words, made-up names, and most numbers get split into two or three odd-shaped pieces. "ShotCanvas" might become one token or three, depending entirely on how often that exact fragment showed up during training — not on how many letters it has.

The model's entire understanding of the text is built on these token IDs, not on characters. It never runs anything resembling string.length. Any sense it has of "how long is this phrase" is a learned statistical approximation — pattern-matched from millions of examples of short phrases during training — not an exact operation it performs on demand. That approximation is often close. It is not reliable, and reliable is the only thing that matters when a store field hard-rejects character 31.

The "strawberry" problem is the same bug, smaller

This became internet-famous in 2024, when people discovered that several widely used chatbots insisted the word "strawberry" contains two r's. The reason wasn't stupidity — it's that "strawberry" doesn't reach the model as ten discrete letters. It reaches it as a small number of subword tokens, and counting a letter that's fused inside a token the model has never had to decompose is a genuinely hard task for it, not a lookup.

Character-limited copywriting is the exact same failure mode wearing a suit. Asking an AI to write "a subtitle under 30 characters" is asking it to hit a precise numeric target using a sense of length it can only approximate. Most of the time the approximation is close enough that nobody notices. On a field with zero tolerance for going over, close enough fails.

Why this matters more for app listings than almost anywhere else

Most writing tasks have soft limits — "keep it snappy," "a sentence or two." App and Play Store metadata fields are the opposite: hard, enforced, byte-exact ceilings. Apple's subtitle field cuts off at 30 characters. Its keyword field caps at 100. Google Play's short description stops at 80. There's no partial credit — a 31-character subtitle for Apple doesn't get truncated gracefully, it gets rejected or silently clipped mid-word, which is worse than either.

Generate that copy with an AI model and skip validation, and you're trusting an approximation to hit a target that has none of the tolerance the model was built around. It'll be right often enough to feel reliable in casual use, and wrong often enough to ship a clipped subtitle to production the one time you don't double-check.

The fix: stop asking the model to count. Count yourself.

Never trust a self-reported count. If a model says "here's your 30-character subtitle," that claim is itself a token-level guess, not a measurement. Treat it as decoration, not a guarantee.

Validate with real character counting, in code, after generation. A single call to a string-length function is instant, exact, and something the model will never be. Every AI feature that outputs constrained copy should run that check before the text ever reaches a screen or a store field — not as a nice-to-have, as the actual mechanism that enforces the limit.

When it's over, don't ask the model to "recount and fix it." That routes the same unreliable operation right back through the same bottleneck. Either trim programmatically, or re-prompt with the exact, code-measured overage stated as a fact: "this is 34 characters, cut it to 30" gives the model a concrete edit target instead of a counting task — a much easier job for it, and one worth re-verifying afterward regardless.

Iterate in small steps. A model asked to shave four characters off a phrase it already wrote does noticeably better than one asked to hit an exact count from a blank page. Constrain the edit, not the generation.

How we handle it in ShotCanvas

ShotCanvas's AI headline and metadata tools generate subtitle, keyword, and description copy against exactly this kind of hard field limit — so the model's output is never the last word. Every generated string gets measured and enforced in code before it's shown, the same length-check any store submission would run, rather than trusting the prompt to have produced something on target. It's a small, unglamorous safeguard, and it's the difference between AI copy you can ship straight to App Store Connect and AI copy you have to re-check by hand every single time.