Inside Aestheria

Stop fixing. Start designing.

Agentic coding was supposed to free designers for the big problems. Instead the day disappears into little ones: nudging spacing, renaming greys, prompting a screen toward pixel-perfect one correction at a time. That is not design. Here is the way out.

The promise of agentic coding is real: describe a screen and it exists. Then the second half of the day arrives. The spacing is close but not right. The grey is one shade off. The button is a near-copy of the one your system already has. You write another prompt: a little more padding. Then another. By the tenth correction you are not designing anymore. You are supervising pixels through a chat window.

We built Aestheria, the design context layer, around one conviction: fixing is not designing. Designing is solving problems, and solving problems is what designers signed up to do. Here is why agentic work keeps burying that, and what getting out looks like.

The new pixel-pushing

Every designer who has paired with Cursor, Claude Code, or v0 knows the loop. Generate. Squint. List the deviations. Re-prompt. The agent fixes two of the four and introduces a fifth. Sight is not the missing piece anymore: as of August 2026 an agent can screenshot the running page, measure a rendered element, and diff it against a target. What it cannot do is know which of the deviations matter, because nobody ever wrote that down anywhere it can read. So it converges on a look. Just not yours.

The cruel part is the ratio. The first eighty percent of a screen takes a minute. The last twenty percent, the part your eye actually cares about, takes the afternoon: correction prompts, regenerated diffs, the same spacing conversation you already had on the last screen. Engineering measured this shape first. In Sonar’s State of Code 2026 survey of 1,149 technology professionals, 61% agree that AI often produces code that looks correct but is not reliable, and the same 61% agree it takes a lot of effort to get good code out of AI through prompting and fixing. Almost everyone (95%) spends real effort reviewing and correcting the output, and 59% call that effort moderate or substantial. Toil did not shrink. It changed address.

The almost-right component is measurable too. GitClear’s 2026 maintainability research tracked what AI authorship did to reuse: duplicated code blocks up 81% against 2023, copy-pasted code up from 9.4% of new lines in 2022 to 15.7% in the first half of 2026, and properly moved or refactored code down from 21% to 3.8%. Cross-file function calls, their proxy for real reuse, fell 35%. Agents do not reuse your button. They rebuild it, a little differently, every time.

Fixing is not designing

The two feel similar. Both take taste, care, and a trained eye. But they run in opposite directions. Designing decides what should exist: the flow, the hierarchy, the problem this screen solves and for whom. Fixing defends decisions that were already made, one deviation at a time, forever.

Designing is solving problems. That is the aspiration that put most designers in this work, and it is not served by typing sixteen pixels, not twelve into a chat for the third time this week. A designer who spends the day correcting an agent has turned taste into a linter. And unlike a linter, people burn out. Designer Fund’s AI in Design 2026 report, drawn from more than 900 designers across 60 countries, found weekly AI use jumped from 54% to 91% in a year, and that the challenge designers name most often is unreliable output quality.

The tell is repetition. Corrections do not converge; they recur. The spacing you fixed on Tuesday is wrong again on Thursday’s screen, because the correction was a sentence in a chat and not a rule in the system. That is design system drift, arriving one generated screen at a time.

Why prompting harder does not work

The agent is not sloppy. It is context-starved. It reads your codebase fluently and your design intent not at all, because that intent lives in a Figma file, a documentation site, and your eye. None of those are readable at generation time, so every screen re-decides the small things and some re-decide wrong.

The industry has already sorted itself along that exact line. zeroheight’s Design Systems Report 2026 found 56% of design system teams using or experimenting with AI, but only 10% with it built into their process. Split by use case, the pattern is sharp: 71% use AI for code generation and 60% for documentation, while 24% use it for design generation, the use case 61% named as their biggest worry. Teams already trust these tools to write the code. They do not trust them to make the decisions.

The usual answer is a rules file, and rules files do help. AGENTS.md and CLAUDE.md load on every session, so corrections at least stop dying with the chat window. But prose is not a contract. Nothing verifies the generated screen against it, nothing fails when it drifts, and a long session wanders from an instruction it read an hour ago. A rule nobody checks is a preference, and agents treat it like one. What closes the gap is a system that can say wrong.

Correct the screen and you have fixed one screen. Correct the system, in a form the agent reads and something checks, and you have fixed every screen that comes after. The first is a treadmill. The second is design work: it compounds.

Make the correction once

Every correction you keep typing is a decision that deserved to be made once. Which grey. Which spacing between a title and its subtitle. Which button variant a secondary action takes. In Aestheria those answers live as machine-readable design context: tokens with usage rules, components meant to be reused rather than approximated, patterns, and checks that verify a generated screen against all of it.

Your agent reads that context from the kit in your repo or live over MCP, so the correction happens inside the generation loop, before the screen reaches your eye. Pixel-perfect stops being a negotiation, because the pixels were decided before the prompt. The tenth screen arrives as on-system as the first.

This is not only our read of where things are going. Atlassian published DESIGN.md on the same premise: design context should be portable and read at generation time, not looked up by a person. We think a single file is the right instinct and the wrong ceiling, which is the argument the comparison with DESIGN.md makes in full. Either way, the correction belongs in the context and not in your afternoon.

Start designing

What is left, once the correction loop goes away, is the work designers actually want. What should this product do. Who is it failing. Why does this flow lose people at the third step. What should it feel like to use, and does it. Problems. The kind worth a designer’s day.

The role moves upstream. Instead of correcting a hundred screens, you shape the system the screens are generated from: the tokens, the patterns, the rules, the taste, encoded once and applied everywhere. Decisions propagate. Judgment compounds. The product moves.

That is the trade Aestheria offers: the small decisions, already made; the corrections, already applied; the day, returned to the problems. Stop fixing. Start designing.

Questions

Why does AI-generated UI still need so much correction?

Coding agents read the codebase fluently and design intent not at all, because that intent usually lives in a Figma file, a documentation site, and a designer’s eye. None of those are readable at generation time, so every screen re-decides spacing, greys, and component choice from scratch. In Sonar’s 2026 developer survey of 1,149 technology professionals, 61% said AI often produces code that looks correct but is not reliable.

Can AI coding agents see the screens they generate?

Yes. As of August 2026, agents can screenshot a running page, measure rendered elements, and diff the result against a target design. Sight is no longer the limitation. Knowing which deviations matter is the limitation, because that judgment has to be written down somewhere the agent can read before it can be applied.

Do AGENTS.md and CLAUDE.md files solve design drift?

They help, and they are not sufficient. Rules files load on every session, so corrections persist beyond a single chat. But they are prose that nothing verifies: no check fails when a generated screen ignores them, and long sessions drift from instructions read earlier. Persistent context plus a verification step is what stops corrections from recurring.

Does AI make design system reuse better or worse?

Worse, by measurement. GitClear’s 2026 maintainability research found duplicated code blocks up 81% against 2023, copy-pasted code up from 9.4% of new lines in 2022 to 15.7% in the first half of 2026, and refactored code down from 21% to 3.8%. Agents rebuild a near-copy of an existing component more often than they reuse the real one.

Do you need an existing design system to fix the correction loop?

No. Aestheria ships the starter context: tokens with usage rules, components meant to be reused rather than approximated, patterns, and checks that verify a generated screen against all of it. Teams with a mature design system map theirs in. Teams without one start from what ships and edit it.