How AI Changed Software Development
AI did not arrive in software development as one event. It arrived as a sequence of capability steps, each moving a bit more of the work — and a bit more responsibility — from the developer's hands to the tool. This page names those steps, shows what the developer still does at each one, and explains what has really changed about the job.
Traditional Development
Before any AI tooling, the developer personally performs every step of a change: read the code to understand it, decide what to change, type the change, build, run the tests, read the failure, and repeat. Tools helped with individual steps — syntax highlighting, refactoring menus, debuggers — but the developer carried the whole loop in their head.
Code Completion and AI Autocomplete
What it does: as you type, the tool proposes the next few tokens or lines, and you accept or ignore the suggestion. Classic IDE autocomplete suggested names from a symbol table. AI autocomplete predicts whole lines or bodies from the surrounding code — the next-token mechanism from Chapter 1 applied to your open file.
Dated anchor: GitHub announced a technical preview of Copilot on 29 June 2021, described in press coverage as autocomplete-like pair-programming support powered by OpenAI Codex (Source 1). GitHub's own announcement post was not retrieved for this page; coverage that quotes it was used instead.
| You still do | The tool does | Typical weakness |
|---|---|---|
| Everything except typing the next line: decide, read, build, test, debug. | Predict the likely continuation from nearby code. | Sees mostly the open file, so it can suggest code that conflicts with the rest of the project. |
AI Chat Assistants
What it does: you describe a problem in conversation and the model replies with an explanation or code. This opened up questions — "why does this stack trace happen?" — that autocomplete could not take. The model, however, only knows what you paste in.
| You still do | The tool does | Typical weakness |
|---|---|---|
| Choose what context to paste, apply the answer, run it, report back. | Explain, draft and revise code from what you provided. | Cannot see your repo or run your tests, so it may answer for a project that is not yours. |
AI Coding Assistants Inside the IDE
What it does: the assistant lives in your editor, can see selected files or the repository, and edits code in place. GitHub's current description of Copilot covers inline suggestions, questions and explanations about files and repositories, code review, refactoring, and customisation with instructions and reusable prompts (Source 2).
The key change from chat is context supplied by the tool: you no longer hand-pick every snippet. The remaining gap is that the assistant mostly proposes; you still build, run and verify.
| You still do | The tool does | Typical weakness |
|---|---|---|
| Review each proposed edit, run the build and tests, drive the next step. | Gather repository context, draft multi-line or multi-file edits. | Quality depends on which context it selected; it may miss a relevant file. |
Agentic Coding Systems
What it does: you state a goal, and the tool carries out the loop itself — searching code, editing files, running commands and tests, reading the results, and trying again. Anthropic's Claude Code documentation describes this as a loop of gathering context, taking action and verifying results, and describes Claude Code as "an agentic coding tool that reads your codebase, edits files, runs commands" (Source 3).
Dated anchor: Anthropic introduced Claude Code on 24 February 2025 as a limited research preview alongside Claude 3.7 Sonnet, according to press coverage (Source 4). It is no longer described as a preview in current documentation. Other vendors ship agentic tools too: GitHub documents a Copilot cloud agent that researches a repository, plans changes, edits files, runs tests and linters, and opens a pull request (Source 5).
Autonomous and Multi-Agent Workflows
The next step is not one smarter agent but several cooperating ones. Here it is important to separate what is documented today from what is experimental.
| Capability | Status as documented (2026-10-30) | Source |
|---|---|---|
| Subagents: separate workers with their own context window that return a summary | Documented Claude Code feature | 7 |
| Dynamic workflows: scripts that run many subagents and return one result | Documented in the features overview | 8 |
| Agent teams: coordinated sessions that message each other | Disabled by default; enabled with an experimental environment flag | 9 |
| Autonomous cloud agents that take a ticket to a pull request | Offered by several vendors (for example GitHub's cloud agent, Devin); behaviour and limits vary by product | 5 |
Subagents and workflows are explained properly in later chapters. For now, note the pattern: each step hands the tool a larger, longer-running piece of the loop — and each step raises the cost of a wrong assumption.
The Developer's Role
| Concern | Traditional | AI-assisted (stages 2–4) | Agent-driven (stage 5+) |
|---|---|---|---|
| Who writes the first draft | Developer | Tool proposes, developer accepts or edits | Agent writes; developer reviews the diff |
| Who runs build and tests | Developer | Developer | Agent, within the permissions granted |
| Main skill under pressure | Implementation speed and recall | Choosing context; spotting wrong suggestions | Stating intent precisely; verification; knowing when to stop the agent |
| Typical failure | Slow delivery, human bugs | Plausible but wrong snippet accepted | Confident multi-file change built on a wrong assumption |
| Accountability | Developer | Developer | Developer — unchanged |
The second column is not "less engineering". Step 3 — judging whether the diff is right and whether the evidence actually proves it — is the engineering. It is also why Anthropic's agent guidance recommends starting with the simplest solution that works and adding autonomy only when it measurably helps (Source 10).
Key Takeaways, Exercises and Sources
- The change is gradual: manual, autocomplete, chat, in-IDE assistants, agents, then multi-agent setups.
- The dividing line is who closes the loop. In chat you do; an agent runs tools and reads results itself.
- The developer moves from typing to directing and verifying. Accountability does not move.
- Separate documented from experimental. Subagents are documented Claude Code features; agent teams are off by default and experimental.
- Dates here are limited on purpose. Only two dated anchors were verified; other dates were left out rather than guessed.
Exercise 1 Beginner
Think of the last bug you fixed. List each step you took, then mark which of the five stages could have done that step for you and which you would still have wanted to do yourself.
Learning outcome: map real work onto the stages.
Exercise 2 Intermediate
Take one tool you already use (Copilot, ChatGPT, an IDE assistant). Using its own documentation, classify it into stages 2–5 and write down one thing it still needs you to do.
Learning outcome: judge a tool by what it does, not its marketing label.
Exercise 3 Advanced
Write a one-page review checklist you would apply to an agent-produced diff (for example: does a test fail without the change, are unrelated files untouched, are new dependencies justified). Keep it to ten items.
Learning outcome: turn "review everything" into a concrete, repeatable verification habit.
- Visual Studio Magazine, GitHub Copilot (29 Jun 2021) — launch of the Copilot technical preview. Secondary coverage; seen through a web search summary, as GitHub's own post was not retrieved.
- GitHub Docs, What is GitHub Copilot? — current feature description.
- Anthropic, Claude Code overview and How Claude Code works — agentic loop and definition.
- SD Times, Anthropic releases Claude 3.7 Sonnet and Claude Code, and Simon Willison, 24 Feb 2025 — launch as a research preview. Seen through web search summaries; Anthropic's original announcement was not retrieved.
- GitHub Docs, About Copilot cloud agent; Cognition, Devin documentation.
- Anthropic, Claude Code security — user responsibility statement.
- Anthropic, Subagents.
- Anthropic, Extend Claude Code — dynamic workflows.
- Anthropic, Manage costs — agent teams disabled by default, experimental flag.
- Anthropic, Building effective agents — start with the simplest solution; agents cost more and errors compound.