# Eight Names for One Shift, and Which Ones Hold Up

**Agent-driven, agent-first, agent-native, spec-driven, intent-driven. What each one actually means — and who was selling something when they named it.**

Checked: 30 August 2026 · auxfirst
Canonical: https://auxfirst.com/news/agentic-software-development.html

| | |
|---|---|
| Terms mapped | 8 |
| Independent anchor | 3 |
| Named by a seller | 5 |
| Checked | 30 August 2026 |

---

There are at least eight names in circulation for the same broad thing: AI agents doing meaningful work inside software development. Agentic software development. Agent-driven. Agent-first. Agent-native. Agent-assisted. Spec-driven. Intent-driven. AI-native. They overlap, they are used interchangeably in the same paragraph, and most published comparisons treat them as a settled hierarchy.

They are not a settled hierarchy. I checked where each definition actually comes from, and the pattern is worth knowing before you adopt any of the vocabulary in a strategy document: **three of the eight have a definitional source with nothing to sell. Five were named by a party selling the thing the name describes.**

That does not make the five wrong. Vendors are often first to name a real pattern, and two of these terms describe something genuinely distinct. But it changes how much weight a term can carry in a procurement conversation, an architecture decision record, or a board slide.

## Where each definition comes from

| Group | Terms | Source |
|---|---|---|
| **Independent anchor** — nothing to sell | Agentic Software Development · Spec-Driven Development · SDAD | Forrester · IBM · arXiv paper |
| **Vendor documented** — sells the tooling | Agent-First Development · Agent-Native Development · AI-Native Development | VS Code · Factory, Northflank · Microsoft |
| **Self-named** — the site is the term | Agent-Driven Development · Intent-Driven Development · Agent-Assisted Development | agentdrivendevelopment.com · intent-driven-development.com · blog.agentcohort.ai |

### The one correction worth making up front

Most taxonomies circulating right now cite Microsoft's VS Code documentation as evidence that **agent-first development** is a distinct tier of autonomy. It is not what that page says. VS Code's own wording is that the practice is *"often called agentic programming or agent-first development"* — the two are offered as synonyms for the same thing, not as separate rungs on a ladder. The eight-term hierarchy is a useful construct, but it is largely a synthesis rather than a set of industry definitions.

---

# The three that have an anchor

## Agentic Software Development — Forrester

Verbatim: agentic software development is *"the use of AI agents (aka TuringBots) that can plan, generate, modify, test, and explain software artifacts across multiple stages of the software development lifecycle (SDLC) — working alongside human developers with a degree of autonomy."*

Three things make this the strongest of the eight. It comes from an analyst firm rather than a toolmaker. It names the distinguishing property directly — Forrester's phrase is **"agency, more than assistance"**, meaning the system can take on a task, decompose it, execute steps and iterate, often asynchronously, rather than merely responding. And it puts accountability in the same sentence: the practice is *"about delegating meaningful development work to AI agents while keeping humans accountable for intent, review, and outcomes."*

**Use this as your umbrella. Everything else is a sub-case or a marketing variant.**

## Spec-Driven Development — IBM

IBM's definition: *"a software methodology in which a detailed specification of implementation details is authored and agreed upon before development begins. In other words, it serves as a single source of truth for what to build and how to build it."* Microsoft frames the same practice as spec-first AI-native engineering, opening on the observation that matters most: *"AI has made software delivery faster, but speed alone does not guarantee better outcomes."*

Writing the spec first is not new. What is new is the economics: **when code production becomes cheap, precisely defining what should be produced becomes the expensive part.**

Failure mode worth naming: a specification detailed enough for an agent to implement without ambiguity is, in some domains, close to the length of the implementation. Expect the spec to become a maintained artifact with an owner.

## Spec-Driven Agentic Development (SDAD) — arXiv, 5 May 2026

The only one of the eight with a paper behind it. SDAD is formalised as *"a synthesis of disciplined up-front formalisation and high-velocity implementation: intent capture, machine-readable specification, agentic synthesis, and independent multi-agent verification under human sign-off."*

