GPT Engineer

GPT Engineer is the open-source CLI project that first showed a mass audience what it looked like to describe an app in plain language and get a working codebase back. Created by Anton Osika in 2023 and now sitting at over 55,000 GitHub stars, it sparked the entire wave of prompt-to-app tools that followed. The repository was archived in April 2026, making it officially a read-only historical reference rather than an actively developed product. The commercial successor is Lovable. The CLI still installs, still runs, and still works for learning purposes, but it has been lapped by every modern alternative on UX, model support breadth, and reliability. If you want to understand where the category came from, this is ground zero. If you want to ship something today, reach for a different tool.

Three years ago, dropping a paragraph into a terminal and watching a folder of working code appear felt like a conjuring trick. GPT Engineer was the project that made that trick go viral. Anton Osika pushed the repo to GitHub in June 2023, the internet shared it relentlessly, and 55,000 stars arrived before most people had time to form an opinion. Every prompt-to-app product you use today traces some part of its DNA back to what that initial release demonstrated. The repository was archived in April 2026, which makes this a good moment to look at what it actually was, what it still is, and why the honest answer in 2026 is “go use something else” for almost everyone except the curious.

Quick verdict

GPT Engineer is a museum piece that runs. The codebase is clean, the concept was genuinely influential, and it still installs and generates code today. But the last release was June 2024, the repo is now read-only, and every problem it solved has been solved better by tools that kept developing. If you want to understand the category’s origins, it’s worth an hour. If you want to ship software, open Lovable, Bolt.new, or Aider instead.

What is gpt-engineer, exactly?

The core idea is simple: you write a plain-text description of the software you want, you run a CLI command, and an AI reads that description, asks you a handful of clarifying questions, then writes the full project into a directory on your machine. No GUI, no browser, no cloud infrastructure on your end. Just Python, your API key, and a text file.

Anton Osika, a Swedish engineer, released the first public version in June 2023. At the time, the idea of an agent that could produce a complete, runnable codebase from a single natural-language spec was genuinely new to most people. Tools like GitHub Copilot existed, but they completed individual lines. GPT Engineer was one of the first widely available demos of what people now call the “prompt-to-app” pattern, where you describe intent at the application level and the model handles the structural decisions.

The viral moment was real. The 55,000-star count is not inflated by bots or hype cycles. Engineers who had been using Copilot for autocomplete suddenly saw a different mode of AI interaction, and many of them built side projects with this tool in the months that followed.

The commercial thread is equally important to the story. The gptengineer.app web product, which became Lovable, grew out of the same team and the same ideas. The README in the archived repository is explicit about this. It describes the CLI as a “Precursor to lovable.dev” and lists that URL directly. The split between the OSS CLI and the commercial product happened as the team realized the browser-based, hosted experience was where the growth was. The CLI became a reference point rather than a product under active development.

By April 2026, the repository was formally archived. No new issues will be resolved, no new releases will ship, and no new model integrations will be added. The code is frozen.

The features that mattered then and the ones that still do

Spec to project scaffold in one prompt

The headline feature is still the headline feature: you drop your requirements into a file called prompt, run gpte, and get a directory of source files. The agent doesn’t just write a single script. It makes structural decisions, names files, writes configuration, and wires pieces together according to what it thinks your spec implies. In 2023 this was remarkable. In 2026 it’s table stakes, but you can see the bones of every modern scaffolding tool in how GPT Engineer approached it.

Iterative refinement loop

Before writing any code, the agent asks clarifying questions. This was a deliberate design choice and a smart one. Rather than charging ahead with assumptions that produce something useless, it surfaces ambiguity early. You answer the questions, the answers become additional context, and then the code generation runs. The loop is text-only and happens entirely in your terminal, which makes it slower and more friction-heavy than the real-time back-and-forth you get in a tool like Lovable, but the underlying instinct was correct.

Bring your own model

GPT Engineer was BYOK from day one. You supply your own OpenAI key, or your Anthropic key, or an Azure deployment endpoint, or an OpenRouter URL pointing at an open-source model. Nothing is locked. This was partly a practical decision (the project had no hosting infrastructure) and partly a philosophical one: the OSS community should be able to run this on whatever models they choose.

