From code to intent

First, a shared vocabulary. A chatbot produces a response and waits. An agent runs its own loop: you give it a goal, and it decides the next step.

The climb: from autocomplete to autonomy

The agent loop — click each step

The 5 parts of every agent

In Feb 2025, Andrej Karpathy described vibe coding: "fully give in to the vibes, forget that the code even exists." The term went viral — and became a confusing umbrella. In 2026, Karpathy himself proposed agentic engineering for the disciplined end. It's not a binary: it's a spectrum. The differentiator isn't whether you use AI — it's how much structure, verification and human judgment surrounds the output.

The quality of generated code depends less on prompt cleverness and more on the quality of the context provided. The question isn't "how do I trick the AI?" — it's: "what would a new team member need to know to contribute well, and how do I encode that?"

The 6 types of context every agent needs

Static × Dynamic: the architecture trade-off

What is static and what is dynamic is a first-class architectural decision — reviewed and versioned like any other configuration. Too much static wastes tokens; too little and the agent forgets critical rules.

Agent Skills — the winning pattern (click the tabs)

skills_available:
  - deploy-agent:    "deploy ADK agents to Agent Runtime"
  - eval-runner:     "runs evalsets and reports regressions"
  - db-migration:    "safe schema migrations"
  - legacy-refactor: "legacy code refactoring"
  ... (dozens more)

loading skill: deploy-agent
  ✓ pre-deploy checklist (env vars, permissions)
  ✓ publishing steps to Agent Runtime
  ✓ automatic rollback rules

deep reference: deploy-agent/reference.md
  ✓ full agents-cli flags catalog
  ✓ permissions matrix per environment
  ✓ deploy incident runbook

Skills solve 4 classic problems: context rot (overloaded prompts), the lack of procedural memory in LLMs, the overhead of multi-agent architectures, and the need for portability across tools and vendors.

AI compresses the cycle unevenly: implementation that once took weeks now takes hours, while requirements, architecture and verification remain at human pace. The result is not a faster old SDLC — it's a different workflow, with phases that blur and iteration cycles of minutes.

The compression (animated)

Phase by phase — explore

The mental model that ties it all together: the developer's primary output is not the code — it's the system that produces code. A factory manager doesn't assemble every widget by hand: they design the assembly line and ensure quality control.

The 5 parts of your factory

It's tempting to treat the model as the system: "a new model came out, the agent got smarter." That intuition is wrong. The model is one input. Everything else — prompts, tools, context policies, hooks, sandboxes, sub-agents, observability — is the harness: the scaffolding that lets the model actually finish things.

The harness in every SDLC phase

Two working modes you'll fluidly alternate between. Neither is "better" — each serves a type of task.

The 80% problem — click the bar

Three places in your day — and most devs use all three on the same day. The right starting point depends on the task, not on which category sits higher on the autonomy ladder.

And when the product is an agent?

A support bot, a research assistant, a compliance monitor — these aren't tasks for a coding agent to solve: they're products that need their own persistent memory, scoped permissions, eval coverage and observability. The same terminal workflow that produces prototype scripts now reaches these production agents — the build → evaluate → deploy → observe → refine cycle lives in one place:

The conversation usually starts and ends with "how fast can we write code?". For leaders, the critical metric is TCO — and in the AI era, OpEx is dictated by the token economy.

Context as a financial lever + intelligent routing

The transition from syntax to intent is not a future prediction — it's a present reality. Developers are already spending more time describing what they want than specifying how to build it. The SDLC is already being compressed, restructured, and reimagined around AI capabilities. The question is not whether this transformation will happen, but how effectively individual developers, teams, and organizations will navigate it.

The framework presented in this paper — the spectrum from vibe coding to agentic engineering, the conductor-to-orchestrator model of developer roles, the taxonomy of ambient, workflow, and autonomous agents, and the factory model of software production — provides a set of mental models for making sense of a rapidly evolving landscape. These models will remain useful even as the specific tools and capabilities evolve.

Three durable principles

We're at the beginning of a transformation that will reshape not just how software is built, but what kind of software is possible to build. Smaller teams will be able to tackle larger problems. Individual developers will be able to build and maintain systems that previously required entire departments. The barrier to creating software will continue to fall, opening the practice of software development to a broader population.

The teams that thrive will be those that embrace AI as a powerful tool while maintaining the engineering discipline that has always been the foundation of reliable software. They'll be the ones who understand that the future of software engineering isn't about choosing between human expertise and AI capability — it's about designing systems where both contribute their unique strengths.

8 questions covering the whole guide. No rush — each answer's explanation is part of the study.

Three artifacts you can use today. Click copy and paste into your project.

# AGENTS.md

## Stack
TypeScript 6.x · Next.js 16 · Postgres (Drizzle ORM) · Vitest

## Conventions
- Pure functions whenever possible; errors via Result<T, E>, never bare throw
- Names in English, comments explain "why", not "what"
- Every API handler validates input with zod before touching the database

## Hard rules (unbreakable)
- NEVER commit secrets; use env vars via .env.local
- NEVER install a dependency without confirming with me
- NEVER modify migrations already applied in production

## Workflow
1. Read docs/ before implementing  2. Write the test first
3. Run `pnpm test` until green     4. Describe the diff before committing

# REVIEWING AI-GENERATED CODE

[ ] Real imports          — does each package exist? compatible version?
                              (dependency hallucination is error #1)
[ ] Nothing "too clever"  — if it looks too clever, be suspicious;
                              code the team doesn't understand = debt
[ ] Real error handling   — covers realistic failure modes, not just
                              the happy path that passes the test
[ ] Business edge cases   — the AI doesn't know your refund rule;
                              verify business-logic assumptions
[ ] Trajectory, not just output — did the agent RUN the tests or just
                              say it did? check logs / CI hooks
[ ] Secrets and permissions — nothing hardcoded; minimal access scope
[ ] You could explain this diff — if you can't explain it, don't ship it

# THE NEW SDLC — MIND MAP

shift       : syntax → intent (you say WHAT, the machine the HOW)
spectrum    : vibe coding ──────── ai-assisted ──────── agentic eng.
divider     : verification (tests = deterministic · evals = non-determ.)
skill       : context engineering (6 types: instructions, knowledge,
              memory, examples, tools, guardrails)
trade-off   : static context (always paid) × dynamic (paid on demand)
key pattern: Agent Skills — lightweight generalist becomes specialist on demand
factory     : your output is the SYSTEM that produces code, not the code
harness     : AGENT = MODEL + HARNESS · agent failures ≈ config failures
roles       : conductor (real-time) ⇄ orchestrator (async, multi-agent)
80/20       : AI does 80% fast; your value is in the 20% (edge, integration, subtlety)
economics   : vibe = CapEx↓ OpEx↑↑ · agentic = CapEx↑ OpEx↓ + model routing
motto       : "Generation is solved. Verification, judgment and direction are the new craft."

Check the boxes as you progress. Progress is saved in your browser.

This guide is Day 1 of a series. The full series has four companions that deepen the themes introduced here — note where to go next.

The original sources underpinning this guide, for when you want to go beyond the summary.

The numbered footnotes from the original paper, so you can trace each claim to its source.