One of the favourite old warnings from AI sceptics was: “Just wait until that AI of yours starts writing code.” Well, it happened.
Generative AI learned to speak programming language, and software development hasn’t been quite the same since.
Are Developers Unnecessary? Far From It.
At first, this sounded like another round of futuristic marketing. Developers have heard similar promises before. Tools that generate code, scaffold applications, create CRUD screens, and build project skeletons have been around for a long time. The dream of writing less repetitive code is almost as old as the developer world itself.
What changed isn’t only that artificial intelligence can generate code. What changed is that large language models, or LLMs, can understand instructions, read existing code, explain unfamiliar logic, propose changes across multiple files, run tests, review pull requests, and help developers move from idea to implementation faster.
That doesn’t mean developers are obsolete, far from it. It means the job is shifting again. The developer is no longer just someone who writes every line manually.
From Autocomplete to Coding Agents
The first generation of developer assistance was mostly reactive. The developer typed, and the IDE suggested a class, method, parameter, or import. It saved time, but it didn’tunderstand the broader task.
AI-assisted autocomplete changed the experience. Tools such as GitHub Copilot made it possible to generate entire lines, functions, tests, or small components from surrounding code and comments. A developer could describe a function in plain language and receive a useful first draft.
Then came conversational programming assistants. As of July 2026, the leading conversational programming assistants include ChatGPT, who’s latest OpenAI model family includes GPT-5.6; Claude, whose latest Anthropic lineup includes Claude Fable 5 (Mythos) and Claude Sonnet 5; and Google Gemini, whose latest Gemini model updates include Gemini 3.5 Flash. These tools became useful not only for coding, but also for learning, debugging, documentation, and technical planning.
The newest category is agentic coding tools. These tools can work across repositories, modify files, run commands, check failures, and prepare changes for review. GitHub Copilot agents, OpenAI Codex, Claude Code, Amazon Q Developer, Cursor, Windsurf, and similar products are moving AI assistance from code suggestion into task execution.
GitHub Copilot and the Developer Wingman
GitHub Copilot is still the best-known example of AI programming assistance. In its early form, it was understood as advanced autocomplete. It could suggest functions, fill in tests, complete repetitive code, and help developers avoid constant context switching.
Modern Copilot is broader. It can chat about code, explain unfamiliar sections, help with tests, suggest fixes, review pull requests, and operate through cloud agent workflows. Instead of only asking for the next line of code, a team can assign a small backlog task: add missing unit tests, improve logging, update a deprecated API, or refactor a simple component.
This changes the relationship between developer and tool. Copilot becomes less like a typing shortcut and more like a wingman. It can help, suggest, warn, and accelerate. But it shouldn’t fly the whole plane without human review.
ChatGPT, Codex, and Repository-Level Work
When ChatGPT became widely available, many developers quickly tested the same question: can it write code?
Very often, it could.
ChatGPT became useful because it wasn’t tied to one language, framework, or IDE. Developers could ask it to explain a C++ class, generate a REST API in Node.js, write a Dockerfile, debug Python, convert JavaScript to TypeScript, or outline an architecture decision.
That older workflow was mostly conversational. The developer pasted a snippet, question, or error message. The model returned an explanation or draft code.
OpenAI Codex, now available in ChatGPT and powered by OpenAI’s latest frontier coding models, represents a different direction. Instead of generating only snippets in a chat window, Codex is designed for software engineering tasks across real repositories. It can help with features, refactoring, migrations, testing, and code review inside controlled development environments.
This doesn’t remove engineering judgment. It makes judgment more important. The developer still needs to define the task, control scope, review the output, understand tradeoffs, and decide whether the change belongs in the system.
Claude Code and the Careful Programming Colleague
Claude has become popular among developers because it is often strong at explanation, long-context reasoning, technical writing, and working through messy requirements.
Claude Code moves the latest Claude model capabilities into the development workflow, including Anthropic’s newest Claude lineup for knowledge work, coding, analysis, and everyday automation. It can read a codebase, edit files, run commands, and work through tasks in the terminal or development environment. It is useful when a task is too large for autocomplete but still clear enough to delegate.
Examples include adding tests, fixing lint errors, updating dependencies, tracing a bug, resolving a merge conflict, writing release notes, or refactoring code across several files.
Claude Code also reflects an important trend: project instructions. Teams can define how the project works, which commands to run, which libraries to prefer, and what review standards matter. This makes the tool less generic and more aligned with the actual codebase.
The best way to think about Claude Code isn’t as a code vending machine. It is closer to a careful programming colleague. Helpful, fast, and often insightful, but still capable of misunderstanding the task or making a change that needs review.
Amazon Q Developer and Cloud-Centric Development
Amazon CodeWhisperer is now part of the latest Amazon Q Developer experience that has been recently announced to shut down in 2027, while being replaced with Kiro agentic development environment.
Amazon Q Developer isn’t only about generating generic code. It is closely connected to AWS workflows. It can help developers understand AWS services, write code, generate command-line suggestions, scan for vulnerabilities, create tests, modernize applications, and work inside common IDEs.
For teams already building on AWS, this context is the value. A general chatbot can explain an S3 bucket or Lambda function. Amazon Q Developer sits closer to AWS documentation, cloud architecture patterns, IAM-aware environments, and modernization tasks.
Configuration is Becoming the Real Skill
In the first wave of AI coding tools, the main question was: can the tool write code?
Now the better question is: can the tool write code the way our project needs it written?
Modern AI development tools increasingly support repository instructions, project memory files, coding standards, tool permissions, allowed commands, security rules, custom agents, team prompts, and pull request review instructions.
This is where teams will either succeed or fail.
If an AI assistant receives a vague task in a large codebase with no guidance, it will guess. Sometimes it will guess well. Sometimes it will produce code that looks reasonable but doesn’t fit the architecture.
If the same assistant receives a clear task, known test command, architecture notes, coding standards, and review criteria, the result usually improves.
Where LLMs Help Most
LLMs are strongest when the task is clear and the result can be checked quickly. They are useful for generating first drafts, writing unit tests, creating mocks, translating code, explaining unfamiliar systems, refactoring repetitive patterns, drafting documentation, reviewing pull requests, debugging errors, and creating small scripts.
They are weaker when the task depends on hidden business rules, unclear product intent, sensitive security decisions, or architectural trade-offs that aren’t written down.
There are also privacy and governance questions. Should proprietary code be pasted into a public chatbot? Can the tool access secrets? Can it run commands? Can it open pull requests? Who reviews the output? Who is responsible if the generated code causes a problem?
Conclusion
The old dream of code generation was to save developers from repetitive work. LLMs have pushed that dream much further. We are no longer talking only about scaffolding projects or completing method names. We are talking about assistants and agents that can read repositories, modify files, run tests, write documentation, review changes, and participatein development workflows.
The software developer won’t be replaced by machines. But likely working with increasingly capable machines.