Card sharps call it a "tell" - the unconscious twitch that gives away a bluff. AI-generated screens have tells too, and once you learn to see them you cannot unsee them. The avatars are all the same person. The spacing is 12.5 pixels instead of 12. The greeting says "Hello, John!" The corners are 4 pixels here, 6 there, 8 somewhere else. And there is a settings cog that goes nowhere. None of these break the screen. All of them whisper "a model made this and nobody finished it." This lesson teaches you to read any hi-fi screen for the five visual symptoms of generated work and walks you out with a 30-second screen-audit script you can run before a Thursday review, in a portfolio screen, or on the v0 output engineering just pushed.

Why the Tell Matters More in 2026, Not Less

You might expect that as generation improves, the tells disappear. The opposite is happening. The big, obvious tells of 2023 - melted hands, garbled text, six-fingered stock photos - are mostly gone. What remains are the subtle, structural tells that come from the model averaging its training data and from a human never doing the last finishing pass. These are harder to see precisely because the surface looks clean, which means the screens that pass on a glance are exactly the ones carrying unfinished AI residue into your product, your design review, and your portfolio.

And the stakes are concrete. The product designer who has to ship a hi-fi mock, a Figma Make prototype, and a decision memo to a CPO in the same week cannot afford a screen that whispers "unfinished AI" in front of leadership. The design lead deciding whether the v0 prototype "matches design intent" needs a fast read on whether engineering hand-checked the output or just shipped the average. And anyone with a portfolio in 2026 needs to know that a hiring manager who clocks "Hello, John!" and three corner radii on the same screen has already decided you did not finish your own work. The tell is not a curiosity. It is a signal of unfinished craft, and people read it whether or not they can name it.

Symptom One: Avatar Uniformity

The first and most recognizable tell is the cast of identical people. Generate a screen with user avatars, testimonials, or a team page, and the model will hand you a row of humans who are suspiciously similar: the same approximate age, often the same ethnicity, the same lighting, the same slightly-too-perfect smile, frequently the same beige-sweater-and-soft-background aesthetic. Everyone is a 32-year-old in flattering light. The model is averaging "what a user photo looks like" across its training data, and the average of a biased corpus is a narrow, homogeneous, faintly uncanny crowd.

This is a tell on two levels. On the surface, it reads as fake, because real product screens show real human variety - ages, ethnicities, abilities, photo quality, candid imperfection. Beneath the surface, it is an early warning that the model's imagery carries demographic bias you will have to correct deliberately, a thread this program picks up in the training-data-ethics lesson. For now, the detection point is simple: a row of interchangeable people is a generated row.

Detection: Cover Three Faces and Ask "Are These the Same Person?"

The fast check is to glance at any cluster of human imagery and ask whether it represents a believable spread of real people or a single averaged archetype repeated. If you could swap any two faces and no one would notice, it is the tell. The fix is to replace generated avatars with real, diverse, appropriately licensed imagery, and to treat any generated cast as a placeholder that has not yet been designed, never as finished content.

Symptom Two: Off-Grid Spacing

The second tell is the one that separates designers from everyone else, because only a designer's eye is trained to feel it. A model that generates layout works in approximate pixels, not in your spacing system. So you get 12.5 pixels where your system uses 12, a 7-pixel gap where every human-built screen would use 8, a 23-pixel margin instead of 24. The screen looks almost aligned, and the almost is the tell. Human designers working in a token system land on the grid because the grid is how the tool snaps and how their eye is trained. The model lands near the grid because it is approximating, not adhering.

This is the v0-drift symptom in its purest form. The Thursday prototype review where the modal spacing drifted by 2 pixels and the focus ring went missing is this exact tell, rendered in code instead of Figma. The reason it matters beyond aesthetics is that off-grid spacing means the screen was not built from your tokens, which means it will not survive contact with your design system, which means a rebuild. Off-grid is not a cosmetic flaw; it is evidence that the structure underneath is improvised.