In 2026, that model list is somewhat dated. The integration layer hasn’t been updated since mid-2024, which means very recent models may require you to manually edit the code to point at current API endpoints or model names. It’s not impossible, but it’s friction that didn’t used to exist.

Self-improvement experiments

One of the stranger and more interesting features was a self-improvement mode where you could ask the agent to improve its own prompts and scaffolding. The idea was to let the agent run benchmarks against APPS and MBPP datasets and iteratively refine its own code generation strategy. In practice this was more of an experiment than a production feature, and it was never mature enough to be something you’d run as part of a real workflow. But it represented a genuine attempt to push past simple spec-to-code into something more recursive. At the time, few other public tools were even attempting this.

Open source as a learning tool

The codebase is clean, well-commented Python. The core pipeline is easy to read: a spec gets loaded, clarifying questions get generated and answered, a set of files gets produced by the model, and those files get written to disk. There’s no magic and no obfuscation. If you want to understand how to build a simple autonomous code generation agent, reading the GPT Engineer source is one of the fastest ways to get there. For anyone building their own tooling or teaching a course on AI agents, the code is worth studying even now.

Pricing

GPT Engineer itself costs nothing. The MIT license means you can fork it, modify it, distribute it, and build commercial products on top of it without asking permission or paying anyone.

Your only real cost is API usage. The tool was originally designed around OpenAI’s GPT-4, which was the most capable publicly available model when it launched. At 2023 prices, generating a medium-complexity project could cost a few dollars in tokens. By 2026, model prices have dropped dramatically across every major provider, so the token cost of a typical run is closer to a few cents on efficient models.

If you use Anthropic models, you pay Anthropic’s standard API rates. If you use OpenAI models, you pay OpenAI. If you route through OpenRouter to use open-source models, you pay OpenRouter’s per-token rates, which are lower than the frontier model costs for equivalent tasks.

There is no subscription, no freemium tier, no feature gate, and no seat licensing. This is genuinely and completely free software. What you’re trading away is the infrastructure, maintenance, and polish that come with a paid product. In 2026, with the repository archived, you’re also trading away any future development. What you see is what you get, permanently.

For comparison, Lovable starts at around $25/month for a hosted plan where you don’t manage any API keys. Bolt.new operates on a credit model. Aider is similarly free and BYOK but is still actively maintained. If cost is genuinely your only constraint, GPT Engineer and Aider are your two real options. Between them, Aider is the better-maintained choice.

Where gpt-engineer still has a place

The honest answer is that GPT Engineer has been supplanted for production use. Any serious engineer who needs a CLI-based coding agent should use Aider. Any developer who wants a hosted prompt-to-app experience should use Lovable or Bolt.new. The workflows are smoother, the models are better supported, and the tools are actively developed.

What GPT Engineer still does is anchor an understanding of where the category came from. If you’re writing about the history of AI coding tools, studying how the earliest autonomous agents were designed, or building a course on the topic, the original repo is primary source material. The 2023 commits are a timestamp on the early state of this field.

There’s also a niche for people who want a minimal, hackable scaffold. The codebase is small enough to read completely in an afternoon. If you want to build a custom agent that generates code from specs and you want to start from something rather than nothing, forking GPT Engineer gives you a workable foundation that you fully control. You’re not fighting an actively developed product’s opinions, because it has no more opinions to add.

Finally, for educators who want to demonstrate how a simple LLM pipeline translates natural language into a file tree, the code is pedagogically clear. The path from prompt to output is short and traceable.

Who gpt-engineer is built for in 2026

The audience for GPT Engineer in 2026 is narrow but real.

Learners who want to understand how early autonomous coding agents worked will find the codebase readable and instructive. It’s a good starting point for anyone studying the architecture of these systems.

Researchers and writers covering the history of the AI coding tools category will want to reference the original repo and the 2023-era design decisions it made.

Tinkerers who enjoy forking and customizing tools will find a small, well-structured Python project they can reshape without worrying about breaking compatibility with an actively maintained upstream.