The phrase doing the work is **"specification quality [as] the execution fuel for autonomous delivery"**. Frontier coding agents with very large context windows can now ingest substantial requirement documents and repository context in a single workflow — which shifts the constraint from how fast code can be written to how precisely the target can be described.

Two framings worth borrowing whether or not you adopt the acronym: the paper introduces **AI-code as a fourth production paradigm** alongside the historical pendulum between Waterfall and Agile, and compares **Human-Agile circa 2020 against Agentic-SDAD circa 2026** as distinct operating models rather than a tooling upgrade.

---

# The five named by someone selling something

## Agent-Driven Development — self-named

Structure development so agents perform *substantial development work*, rather than sitting beside a developer suggesting the next function. Human defines the outcome, agents plan, implement, test and review, human approves.

The operative word is **driven**. "Help me write this endpoint" is assistance. *"Implement authentication according to this spec, add tests, run them, fix the failures and prepare the PR"* is delegation — a different management problem, because you are reviewing an outcome rather than watching a process.

Worth keeping despite the provenance. It names what actually changes for an engineering manager: **the review surface moves from diffs to outcomes**, and nothing in the existing process was built for that.

## Agent-First Development — VS Code

Instead of writing each line, you direct an AI coding agent to read your codebase, make edits, run commands, fix its own mistakes and accomplish work — and *"these agents operate in a loop. You give direction, the agent acts, you course-correct, and repeat."*

The inversion is the useful part. Not *"how can AI help a developer do this?"* but *"how would an agent do this?"* That reframing makes your environment's legibility a first-class engineering concern: machine-readable documentation, clear repository structure, an AGENTS.md, accessible tests, CLI-reachable tools, MCP servers, reproducible environments, explicit acceptance criteria.

But VS Code uses the phrase as an alias for agentic programming, not as a distinct level of autonomy. **Treat "agent-first" as a design posture, not as a rung.**

## Agent-Native Development — Factory (July 2025), Northflank

The most useful distinction on this page. Agent-first is an organizational preference about how humans interact with development. **Agent-native is a claim about the infrastructure.**

| Human-native CI | Agent-native CI |
|---|---|
| developer writes code, pushes | agent creates branch, launches environment |
| opens PR | executes tests, reads failures |
| waits for CI | repairs the implementation |
| reads the errors | runs browser verification |
| fixes and repeats | produces PR **plus evidence**, asks a human for approval |

Note the date on Factory's post: **1 July 2025**. This term predates the 2026 wave by a year, which is mild evidence it describes a real engineering constraint rather than riding one. Northflank uses it the same way. Red Hat is building in the same direction, describing an agentic SDLC with a central management layer they call Org Pulse, giving *live visibility into what the system is doing*.

## Intent-Driven Development — self-named

Neither code nor the specification is the durable source of truth — **human intent is**, and both spec and implementation are derived artifacts. The chain runs *why* (business intent) → *what* (desired behavior) → constraints (security, architecture, UX) → specification → agent plan → implementation → verification.

The problem it exists to solve is genuine and getting worse: coding agents implement extremely quickly while still misunderstanding what the human actually wanted. Speed of implementation has made the cost of a misread intent higher, not lower, because more of the wrong thing gets built before anyone looks.

Whether it needs its own name is a fair question. In practice it is the first phase of spec-driven development, taken seriously.

## Agent-Assisted Development — self-named

Human is the primary actor; the agent generates tests, explains code, refactors a method, suggests an implementation, finds a bug, writes documentation. The human still controls the loop.

Worth naming precisely because **this is where the overwhelming majority of teams currently sit**, while the vocabulary in their strategy documents comes from four rungs higher. That gap produces roadmaps costed for agent-native infrastructure and staffed for agent-assisted reality.

---

# The autonomy ladder

Once you strip the branding, the terms sort onto one axis: **who holds the loop.** Not what the tool can do — what the human has to be present for.