On-grid spacing is the fingerprint of a system. Off-grid spacing is the fingerprint of an average. A trained eye reads the difference in half a second, and so does a design system when you try to build against it.

Detection: Measure Two Gaps Against the Token Scale

You do not have to measure everything. Pick two or three gaps that should be obvious - the padding inside a card, the gap between list rows, the margin around the primary button - and measure them against your spacing tokens (usually a 4-pixel or 8-pixel scale). If they land on 8, 16, 24, the screen was likely built on the grid. If they land on 7, 13, 23, it was generated and never reconciled to your system. Two measurements take ten seconds and tell you whether you are looking at a buildable artifact or a pretty approximation.

Symptom Three: Generic Placeholder Copy

The third tell is the easiest to spot and the most embarrassing to ship: copy that was never written for a real user. "Hello, John!" in the greeting. "Lorem ipsum dolor sit amet" in 2026, which is almost a confession. "Welcome back!" with no thought to who is welcomed or why. "Your dashboard" as a page title. Card titles like "Card Title" and bodies like "This is a description." The model fills text slots with the most generic plausible string, because generic plausible strings are the statistical center of its training data, and a human never replaced them with real product language.

Generic copy is a tell because real interfaces speak in the specific voice of a specific product to a specific user doing a specific thing. "Hello, John!" tells you the screen was designed for a demo, not a person. The danger is that placeholder copy is exactly the kind of thing that slides through when everyone is looking at layout, and then ships, and then a customer sees "Hello, [First Name]" in production because the merge tag was never wired to anything real.

Detection: Read Every String Aloud as If You Were the User

Read the actual words on the screen as if you were the intended user mid-task. Does any string sound like it came from a template rather than from this product? "Hello, John!", "Lorem ipsum", "Your items", "Click here" - any of these is the tell. The fix is to replace every placeholder with real, voice-correct, edge-tested copy, including the longest realistic string and the empty state, so the screen speaks like the product and not like a demo. Generated copy is a draft prompt for real copy, never the finished thing.

Symptom Four: Inconsistent Corner Radii

The fourth tell is the one that reveals the absence of a system most clearly: corner radii that vary across elements that should match. A button with a 4-pixel radius, a card with 6, an input with 8, a modal with 12, all on the same screen, with no logic connecting them. A human working in a design system uses a radius token - one value, or a small deliberate set with a clear rule. The model picks a radius per element from its sense of "what a rounded corner usually is," so the values scatter, and the scatter is the tell.

This symptom is closely related to the invented-component flavor from the previous lesson: scattered radii are evidence that the elements were generated independently rather than composed from shared tokens. It matters because consistency of radius is one of the cheapest, strongest signals of craft, and its absence reads as carelessness even to people who could never name what is wrong. They just feel that the screen is slightly off, and slightly off is a tell.

Detection: Pick Three Rounded Elements and Compare

Choose three elements that have corners - a button, a card, an input - and ask whether their radii match the system's radius token or follow a deliberate rule. If a button and a card on the same screen have visibly different corner rounding for no functional reason, you have found the tell. The fix is to reconcile every radius to the token, which usually also means rebuilding the elements from real components rather than the generated approximations.

Symptom Five: Ghost Components

The fifth and most functional tell is the ghost component: an affordance that promises a behavior that does not exist. A settings cog with no settings page behind it. A "filter" button that filters nothing. A notification bell that opens nothing. A "see all" link that goes nowhere. The model includes these because they are common furniture on screens of this type in its training data - dashboards have settings cogs, so it draws a settings cog - without any model of whether this product actually has settings or where they live. The component is a ghost: it looks like an affordance but has no body behind it.

Ghost components are the most dangerous tell because they extend past aesthetics into broken behavior. A user clicks the cog and nothing happens, or worse, the team builds the cog because it is in the mock and then has to invent a settings page to justify it, designing backward from a hallucinated affordance. The tell here is structural: the screen promises functionality the system never agreed to provide.

