Agentic Development
How day-to-day engineering changes once coding agents — not autocomplete — sit at the centre of the loop. The patterns here describe the shift from typing code to directing agents that run, observe, and iterate.
The first wave of AI coding tools suggested the next few tokens. The shift now underway is larger: agents take a goal, plan, execute, observe results, and correct themselves. That changes what a developer's day looks like, what a team agrees on, and where human judgment is best spent.
This theme collects the patterns at the centre of that shift — the approaches teams are converging on as agents move from novelty to default.
Letting the model drive -- describing intent in natural language, accepting the generated code, and running it without reading most of it. Coined by Andrej Karpathy, the term took off fast and split the community: a liberating way to build prototypes and personal tools, a liability when unreviewed code reaches production.
TechThe structured counterpart to vibe coding: before the agent writes code, you produce a specification -- requirements, design, and a task breakdown -- as an editable, human-readable artifact, and the agent builds against it. The spec captures intent durably so it outlives the chat history and the model's context window.
TechThe interface you drive AI through keeps adapting as autonomy rises -- from completions in the editor, to side chat, to agents on your code, to background agents in the cloud, to spec-, chat- and board-native surfaces. "The IDE is dead" misses it: more autonomy needs a better review UI, not none.
TechManaging what enters and stays in an agent's context window is now as important as the prompt. More tokens do not mean better results -- as the window fills, models suffer context rot. The skill is finding the smallest set of high-signal tokens that fully specifies the task.
TechIf context is the new code, evals are its tests: repeatable checks that your AGENTS.md, rules, skills, and prompts still produce the behaviour you want when you edit them or the model changes underneath you. Run on your own codebase -- which is what makes them different from public benchmarks.
TechA coding agent is a model plus everything built around it. Most of the leverage in agentic development sits in the harness -- the prompts, hooks, sandboxes, feedback loops, and memory policies -- not in model selection.
TechThe layer above harness engineering: instead of prompting an agent yourself -- prompt, wait, read the diff, repeat -- you build the outer system that prompts it. A goal written to files, a trigger that is not a keystroke, fresh context each iteration, verification the agent cannot bypass, and a defined point where it stops to ask a human.
TechCoding agents are stateless by default -- every session starts cold. Memory engineering is the discipline of building the durable layer that persists between runs, so an agent accumulates experience instead of relearning it. Where context engineering manages the live window, memory engineering manages what outlives it and gets retrieved back in.
ProcessThe end state of loop engineering: a software production system that runs with the lights off. Autonomous agents build, test, and ship around the clock while humans define intent and review outcomes -- not code. Named after fully automated factories that need no human on the floor. Real for a handful of tiny elite teams; contested as a general model.