GitHub Copilot launched in spring 2021. It changed how developers think about AI. Look, the fight for coding AI is only getting hotter.

From autocomplete to writing apps

Three years before most people had heard of ChatGPT, GitHub Copilot arrived as an experiment from Microsoft and OpenAI. It watched developers type and tried to finish the next line — sometimes helpfully, sometimes not. More than a million developers signed up to try that early preview, and the industry took notice.

That early moment framed a simple idea: code is structured, lots of it's online, and you can check an output by running it. So training language models to work on code looked like low-hanging fruit.

David Pierce, who writes The Stepback newsletter at The Verge, argues that coding was a natural killer app for large language models. He pointed out that if models could autocomplete words for a search box, they could probably autocomplete the next lines of a program — and maybe, eventually, whole features.

The early successes sparked a competitive race among companies.

Who’s in the fight

OpenAI and Microsoft, which had already teamed up for Copilot, kept investing in developer tools. Google and Anthropic moved in with their own models and products. Startups such as Cursor and Windsurf raised fresh funding to compete directly with the big firms.

Companies are eager to improve developer workflows because speeding up or reducing the number of developers could transform software development.

Some firms aimed at the developer market more broadly: offering copilots that live inside editors, tools that generate tests, and assistants that explain code. Others focused on higher-level “vibe” or product design: models that turn a description into functioning interfaces or backend services.

Why code is different

Code isn’t like prose. It’s rule-based and checkable. You can run it, see where it breaks, and iterate. That makes debugging model output easier than, say, trusting a model to answer medical questions without verification. Developers can treat an AI like a junior teammate: try what it suggests, test it, and fix what fails.

Still, models make mistakes. They hallucinate functions that look plausible but don’t exist. They reuse licensed or copyrighted fragments in ways that make teams uneasy. Simon Willison, a programmer and blogger, summed that early behavior up when he called language models "weird coding interns" — helpful in spots, alarming in others.

And then there’s provenance: where did the training data come from? Lots of code is public on the web, but some of it's private, licensed, or behind paywalls. Companies and developers worry about whether a model’s output could carry legal risk or reveal someone’s intellectual property.

Mastheads

Business and market implications

Startups and giants are each chasing a similar prize: make engineers more productive, cut development time, and win enterprise contracts. Investors poured money into tools that promise to automate parts of the stack. Cursor and Windsurf are examples of smaller companies betting the market will take multiple specialised copilots — one for debugging, another for code review, another for scaffolding apps.

Big cloud and software companies don't want to cede the developer interface. Microsoft sells GitHub and its Visual Studio suite as places to embed AI help. Google wants to tie assistant features into its Cloud and IDEs. Anthropic and OpenAI focus on building models that are safe and useful for coding, then licensing those models to partners.

The result: lots of overlapping products, many similar claims, and a scramble for developer mindshare. And because code is a commercial asset, enterprise customers are picky about security, compliance, and audit trails — so product design has to match those demands.

Where developers stand

Developers have had mixed reactions. Some treat copilots as productivity multipliers: they scaffold repetitive sections, suggest tests, and speed up prototyping. Others are cautious, seeing the tools as buggy or time-consuming to verify. Many developers say the tools change the rhythm of work — shifting effort from typing to reviewing.

The labor question is on many executives' minds: if teams deliver faster with fewer people, how will hiring change? Some companies say AI will augment teams, not replace them. Others quietly plan smaller headcounts or shift roles toward integration and oversight rather than routine building.

That’s why developer trust matters. If a tool saves time but produces code that breaks in production, the net outcome isn't a win. So vendors are adding guardrails: built-in tests, provenance traces, and licence checks. They’re trying to make output auditable so engineering managers can feel safer deploying AI-assisted code.

Technical limits and safety concerns

Even powerful models stutter on complex problems. They struggle with multi-file projects, long-term architectural constraints, and context beyond the immediate editor window. They still miss edge cases and often propose insecure defaults. That means teams still need to oversee the work carefully.

Security researchers worry about models suggesting vulnerable code patterns or leaking secrets that were accidentally in training data. Legal teams worry about licences. Open-source maintainers worry that their work fuels commercial products without clear compensation. Those tensions trigger patchwork fixes — licence scanning tools here, model fine-tuning there — but no single solution yet.

What the competition looks like

Competition is playing out on several fronts. One is raw model quality: who can produce the most accurate, least hallucinating assistant. Another is integration: who can make AI fit smoothly inside existing IDEs, CI pipelines, and ticketing systems. A third is enterprise trust: who can prove their offering meets security and regulatory needs.

Companies are betting differently. Big tech can push integration and cloud bundling. Startups promise nimble product design and focused workflows. Open-source projects want to keep developer tools transparent. The market will likely support multiple approaches — at least for now.

The near-term product roadmap

Expect more vertical specialisation. Tools that focus on tests, code review, or specific languages will get better. Expect copilots to tie into pull-request workflows, CI, and observability platforms so they can suggest fixes that are already validated against tests and linters.

Vendors will also push for better provenance and licence tooling. If a firm can show where a snippet came from and that it’s licence-compliant, customers will feel safer using the output.

That said, some hard problems remain: reasoning over large codebases, keeping context consistent across sessions, and routing ownership for AI-generated features inside organisations.

What this means for software’s future

AI-assisted coding will probably change how teams organise. Routine pieces may get generated. Humans will shift toward oversight, architecture, and domain expertise. And new roles will appear — AI curators, prompt engineers, or code auditors — to make sure machine outputs are safe and correct.

But nobody’s replacing senior engineers overnight. Complex system design still needs human judgement. The machines are getting better at the repetitive stuff. The judgement calls remain ours.

Final signpost

Simon Willison’s "weird coding interns" line stuck because it captures the odd mix of help and hassle these models offer: they can boost productivity, yet they still require careful review. More than a million developers signed up for Copilot’s early preview in 2021, a fact that helped kick off the wider race to build coding AIs.

Related Articles

More than a million developers signed up for GitHub Copilot’s early preview in 2021.

This article was created with AI assistance.