AI-Native Development Glossary: Agentic Coding, Vibe Coding & 16 More Terms Defined

The vocabulary of AI-native development moves faster than the dictionaries. New terms — agentic coding, vibe coding, MCP, context engineering, subagents — get coined on X, shipped in a CLI, then absorbed into how teams work, all inside a quarter. This page is the canonical reference: every term gets a crisp, quotable definition first, the origin facts most glossaries skip, and a map to where the skill sits on the 7-level AI-Native Developer model — from L1 Chat-Assisted Developer to L7 Universal AI Creator.

Each entry ends with the same honest question: which level does this put you at? When you're done reading, take the 3-minute quiz and find out.

Jump to a term

Term	Maps to	Term	Maps to
AI-native developer	L1–L7	evals	L6
Agentic coding	L3	worktrees	L5+
Agentic engineering	L4–L5	Context engineering	L4–L6
Vibe coding	Off-ladder	Spec-driven development	L4–L6
AI-assisted development	L1–L7	Autonomous coding agent	L3→L5
MCP	L5–L6	Prompt engineering	L1–L2
Agent orchestration	L5	AI coding maturity model	the model
Subagents	L5+	Model routing	L5–L6
Plan-before-code	L3–L4	Verification harness	L4–L5

---

AI-native developer

An AI-native developer is a developer whose default workflow is to direct AI systems to plan, write, test and ship code, rather than typing most lines by hand. It's measured by autonomy and verification habits — not by how many AI tools you have installed.

Almost every developer now "uses AI." That's not the same thing. Being AI-native is a posture, not a toolbelt: the AI is your primary production mechanism, and your job shifts toward direction, review and verification. The dividing question isn't do you use an AI assistant? — it's how much do you delegate, and how do you check the result?

This is precisely the trait the 7-level AI-Native Developer model grades, from L1 Chat-Assisted Developer (the "Old-School Artisan" who copy-pastes from a chat tab) up to L7 Universal AI Creator (one person running a full product cycle with agents). Where you land depends on autonomy and verification, not vibes.

Which level does this put you at? Take the quiz →

Agentic coding

Agentic coding is a development approach where autonomous AI agents plan, write, run, test and modify code across multiple steps with minimal human intervention, using tools — shell, file edits, test runners — inside a feedback loop until the task is done.

The key word is loop. Single-turn chat autocomplete hands you a snippet and stops; an agentic coding agent owns the whole task. It reads the repo, makes a plan, edits files, runs the tests, reads the failures, and tries again — iterating across a long trajectory rather than answering one prompt. Google Cloud defines it as a software development approach where autonomous AI agents plan, write, test and modify code with minimal human intervention; IBM frames the underlying coding agents as AI systems that combine LLM reasoning with access to coding tools to act across multiple steps.

On the ladder, agentic coding is the signature of L3, the Agentic Developer ("The Agentic Native") — where the agent writes the routine, you plan before you code, and you don't take its word for it. Go deeper in the agentic coding pillar or see the level itself at L3 →.

Which level does this put you at? Take the quiz →

Agentic engineering

Agentic engineering is the professional discipline of orchestrating AI coding agents as force-multipliers while the human retains responsibility for architecture, quality and verification. Agents do most of the typing; the engineer directs, constrains and validates.

If agentic coding is the technique, agentic engineering is the rigor around it. According to MindStudio, it's the practice of orchestrating AI coding agents to do most of the coding while the human keeps ownership of architecture, code quality and engineering judgment — framed as the disciplined 2026 successor to vibe coding. The emphasis is on specs, evals, review and reproducibility rather than "accept and hope."

This maps to the L4–L5 band — the Director and the Orchestrator — where you stop typing routine and start building the system that produces it. See how vibe coding and agentic engineering pull apart in vibe coding vs agentic coding, or browse the full levels.

Which level does this put you at? Take the quiz →

Vibe coding

Vibe coding is building software by prompting an AI and accepting its output without reviewing the code. Andrej Karpathy coined the term on February 2, 2025, describing fully giving in to the vibes and forgetting the code exists — accepting AI changes without reading the diffs.