Detection: For Every Interactive Element, Name Its Destination

Walk every clickable thing on the screen and state, out loud, what happens when a user activates it and whether that destination actually exists in the product. If you cannot name where the settings cog goes, it is a ghost. The fix is to remove affordances the product does not support, or to make a deliberate decision to build the destination, rather than letting a hallucinated control imply functionality nobody scoped.

The 30-Second Screen-Audit Script

Here is the artifact this lesson exists to give you. It is deliberately ordered fastest-to-slowest so you can stop early when a screen obviously fails, and it is phrased so anyone on the team can run it. Pin it next to the Generated-Mock Audit from earlier in the program; that one tests behavior, this one tests finish. Together they cover both halves of "looks right, behaves wrong."

1. Faces (5s). Are the people a believable spread of real humans, or one averaged archetype repeated? Interchangeable faces are generated.
2. Copy (5s). Read three strings aloud. Any "Hello, John!", "Lorem ipsum", "Card Title", or "Click here" means a human never finished the words.
3. Radii (5s). Compare a button, a card, and an input. Different rounding for no reason means scattered values, not a token.
4. Spacing (10s). Measure two gaps against the 4 or 8 pixel scale. Off-grid values (12.5, 7, 23) mean it was approximated, not built from tokens.
5. Ghosts (5s). Name the destination of every interactive element. A control that goes nowhere is a hallucinated affordance.

Thirty seconds, five symptoms, and a clear verdict: finished by a human, or generated and abandoned. Notice that none of these checks asks whether the screen is beautiful. The model already made it beautiful. The script asks whether anyone actually finished it.

A Worked Example: Auditing a v0 Prototype in 30 Seconds

Engineering shipped a v0 prototype from a screenshot and wants to know if it matches design intent. You open the preview and run the script. Faces: the testimonial row shows three smiling 30-somethings in soft light who could be siblings. Tell one. Copy: the hero says "Welcome back!" and a card reads "This is a description." Tell two. Radii: the primary button is 6 pixels, the card is 8, the input is 4. Tell three. Spacing: the modal padding measures 13 pixels against your 16-pixel token, and the focus ring is missing entirely. Tell four, plus a behavior bug. Ghosts: there is a notification bell in the header that opens nothing, because the product has no notifications yet. Tell five.

In thirty seconds you have a precise, non-defensive answer to "does it match intent": no, and here are the five specific reasons, four of which are finish and one of which (the missing focus ring) is a behavior bug worth its own flag. The conversation shifts from "did the AI do a good job" to "here is the finishing pass this needs before it is design," which is exactly where you want a prototype review to land.

The Three Places These Tells Hide Longest

If the five symptoms are so learnable, why do they keep shipping? Because they cluster in three blind spots, and knowing the blind spots is half the battle. The first blind spot is the portfolio screen that a designer has stared at for so long they no longer see it. After the tenth hour with a case-study hero, "Hello, John!" stops registering as placeholder and starts reading as part of the furniture. The tell is loudest to the stranger who sees it for three seconds and silent to the author who has seen it for three days. This is why a fresh pair of eyes - or a script you run mechanically rather than by feel - catches what your saturated attention cannot.

The second blind spot is the demo build, where everyone agrees "we'll fix the copy later" and later never comes. Placeholder copy and ghost components survive into shipped product precisely because they were waved through as temporary, and temporary has a way of becoming permanent the moment a deadline arrives. The script defeats this by refusing to distinguish "real screen" from "just a demo." You run it on everything, because the demo is exactly where the unfinished tells hide until a customer or a hiring manager finds them first.

The third blind spot is the handoff seam, the v0 or Figma Make output that engineering generated and design never re-checked because "engineering owns the build now." Off-grid spacing and missing focus rings live here, in the no-man's-land where design assumes engineering verified and engineering assumes design approved. The script is the thing that puts a human eye on the seam. Whoever runs it - designer, engineer, or PM - closes the gap that organizational handoff opened. The tells do not hide because they are subtle; they hide because of who was supposed to be looking and was not.

