Introducing new GPT-3 features: Editing and insertion

If you've been working with OpenAI's GPT-3 or Codex models, you'll want to know about a meaningful upgrade: both models now come in new versions that can edit or insert content into existing text, rather than only continuing from where a passage leaves off. This article breaks down what that change means, why it matters, and how it might affect the way you build with these models.

What Changed with the New Versions

Until now, GPT-3 and Codex worked primarily as text completion engines. You gave the model a starting point — a sentence, a paragraph, a chunk of code — and it generated what might come next. That worked well for many tasks, but it had a built-in limitation: the model could only move forward. If you wanted to revise something in the middle of a document or add a missing piece earlier in the text, you had to engineer awkward workarounds, like resending the whole passage and hoping the model reproduced it with the change you wanted.

The newly released versions of GPT-3 and Codex remove that constraint. They can take existing text and either edit it — replacing or rewriting what's already there — or insert new content into it at a specific point. The text that came before no longer has to be treated as untouchable input; it can be part of the output the model actively shapes.

Why Insertion Is a Big Deal for Developers

Completion-style generation has always been a slightly one-directional experience. Codex, the model that powers code generation, is a good example of where the old approach fell short. If you were writing a program and wanted the model to fill in a function in the middle of a file — not at the end — the completion paradigm didn't naturally support that. You'd end up restructuring your prompt to trick the model into placing the code where you needed it.

With insert capability, the model can place new code directly into an existing file at the point you designate. That's a much closer match to how real programming actually happens. Developers rarely write code in one straight pass; they jump around, fill gaps, and revise sections. The updated Codex is better aligned with that workflow, which should make tools built on it feel more like a genuine collaborator and less like an autocomplete that only works at the end of a line.

How Editing Changes Everyday Use Cases

The edit capability opens up a different set of possibilities, especially for people who work with text rather than code. A few examples worth considering:

• Rewriting and polishing. Instead of regenerating an entire paragraph to fix one clumsy sentence, you can ask the model to edit just the part that needs work, keeping everything else intact.
• Consistent tone adjustments. Editing lets you apply a style change across existing content without the model drifting off-topic or inventing new material.
• Translation and adaptation workflows. Existing text can be transformed while preserving its structure, which is useful for localization or adapting content for different audiences.

For Codex specifically, editing suggests smoother experiences for tasks like refactoring — changing how code is written without changing what it does — or updating older code to follow new conventions. These are exactly the kinds of jobs that pure completion models struggled with.

What This Means for Builders and Experimenters

If you build applications on top of OpenAI's models, the practical takeaway is that the interaction model is richer than it used to be. You're no longer designing prompts around the assumption that the model only appends text. Products that involve document editing, code assistants, or any tool where users want to revise rather than just generate can now offer a more natural experience.

It's worth noting that OpenAI hasn't published specific benchmark figures or pricing details in this announcement, so if those numbers matter to your project, check the official documentation for the current state of things. As always with model releases, real-world performance on your particular use case is the best guide — the right move is to try the new versions against your existing prompts and compare results directly.

For researchers and hobbyists, the change also signals a direction: language models are moving from "predict the next word" toward more flexible manipulation of text. Edit and insert are early steps in that shift, and they hint at future capabilities where models treat documents as something to be sculpted, not just extended.

Getting Started

If you're already using GPT-3 or Codex through the API, upgrading to the new versions should be straightforward — the core workflow of sending prompts and receiving output stays the same. What changes is what you can ask for: alongside completion requests, you can now request edits to supplied text or insertions at defined points. Start with a small, low-stakes task, such as editing a short paragraph or inserting a single function into a simple script, and get a feel for how the models handle the new modes before relying on them for anything important.

One practical tip: because the model is now touching text that already exists, it's worth reviewing its edits carefully rather than accepting them wholesale. Edit operations can occasionally rewrite more than you intended, especially on longer or more complex passages, so a quick read-through of the diff between input and output is a good habit to build.

Common Mistakes

• Assuming completion behavior still applies everywhere. The new versions behave differently, so old prompts may need adjustment.
• Skipping output review. Because edits modify existing text, small unintended changes are possible — always compare before and after.
• Overloading a single request. Large, complicated edits tend to work better when broken into smaller, focused ones.
• Ignoring the documentation. Check OpenAI's official docs for exact usage details, limits, and pricing rather than relying on assumptions.