Simon Willison sharpened it into a usable test: vibe coding is "building software with an LLM without reviewing the code it writes." His corollary is the part senior developers care about — if you review, test and can explain the code, "it's software development," not vibe coding. That line is the whole game. Vibe coding is great for throwaway prototypes and weekend experiments; it's a liability the moment the thing has to run in production unattended.

Critically, vibe coding sits off the L1–L7 engineer ladder. It produces the Vibe Builder archetype: a no-code/AI creator who ships real products with AI app-builder tools without writing traditional code — AI-native from day one, but a different species than the engineer climbing the maturity ladder. That's not a demotion; it's a different game with its own superpower (speed) and its own ceiling. More in vibe coding and the head-to-head vibe coding vs agentic coding.

Which level does this put you at? Take the quiz →

AI-assisted development

AI-assisted development is any workflow where AI tools — autocomplete, chat, or agents — help write or modify code while a human stays in the loop reviewing and deciding. It's the broad umbrella spanning everything from L1 to L7.

Think of it as the superset. Both vibe coding and agentic coding live inside AI-assisted development; what separates them is how much autonomy you grant and how you verify the output. Grant little and review everything by hand, and you're an early-ladder delegator. Grant a lot but wire a verification harness, and you're doing disciplined agentic engineering. The term itself is deliberately wide — which is exactly why a leveled model is useful for locating yourself inside it.

The 7-level model is the map that turns this umbrella into a spectrum you can stand somewhere on.

Which level does this put you at? Take the quiz →

MCP (Model Context Protocol)

MCP (Model Context Protocol) is an open standard that lets AI models connect to external tools and data sources through one universal interface, instead of bespoke per-tool integrations. Anthropic introduced and open-sourced it on November 25, 2024 (spec version 2024-11-05), with Python and TypeScript SDKs.

The mental model people reach for is "USB-C for AI tools": one protocol, and any compliant client can talk to any compliant server — your docs, your database, your issue tracker, your shell. Before MCP, every integration was a one-off; after it, the agent's reach becomes a plug-in ecosystem. Adoption spread broadly across the industry through 2025–2026, and you can read the primary source in Anthropic's announcement.

Connecting an off-the-shelf MCP server is something most AI-assisted developers can do early. But governing MCP across a team — deciding what agents are allowed to reach and authoring reusable servers — is an L5–L6 Methodologist signal. See L6 → and the related entry on agent orchestration.

Which level does this put you at? Take the quiz →

Agent orchestration

Agent orchestration is coordinating multiple AI agents — assigning tasks, sequencing steps, managing shared state and merging results — so a team of agents completes work that a single agent cannot do reliably alone.

The dominant shape is the orchestrator-worker (manager-worker) pattern: one agent plans and delegates while bounded worker agents execute and report back. Per Claude Code's documentation, in this pattern the orchestrator owns the plan and each worker handles a scoped task — the structure that makes multi-agent work tractable instead of chaotic.

This is the defining trait of L5, the AI Engineering Architect ("The Orchestrator") — the level where you design the agent stack rather than just drive one agent. See L5 →, then the building blocks: subagents and worktrees.

Which level does this put you at? Take the quiz →

Subagents

Subagents are isolated worker agents a primary agent delegates to, each running with its own fresh context, tool access and permissions, and returning a single summary — keeping the main agent's context clean and the work parallelizable.

Subagents are how orchestration stays sane. Instead of one bloated context window juggling everything, the primary agent spins off scoped workers, each with a clean slate, and gets back a tidy result. According to Claude Code's documentation, each subagent runs with its own context, tools and permissions — and cannot spawn further subagents, so nesting is bounded by design. That bound is a feature: it prevents runaway agent trees.

Routine subagent use is an L5+ behavioral signal — you've moved from driving one agent to fielding a small team. See L5 → and the broader pattern at agent orchestration.

Which level does this put you at? Take the quiz →

Plan-before-code

Plan-before-code is an agentic-coding discipline where the agent (or human) produces an explicit plan and gets it approved before writing any code — so intent is verified up front and the implementation step stays bounded and checkable.

It's a cheap insurance policy. A few minutes spent confirming "here's what I'm about to do and why" prevents the expensive failure mode of an agent confidently editing twenty files in the wrong direction. It also burns fewer tokens and produces diffs you can actually reason about. Plan-before-code is the gateway habit that leads naturally into spec-driven development.

