AI Should Generate Less Code as Its Programming Ability Improves
Cursor used local Noto instead of a font store, producing working but wrong output. AI coding needs reuse discipline, not more generated code.
Key Takeaways
- A working feature can still be architecturally wrong: Cursor bypassed smallsymbols’ existing font store and used a local Noto font, producing inconsistent outputs while still running successfully.
- The core lesson is code reuse, not code generation: coding agents need discipline to use existing abstractions that enforce design decisions, instead of inventing new local paths.
- The author challenges the idea that better AI should skip source code and emit binaries directly: programming languages and abstractions remain important because they keep decisions centralized and stable across future changes.
- GitClear data supports the concern: cross-file function calls fell by 35%, refactoring dropped sharply, and copy-and-paste increased, suggesting AI-era coding often adds standalone code rather than reusing existing logic.
- Better AI programming should mean knowing what not to write: workflow checks, targeted review prompts, and explicit planning are needed to ensure agents respect existing architecture and avoid duplicate solutions.
Meta description: A developer says Cursor bypassed a font store while building smallsymbols, showing coding agents need reuse discipline at work, not more new code.
Tags: coding agents, Cursor, code reuse, GitClear, AI software engineering
Featured image: Abstract friendly illustration showing a code editor, a font library icon, and reused components, with soft blue and orange shapes, no real people, no logos, no text.
A working feature that bypassed a design decision
For developers using coding agents, this account explains why a feature that works can still be wrong, and what checks can catch it. In the authoring work behind smallsymbols, a visual emoji atlas that compares four emoji renderers, the author used Cursor to build a feature that generates derived images. The agent did not use the project's existing font store. It used the Noto font installed locally on the author's machine.
The author noticed because an older version of Noto was still installed. Some derived graphics looked visibly different: Noto draws a few emoji shapes differently in the newer version than in the older local copy. The feature still ran, but it was architecturally wrong. A design decision had been bypassed.
The author frames the font store as a decision, not leftover architecture. It is one place that knows which font versions and formats exist and that every renderer and every derived graphic should use the same one. That sounds like bookkeeping, but the author treats it as a product decision. If the project is comparing renderers, or generating graphics from the same emoji, they have to start from the same font version. Otherwise the result may not show a renderer difference or a stable derived image. It may show an accidental mix of versions.
The font store manages emoji fonts in multiple versions and formats, such as Noto in SVG (Scalable Vector Graphics) and PNG (Portable Network Graphics), and makes sure everything uses one consistent version. The author says this is not a workaround introduced because opening a font file directly is too hard for humans. It bundles a responsibility so that different parts of the software do not make contradictory assumptions.
This was not a one-off, according to the author. Cursor has gone around the font store more than once with the same pattern: a path that worked locally and never went through the place that was supposed to own the fonts.
More code does not always mean better software
The author's broader point is that generating code is not the same as building software. The code can look fine. The feature can produce output. The result can still be inconsistent because it ignored a decision that the rest of the system depends on. The author calls that a quality failure, not a step toward more autonomy.
The account compares this to an earlier article, "My Coding Agent Passed Every Test. The Code Was Wrong." In that case, tests were green while the logic was wrong. In the font-store case, the problem was not a hard-coded example. It was a design decision that the agent did not reuse.
That distinction matters because the conversation about AI coding often moves toward removing intermediate layers. There is a popular argument that as models get better, programming languages will not be needed. In that version, AI will skip source code and emit machine code, even optimized binaries, directly from a description of the desired outcome.
Elon Musk presented a version of that idea at a public xAI all-hands in February 2026. He said work may move, by the end of the year, "to where you don't even bother doing coding," because "the AI just creates the binary directly," and described traditional coding as "an intermediate step that actually will not be needed."
The author does not treat the timeline as the main issue. Programming languages are abstractions, and compilers already produce binaries. The hard part of software is not the last translation step. It is keeping a decision in one place so the next change does not contradict the last one. Abstractions do that work for agents at least as much as they do for humans. The font store already presents that problem at the application layer. No one needs to wait for machine code.
Report data points to less reuse
The article connects the local font incident to a larger pattern: coding agents are very good at producing new code, and much less reliable at using what is already there. GitClear's 2026 report, "The Maintainability Gap," is based on 623 million analyzed changes from 2023 to 2026. It found that cross-file function calls, a signal of reuse, are down 35 percent.
The report also says refactoring, measured as "moved" code, fell from 21 percent of changed lines in 2022 to 3.8 percent in 2026, while copy-and-paste rose from 9.4 percent to 15.7 percent. GitClear sells code-quality tools, and this is a correlation with the AI era, not a controlled experiment. Still, the author recognizes the shape: new code that stands alone, instead of calling the function already in the project, is exactly what the local Noto font was.
The author argues that better AI should not mean the agent writes more. It should mean the agent is better at seeing what it does not need to write. Software engineering, in this view, is the art of not having to solve the same problem again. An abstraction is how that decision stays in force.
Workflow checks keep the font store in force
The author does not assume Cursor will find the font store on its own. The workflow uses targeted search and review prompts that look specifically for the wrong usage: did the new code go through the font store, or did it open a font some other way? The habit is close to the second-agent reviews described in the earlier article, only the questions focus on architecture rather than whether tests were hard-coded.
Planning is also part of the fix. When the author plans a new feature, wiring up the font store is part of the plan, not an afterthought. The repository is searched for font files that have newly appeared. A new font file is a concrete smell that something bypassed the store. None of this is glamorous, and the author does it because the failure does not always announce itself. The case became visible only because the local font was out of date and a few emoji graphics looked wrong.
This is also why files such as AGENTS.md have caught on. Described as a "README for agents," AGENTS.md is now an open standard used by tens of thousands of projects and stewarded by the Agentic AI Foundation. The industry is betting that agents write better software when you tell them about the architecture that already exists, not when you delete the layers.
Instructions alone are not a guarantee, however. The author still searches and reviews, because an agent that can write the code can also walk around the rule.
The agent that writes less may be better
The final argument turns the usual picture of productivity around. The author says we still tend to picture a smarter coding agent as one that produces more code, faster, but that is the wrong picture. An agent that spends an hour reading the repository and then changes five lines to call a function that already exists is doing the better job, not the slower one.
The author links this to earlier arguments in "AI Won't Rewrite Photoshop" and "Building Got Cheaper. Madness Became Affordable." The first says agents make shared software more valuable, not less. The second says cheaper building raises ambition. It also makes it cheap to rebuild a problem already solved. That, the author argues, is the kind of madness not to afford.
The better AI gets at coding, the less new code it should need to write. The account was drafted with AI assistance from the author's notes and ideas. The projects, experiences and opinions are the author's own. It was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to the story.

Comments (0)