Insights · February 15, 2026 · 5 min read
How good is AI-generated code? Strengths and limits
An honest look at AI-generated code: what it does well, where it falls short, how the developer's role changes and what frascati does about quality.
Updated October 14, 2026
AI-generated code has a mixed reputation. Ask developers and you hear about bugs, security holes and code nobody understands. Some of that is fair. Some of it comes from early tools that have improved a lot since. This article looks at what AI-generated code does well, where it falls short and what that means for people who build websites and software.
We make frascati, an AI website and app builder, so we have a stake in this question. We try to be fair anyway, including about the limits.
Where AI code stands today
AI now shows up at every level of software work: autocomplete in the editor, chat assistants that write functions, agents that change whole codebases, and builders that turn a description into a website.
Current models handle more than syntax. They know common architecture, accessibility requirements and the conventions of popular frameworks. For standard work, such as a business website, the result is often good enough to publish after a careful review. For unusual or complex systems, it still needs an expert.
What AI code gets right
Current conventions
Models learn from large amounts of public code and documentation, so they tend to follow current conventions. Ask for a React component and you get a function component with hooks, not an outdated class component. That helps less experienced developers who do not know the current way yet.
Routine steps, every time
People skip routine steps when they are in a hurry. An AI builder with good instructions does them every time: labels on form fields, alt texts on images, one main heading per page, layouts that work on small screens. The catch is the instructions. Without them, AI skips these steps too.
Accessibility basics
Accessibility is a good example. Semantic HTML, sufficient text contrast, visible focus styles and labels are well documented, so AI can apply them when it is told to. They are not automatic, and they are not everything: you still need to check with real content and, ideally, real people.
Responsive layouts
Layouts that work on phones, tablets and desktops follow standard patterns that AI knows well. Still, check your site on a real phone: long words, wide tables and unusual content can break any layout.
Where AI code falls short
AI-generated code has real limits. Know them before you rely on it:
Complex state
AI is good at single pages and components. It struggles when many parts of an application share data, when updates must happen in a certain order, or when edge cases pile up. That code needs careful human review.
Performance
AI writes code that works, not always code that is fast. It can render more than needed or load the same data twice. For applications with a lot of traffic or data, someone has to measure and optimise.
Security
AI can produce insecure patterns, especially around logins, input handling and database queries. Anything that handles user data, payments or authentication should be reviewed by someone who understands security. frascati keeps most of this out of the code it writes: websites and phone apps sign people in with a code sent by email through frascati's own service, which also checks on its server who may read which entries, data lives in Cloud tables that frascati runs, and payments run on Stripe's payment page, so frascati never sees card data.
New architecture
AI is best at patterns it has seen many times. For genuinely new system designs, domain knowledge and judgement matter more than typing speed, and AI helps less.
Unneeded complexity
AI sometimes adds layers nobody asked for: extra wrappers, helper functions without a clear purpose, abstractions for a single use. The code works, but it is harder to maintain. Ask for the simpler version.
Confident mistakes
AI writes fluent text and tidy code even when it is wrong. A made-up fact in the copy or a subtle bug looks just as convincing as the correct version. Review what the site says and does, not only how it looks.
What frascati does about quality
The model is only part of the result. The instructions around it, and the way you review what it produces, matter as much. Here is how frascati handles it:
- Models chosen for the job: Claude Opus 5.5 by Anthropic builds new websites, and Claude Sonnet 5.5 makes the changes.
- Clear rules for every site: frascati's instructions ask for semantic HTML with one h1 per page, alt texts on photos, labels on form fields, visible focus styles and text contrast of at least 4.5:1.
- Mobile first: the instructions ask for layouts that work from 375 pixels wide, with a header that collapses into a menu on small screens.
- Calm motion: hover and focus transitions only, everything visible without animation, and any extra motion respects the reduced-motion setting.
- Nothing made up: where frascati does not know a fact, such as a price, opening hours or a review, it leaves a visible [placeholder] or leaves the element out.
- A preview you can check: the preview switches between desktop, tablet and phone. If it shows an error, fixing it is free, up to 10 times a day.
- Versions: every change is saved as a version you can compare and restore.
- Open code: the Code view shows every file and you can edit it directly. With Pro and Business you can download the full source code for a developer to review, host or extend.
How the developer's role is changing
The useful question is not whether AI will replace developers, but how their work changes. Here is the shift as we see it:
| Less of this | More of this |
|---|---|
| Writing every line | Reviewing and correcting generated code |
| Implementing known patterns | Designing what does not exist yet |
| Fighting with layout details | Describing the intent and checking the result |
| Hunting syntax errors | Checking that the whole system behaves correctly |
| Learning every framework detail | Knowing what to ask for and how to judge it |
| Building everything yourself | Choosing the right tool for each part |
The developers who do well with AI are not the fastest typists. They are the best reviewers: people who understand architecture, security, performance and users well enough to steer AI output toward good software.
Honest conclusions
AI-generated code is good for a wide range of standard web work. Business websites, landing pages and portfolios can be built mostly with AI and turn out well, as long as someone checks the facts and the result.
It is not good enough to build complex applications without human oversight. State, security, performance and new architecture still need expertise. Code that works is not always code that is good.
The practical conclusion: use AI for the parts that follow known patterns, and spend your own time on the parts that need judgement. It is not AI against people. It is about dividing the work well.
For more, read our guide to vibe coding or our comparison of AI builders.