This is an L3–L4 maturity habit — the moment you stop letting agents free-run and start gating them on an approved plan.

Which level does this put you at? Take the quiz →

Verification harness

A verification harness is the set of automated checks — tests, linters, type-checks, build and run scripts — wired so an AI agent can verify its own work in a loop and self-correct, without a human reading every diff.

This is the single thing that makes high-autonomy ("YOLO") agentic coding safe instead of reckless. An agent with a strong harness can run hot — try a change, run the checks, read the failures, fix, repeat — because the checks catch its mistakes before you do. An agent without a harness is just unreviewed risk moving fast. The harness is what converts trust into a system rather than a hope.

Building reusable harnesses is the L4–L5 dividing line — it separates "I review every change" from "I trust the loop and review the outcome." See the levels →, then pair this with evals.

Which level does this put you at? Take the quiz →

Evals

Evals are systematic tests that measure whether an AI model or agent produces correct, reliable outputs. For coding agents, evals check whether the agent plans, calls tools and completes multi-step tasks correctly across a whole trajectory — not just whether the final answer looks right.

There are two main forms, according to Confident AI: code-based evals (automated, CI-style assertions) and LLM-as-a-judge. For coding work, trajectory matters because a run spans many steps — an agent can produce the right file for the wrong reasons, or take a dangerous path to a passing test. Evals catch that. They're the difference between "it worked once" and "it works reliably."

Writing and maintaining evals is an L6 Methodologist signal — you're not just using agents, you're measuring and certifying their behavior. See L6 → and its sibling, the verification harness.

Which level does this put you at? Take the quiz →

Worktrees

Git worktrees are separate working directories that share one repository's history, so several AI agents can each work on an isolated branch or checkout in parallel — without overwriting each other's files.

This is the standard mechanism for running multiple Claude Code sessions on one codebase at once. Per Claude Code's documentation, a worktree is a separate working directory with its own branch sharing the same repository history, which lets multiple agents work in parallel on isolated checkouts. In practice you pair worktrees with port and database isolation so the parallel agents don't collide outside the filesystem either.

Parallel-agent workflows in worktrees are an L5+ trait — the L4 Director already runs several agents this way, and the L5 Orchestrator systematizes it. See agent orchestration and L5 →.

Which level does this put you at? Take the quiz →

Context engineering

Context engineering is, in Andrej Karpathy's June 2025 phrasing, "the delicate art and science of filling the context window with just the right information for the next step." It's the discipline of designing everything an LLM sees: instructions, retrieved docs, tool outputs, memory and state.

Karpathy endorsed the term over "prompt engineering" in June 2025, and Anthropic formalized the concept in September 2025. The reframe matters: in production agent systems, the wording of any single prompt is a small slice of what determines output quality. As Glean puts it, prompt engineering is a subset of context engineering — the full context also includes conversation history, retrieved documents, tool outputs and agent state. The quality gap between AI users today is context, not magic words.

Deliberate context engineering is an L4–L6 signal — it's what people are doing when they curate CLAUDE.md files, design retrieval, and budget the context window on purpose. Contrast with its subset, prompt engineering, and see the levels →.

Which level does this put you at? Take the quiz →

Spec-driven development

Spec-driven development is a methodology that makes a written specification the source of truth AI agents use to generate, test and validate code. You write the spec first, then a plan, then small testable tasks, then implementation.

According to GitHub, the specification becomes a contract for how the code should behave — the source of truth that tools and AI agents use to generate, test and validate code. GitHub announced and open-sourced Spec Kit (MIT-licensed) on September 2, 2025, with the core flow Spec → Plan → Tasks → Implement, explicitly positioned as a repeatable, disciplined alternative to ad-hoc vibe coding. It's plan-before-code, taken to its logical conclusion.

Spec-driven workflows are an L4–L6 maturity marker. They build on plan-before-code and sit at the heart of how Directors and Methodologists ship. See the levels →.

Which level does this put you at? Take the quiz →

Autonomous coding agent

An autonomous coding agent is an AI system that takes a goal and independently plans, edits files, runs commands and tests, and iterates until done — operating over a long multi-step trajectory rather than answering a single prompt.

