AI code generator: the four kinds, and when one is enough

What an AI code generator actually is

An AI code generator takes a description of what you want, in English or as a formal schema, and emits code. One request, one answer. It does not compile the result, run your tests, read the error, or try again. If the output is wrong, you find out, not the tool.

That is the whole definition, and it is worth being precise about because the market uses "code generator", "AI coding assistant", and "AI coding agent" interchangeably for products that behave very differently and cost between nothing and $200 a month.

GENERATOR                        AGENT

you describe an outcome          you describe an outcome
  model emits code                 model reads your files
you read it                        model writes code
you run it                         model runs the tests
you fix it                         model reads the failure
                                   model tries again
                                 you review a diff

The four shapes

1. Inline completion

The highest-volume form by a wide margin, and the one most people mean by "AI writes my code". It predicts the next few lines where your cursor is, and you accept or reject with a keystroke. It is the cheapest to run and the easiest to verify, because you are looking at it as it appears.

2. Chat to snippet

You ask a general assistant for a function, a regex, a config block, or a migration, and paste the result. Underrated for how much it gets used: an enormous amount of real code enters real repositories through a clipboard. The risk is also highest here, because the model has no view of your codebase at all and no way to know what conventions it is violating.

3. Prompt to app builders

Describe a product, get a working project with a UI, a database, authentication, and a deploy URL. These blur the line, because most of them now iterate on their own output, which makes them agents wearing a generator interface. Judge them on whether you get the code, and on what happens on the second change rather than the first.

4. Schema scaffolding, which is not AI

The oldest category and still the most reliable. openapi-generator from an OpenAPI document, a Prisma client from a schema, gRPC stubs from a .proto, rails generate, create-next-app. These are deterministic: the same input produces the same output, forever, and it is correct by construction rather than by review.

The landscape, priced

Prompt-to-app builders price in credits rather than seats, which behaves differently from a subscription: the first version of an app is cheap and the twentieth revision of it is not. Budget for iteration, because that is where the credits go.

When a generator is enough

The rule is simple and it holds up: a generator is enough whenever you can verify the output by reading it. If reading it is not sufficient proof, you need something that can run it.

When you need an agent instead

An agent is a generator wrapped in a loop with tools. It reads files, writes changes, runs commands, reads the output, and decides what to do next. That single addition is what lets it finish a task rather than produce a first draft.

The cost row is the one people are surprised by. A generator sends your context once. An agent re-sends the accumulated conversation on every turn so it can decide what to do next, so cost grows closer to the square of the turn count than to a straight line. Caching flattens the curve substantially but does not change its shape. That is why generators are priced per seat and agents are priced in usage windows and credit pools.

Read this before you ship generated code

Generated code fails in a narrower and more predictable set of ways than human code. Checking for exactly these takes a couple of minutes and catches nearly all of it.

1. Do the imports exist? Models invent package names that sound right. The invented names are repeatable, which means someone can register them, so an unfamiliar dependency in generated code deserves a look at the registry before you install it.
2. Are the versions current? Generated code reflects the ecosystem the model was trained on, which routinely means a deprecated API or an option that was removed two releases ago.
3. Where does it fail? Happy paths are the strength of this category. Error handling, empty inputs, and timeouts are consistently the weakness.
4. Any credentials in it? Placeholder keys, connection strings, and example tokens get pasted along with everything else.
5. Does it match the codebase, or a generic one? A generator that cannot read your repository writes idiomatic code for nobody in particular. That is how a second logging pattern and a third HTTP client get in.
6. Is anything licensed? Large generated blocks can closely resemble training material. It matters more the larger and more distinctive the block is.

Picking one

The honest order is: try the free tiers first, because they are genuinely capable and there are several; add a paid completion tool if you spend your day typing; and only reach for a paid agent when you find yourself describing whole tasks rather than lines. Buying the agent first is the most common way to pay $20 a month for something used like a chatbot.

Questions people ask

Keep reading