| Level | Term | Who holds the loop | What it looks like |
|---|---|---|---|
| 1 | Agent-Assisted | Human | Generate tests, explain code, refactor a method. The developer decides every step. |
| 2 | Agent-First | Agent is default interface | You direct an agent that reads the repo, edits files, runs commands and iterates. |
| 3 | Agent-Driven | Agents execute | "Implement auth per this spec, add tests, fix failures, prepare the PR." Planner, implementer, tester, reviewer. |
| 4 | Agent-Native | The environment | CI designed for agents: branch, environment, tests, repair, verification, PR with evidence. |
| 5 | Agentic SDLC | Agents across every stage | Discovery through maintenance, with humans holding intent, review and release authority. |

This ordering is a synthesis, not an industry standard — only the endpoints have independent definitions. Useful for one purpose: locating where your team actually is before you buy tooling for where the deck says you are. The jump from level 3 to level 4 is an infrastructure programme, not a tooling purchase.

## All eight, side by side

| Term | What it emphasizes | Primary source | Anchor |
|---|---|---|---|
| Agentic Software Development | Agents across the SDLC | Forrester | Independent |
| Spec-Driven Development | Specs drive agent execution | IBM · Microsoft | Independent |
| SDAD | Spec + agents + independent verification | arXiv 2608.20341 | Independent |
| Agent-First Development | Agent is the default interface | VS Code | Vendor |
| Agent-Native Development | Environment redesigned for agents | Factory · Northflank | Vendor |
| AI-Native Development | AI is structural, not additive | Microsoft | Vendor |
| Agent-Driven Development | Agents drive execution | agentdrivendevelopment.com | Self-named |
| Intent-Driven Development | Human intent is the source of truth | intent-driven-development.com | Self-named |
| Agent-Assisted Development | Agents help humans | blog.agentcohort.ai | Self-named |

> Intent-driven says *why*. Spec-driven says *what done means*. Agent-first says how humans interact. Agent-driven says who executes. Agent-native says what the environment is optimized for.

---

# What actually changes

**One. The expensive artifact moved.** When producing code was the constraint, the spec could be thin and the code carried the meaning. When production is cheap, the spec carries it. A team that adopts agents without moving effort upstream simply produces more of whatever it was already misunderstanding.

**Two. The review surface changed shape.** Reviewing a diff written by a colleague and reviewing an outcome produced by an agent are different activities. The diff review assumes a shared mental model you can interrogate. The outcome review does not — and most engineering organizations have no process for the second one, because it never existed before.

**Three. The environment became a dependency.** Machine-readable docs, an AGENTS.md, CLI-reachable tools, reproducible environments and explicit acceptance criteria stop being hygiene and start being throughput. An agent in a poorly documented repository is not slower; it is *confidently wrong*, which is worse.

## The SDAD pipeline, and the two steps that stay human

1. **Human intent** — what the business actually wants. The only thing here a model cannot supply.
2. Specification — machine-readable, with acceptance criteria.
3. Agentic synthesis — planning and implementation agents. The cheap part, and the part every demo shows.
4. Independent verification — a separate agent, or several, checking against the spec rather than against the implementer's own reasoning.
5. **Human sign-off** — release authority. Non-delegable.

Independent verification is the step most implementations skip, because it costs agent time and produces nothing visible when it passes.

# The bottleneck nobody put in the taxonomy

Every one of the eight terms describes how work gets produced. None describes what happens when it needs checking — and that is where the constraint has actually moved.