CLI agents like Claude Code are the canonical example. The important nuance is that autonomy is a spectrum, not a switch: how far you let an agent run unattended ("YOLO mode") is gated by two things — your verification harness and the permissions you grant it. Strong harness plus tight permissions equals safe autonomy. Weak harness plus broad permissions equals a bad afternoon.

Learning to trust autonomous agents without breaking production is the L3 → L5 progression itself: from "the agent writes the routine" to "the agent runs multi-ticket cycles end to end." See the levels →.

Which level does this put you at? Take the quiz →

Prompt engineering

Prompt engineering is the practice of crafting the textual instructions given to an LLM — wording, examples, role and output format — to steer it toward a desired single-turn result.

It still matters; clear instructions still beat sloppy ones. But the field has reframed it as one component of a larger discipline. In production agent systems, the prompt is a small fraction of the total context, which also includes history, retrieved docs, tool outputs and state — which is why context engineering has become the more useful frame.

Prompt engineering is an L1–L2 staple that matures into context engineering around L4. It's where most people start; it's not where the ceiling is.

Which level does this put you at? Take the quiz →

AI coding maturity model

An AI coding maturity model is a leveled framework that grades how AI-native a developer or team is — by autonomy and verification behavior, not tool count. ProCoders' 7-level AI-Native Developer model (L1 Chat-Assisted → L7 Universal AI Creator) is one; Steve Yegge's 8 stages of agentic workflow is another.

Maturity models give a fast-moving field shared vocabulary for the trust gradient — the slope from "AI autocompletes a line" to "I built my own orchestrator." Yegge's 8 levels describe that same gradient from near-zero AI use up to building your own orchestrator, with the critical break at stage 5–6 where a single synchronous agent gives way to multiple parallel agents (per Augment Code's summary). The leveled framing is what lets teams talk about direction instead of just tools.

The canonical example on this site is the model — the named 7-level AI-Native Developer model, with personas and concrete behavioral signals for each rung. The fastest way to use it is the quiz.

Which level does this put you at? Take the quiz →

Model routing

Model routing is automatically choosing which AI model or provider handles each request based on cost, latency, capability and availability — sending easy tasks to cheap models and hard ones to frontier models, with fallbacks.

It's a cost-and-reliability lever, and the spread is large enough to matter: per OpenRouter, per-token cost between frontier and cheaper models can differ roughly 10x–50x, and platforms like OpenRouter expose routing controls and price caps. Route a fleet of agents intelligently and you reserve the expensive frontier models for the work that genuinely needs them while cheaper models absorb the easy volume.

Routing models across an agent fleet — and setting the policy for it — is an L5–L6 architect signal; the L5 Orchestrator owns the model-routing policy across the team's agents. See L5 →.

Which level does this put you at? Take the quiz →

---

How these terms map to the ladder

Definitions are only half the story. The reason this glossary ties every term to a level is that the same word means different things at different maturity. "Using MCP" is an early signal; "governing MCP" is a senior one. "Running an agent" is L3; "orchestrating a fleet in worktrees" is L5. Here's the compressed map:

Level	Persona	Glossary terms that signal it
L1 Chat-Assisted	Old-School Artisan	prompt engineering
L2 AI-Assisted Junior	Delegator	prompt engineering, AI-assisted development
L3 Agentic Developer	Agentic Native	agentic coding, plan-before-code, autonomous coding agent
L4 System Builder	Director	verification harness, spec-driven development, context engineering
L5 Engineering Architect	Orchestrator	agent orchestration, subagents, worktrees, model routing
L6 Methodologist	Methodologist	evals, MCP governance, portable methods
L7 Universal AI Creator	Creator	full-cycle solo across all of the above
Off-ladder	Vibe Builder	vibe coding

That last row is the distinction the generic glossaries miss. Vibe coding isn't a low rung — it's a different ladder entirely. The Vibe Builder ships products without traditional code; the L1–L7 engineer climbs toward directing systems that do. Both are legitimate; they're just not the same path.

Find your level

Reading definitions tells you what the words mean. The quiz tells you where you stand on the 7-level AI-Native Developer model — based on your real autonomy and verification habits, in about three minutes.

Take the quiz → /quiz