A Second Worked Example: Auditing Your Own Portfolio Hero

Turn the script on yourself, because this is where it pays your rent. Imagine the hero screen of your top portfolio case study, the one a hiring manager sees first. You generated a polished mock to illustrate the redesign and never went back. Run the five checks the way a stranger would. Faces: the user-testimonial strip shows four people who could be the same person in four sweaters. A hiring manager reads this in two seconds as "did not source real or diverse imagery." Tell one, and it is costing you in the most expensive thirty seconds of your job search.

Copy: the dashboard greeting says "Welcome back, Alex!" and a metric card reads "Your key metric." Specific-looking, but invented. A reviewer who has hired ten designers knows on sight that no real product ships "Your key metric," and the screen quietly demotes itself from "shipped work" to "school project." Tell two. Radii: your hero card is 12 pixels, the buttons inside it are 8, the avatar chips are fully round with no rule connecting them. A design lead clocks this as "does not work from a radius token," which is the exact opposite of the systems-thinking signal they are screening for. Tell three.

Spacing: you measure the card padding and it is 18 pixels against a system that should be 16 or 24, because you nudged it by eye during a late night. Off-grid. Tell four. Ghosts: there is an export icon in the corner that, in the real product, never shipped, because the feature got cut, but it is still in your portfolio screen promising a capability that does not exist. Tell five. Five tells on the single most important screen in your job search, none of which you could see anymore because you had looked at it too long. Thirty seconds with the script, and you have a finishing list that converts a screen that whispers "school project" into one that reads "this person ships." That is the script earning its keep on the work that matters most to you personally.

Why the Tell Is a Craft Signal, Not a Witch Hunt

It is tempting to weaponize the tell into a purity test - to sniff out and shame anyone who used AI. That misreads the entire point. The tell is not evidence that someone used a model; in 2026, almost everyone uses a model. The tell is evidence that nobody did the finishing pass after the model. A generated first draft that has been reconciled to the grid, given real copy, unified to one radius token, populated with real diverse imagery, and stripped of ghost affordances shows no tells, because a designer finished it. That is the goal: not to avoid generation, but to make the human finish invisible-by-being-thorough.

This reframes what the audit is for. It is a finishing checklist, the visual counterpart to the hallucination cheat sheet and the behavioral mock audit. Run it on your own work before you ship and it raises your floor. Run it on a teammate's generated screen and it teaches the finishing standard. Run it on your portfolio and it removes the five things a hiring manager uses to decide, in three seconds, that you ship the average. The tell is only damning when you let it through.

Key Takeaways

• As generation improves, the obvious tells vanish and the subtle structural ones remain, so clean-looking screens are exactly the ones carrying unfinished AI residue into reviews, products, and portfolios.
• The five visual symptoms: avatar uniformity (one averaged person repeated), off-grid spacing (12.5 instead of 12), generic copy ("Hello, John!"), inconsistent corner radii (4 / 6 / 8 on one screen), and ghost components (a settings cog with no settings page).
• Each symptom has a fast detection move: cover three faces and ask if they are the same person, measure two gaps against the token scale, read three strings aloud, compare three radii, and name the destination of every interactive element.
• Off-grid spacing and scattered radii are not cosmetic; they are evidence the screen was approximated rather than built from tokens, which means it will not survive contact with your design system without a rebuild.
• Ghost components are the most dangerous symptom because they cross from aesthetics into broken behavior and can trap a team into building backward from a hallucinated affordance.
• Run the 30-second screen-audit script before any hi-fi screen advances - on a review, a v0 prototype, or your own portfolio. None of the five checks asks whether the screen is beautiful; the model already made it beautiful.
• The tell is a craft signal, not a witch hunt. It marks the absence of a finishing pass, not the use of a model. A generated draft a designer actually finished shows no tells.