Educators building courses on AI engineering or LLM applications will find it useful as a worked example of a complete, minimal agent pipeline.

If you’re an engineer who wants to get code written today, this isn’t your tool. The people who built it agree: they built Lovable for that job.

gpt-engineer vs the modern alternatives

vs Lovable

Lovable is what GPT Engineer became commercially. The browser-based interface, hosted infrastructure, real-time preview, and iterative editing that Lovable offers are all things GPT Engineer pointed toward but never built. The tradeoff is cost and control. Lovable charges a monthly subscription and manages everything for you. GPT Engineer is free, BYOK, and runs locally. For anyone who wants the polished version of the original idea, Lovable is the destination. For anyone who wants to own the whole pipeline, GPT Engineer is the historical starting point.

vs Bolt.new

Bolt.new runs in a browser, generates full-stack applications with live previews, and supports an iterative chat interface that GPT Engineer never had. The generation quality is higher and the feedback loop is tighter. Bolt.new uses a credit model rather than BYOK, so you’re trading cost control for convenience. If you want to produce a deployable web app quickly, Bolt.new is faster and more capable. GPT Engineer was never designed to compete with what Bolt.new does today.

vs Aider

This is the most direct comparison for CLI users. Both tools run in a terminal and require API keys. Aider works inside existing git repositories, generates precise file-level diffs, auto-commits every change, and supports a much broader and more current model roster. GPT Engineer generates greenfield projects from scratch and has no git integration or diff-level editing. Aider is actively maintained, has a published model leaderboard, and receives regular releases. For any practical coding work, Aider is the better tool by a significant margin. See Aider’s full profile for the breakdown. And if you want to see how agents like this stack up more broadly, the best AI agents for coding comparison covers the current field.

Getting started

If you want to run GPT Engineer despite everything said above, the setup is straightforward. You need Python 3.10 through 3.12 and an API key from a supported provider.

pip install gpt-engineer

Set your API key as an environment variable:

export OPENAI_API_KEY=your_key_here

Create a project directory with a prompt file containing your requirements:

mkdir my-project && cd my-project
echo "A CLI tool that converts Markdown files to HTML and saves them to an output directory" > prompt
gpte .

The agent will ask a few clarifying questions, then generate the project files. You can also use Anthropic or OpenRouter models by setting the appropriate environment variables and passing a model flag. Check the archived README for the exact flags, since the documentation site is no longer actively updated.

Do not expect the results to match what Lovable or Bolt.new produce. The output is a starting point, not a finished product.

The bottom line

GPT Engineer is a landmark project that aged into a teaching tool. It was first to show the world what prompt-to-codebase could look like, it grew to 55,000 GitHub stars on the strength of a genuinely interesting idea, and it directly preceded one of the more interesting commercial AI products of the past few years in Lovable. It was also archived in April 2026, and the world moved on.

If you’re here because you heard about it in 2023 and are wondering whether to try it now, the answer is probably not for production use. If you’re here because you want to understand how this category started and what the early design decisions looked like, the code is sitting right there on GitHub, clean and readable. It’s worth an afternoon. Then go use Aider or Lovable for whatever you actually need to build.

Key features

• Generates a full project scaffold from a single natural language spec file
• Iterative clarification loop asks follow-up questions before writing any code
• Bring your own API key for OpenAI, Anthropic, Azure OpenAI, or open-source models via OpenRouter
• Vision support lets you attach screenshots or mockups as part of the spec
• Custom preprompts let you redefine the agent's identity and coding style
• Benchmarking mode runs against APPS and MBPP datasets for model evaluation

Pros and cons

Who is GPT Engineer for?

• Students learning how LLM-based code generation agents work under the hood
• Researchers studying the design of early autonomous coding systems
• Tinkerers who want a minimal BYOK scaffold they can fork and modify freely
• Engineers building their own agent tooling who want a reference implementation to study

Alternatives to GPT Engineer

If GPT Engineer isn't quite the right fit, the closest alternatives are lovable , bolt-new , and aider . See our full GPT Engineer alternatives page for side-by-side comparisons.