We scored twelve enterprise platforms on two axes in the [Agent Supervision Register](https://auxfirst.com/news/agent-supervision-register.html): what the agent can do without a person present, and what the person accountable for the work can see, approve or reverse afterwards. **Median capability came out at 11 of 12. Median supervision, 6.** Not one of the eleven scored platforms documented a way to reverse the work an agent had performed.

Agents produce faster than people verify. That is not a temporary tooling gap — it is the arithmetic of the arrangement. Add a level of autonomy and you multiply output; the review queue does not multiply with it. **Review is the new bottleneck, and it is a headcount problem wearing a tooling costume.** The term for this does not exist in any of the eight vocabularies, which tells you something about who has been doing the naming.

An implementer agent checking its own work is not verification. It is the same reasoning run twice.

# What to do with this

**Pick one umbrella term and define it in writing.** Use *agentic software development* if you want the one with an analyst definition behind it. The specific choice matters far less than having a single term in your architecture decision records.

**Locate your actual level before you buy for a higher one.** Most teams are at agent-assisted and planning for agent-native. The honest test is the CI comparison above: if a failing test still means a human reads the log, you are not agent-native regardless of what you have licensed.

**Move effort upstream before you add autonomy.** If your acceptance criteria are not machine-readable today, more agent autonomy will produce more work that meets nobody's definition of done.

**Size the review queue before it sizes you.** Work out how much output an added level of autonomy generates and who is reading it. If the answer is "the same three seniors", the autonomy is theoretical.

**Make the environment legible first.** The cheapest item on the list and the best return: an AGENTS.md, documentation agents can read, tests reachable from a command line. The [context file checker](https://auxfirst.com/tools/context-file-checker.html) lints those files in the browser, free.

---

## Method

Every definition quoted above was fetched and read on 30 August 2026, and direct quotations are marked. Where a widely repeated claim did not survive that check — specifically, the use of Microsoft's VS Code documentation to establish agent-first development as a distinct autonomy tier — the correction is stated in the body rather than dropped quietly. The five-level ladder and the anchor classification are auxfirst's reading, not industry standards, and are labeled as such.

## Sources

**Independent definitions**
1. *Agentic Software Development: Defining The Next Phase Of AI-Driven Engineering Tools* — Forrester. https://www.forrester.com/blogs/agentic-software-development-defining-the-next-phase-of-ai-driven-engineering-tools/
2. *SDAD: Spec-Driven Agentic Development for the AI-Native SDLC* — arXiv:2608.20341, submitted 5 May 2026. https://arxiv.org/abs/2608.20341
3. Anna Gutowska — *What is spec-driven development?* IBM, 19 May 2026. https://www.ibm.com/think/topics/spec-driven-development

**Vendor documentation**
4. Apoorv Gupta — *Spec-Driven Development: A Spec-First Approach to AI-Native Engineering*. Microsoft, 10 June 2026. https://developer.microsoft.com/blog/spec-driven-development-ai-native-engineering/
5. *Introduction to agent-first development* — Visual Studio Code. https://code.visualstudio.com/learn/foundations/introduction-to-agent-first-development
6. *Core concepts of Red Hat's agentic software development life cycle* — Red Hat. https://www.redhat.com/en/blog/building-future-core-concepts-red-hats-agentic-software-development-life-cycle
8. *Agent Native Development* — Factory, 1 July 2025. https://factory.ai/news/build-with-agents
11. *Agent-native software development* — Northflank. https://northflank.com/blog/agent-native-software-development

**Self-named sources**
7. *What Is Agent Driven Development?* — agentdrivendevelopment.com. https://agentdrivendevelopment.com/what-is-agent-driven-development/
9. *What is Intent-Driven Development?* — intent-driven-development.com. https://www.intent-driven-development.com/what-is-idd
10. *What Is Agent-Assisted Development: A 2026 Field Guide* — Agent Cohort. https://blog.agentcohort.ai/blog/what-is-agent-assisted-development-a-2026-field-guide

**Related on auxfirst**
- The Agent Development Lifecycle. https://auxfirst.com/agent-development-lifecycle.html
- The Agent Supervision Register. https://auxfirst.com/news/agent-supervision-register.html
- How we score agent supervision. https://auxfirst.com/news/agent-supervision-method.html
- The Action Heat Ladder. https://auxfirst.com/action-heat-ladder.html
- The 40th Principle: who verifies the other 39? https://auxfirst.com/news/the-40th-principle.html
- AGENTS.md for teams that don't write code. https://auxfirst.com/news/agents-md-for-non-engineering-teams.html
- WebMCP for B2B SaaS. https://auxfirst.com/news/webmcp-b2b-saas.html
- The Agent Operability Audit. https://auxfirst.com/agent-operability-audit.html

---

*Emil Krzemiński is the founder of auxfirst (https://auxfirst.com/), the agentic experience design agency. For how machines read auxfirst, see https://auxfirst.com/ai-info.html.*