Context & Spec-Driven Development
When an agent can write the code, the leverage moves upstream - to how clearly you describe the work and how rigorously you review it. Context engineering is the defining developer skill of the agentic era.
Why Context Became the Skill
An agent is only as good as the context it is given. The same model will produce throwaway code from a vague prompt and production-ready code from a precise one. The difference is not the model - it is the spec, the constraints, and the surrounding information the agent can see.
"Vibe coding" - accepting whatever an agent produces and hoping it works - is the failure mode of this era. The discipline that replaces it has two halves: writing context well so the agent does the right thing, and reviewing rigorously so nothing wrong slips through. Both are human skills, and both get more valuable as agents get more capable.
What Goes Into Good Context
Intent & Acceptance
What you are building and how you will know it is done. Clear goals and acceptance criteria keep the agent aimed at the outcome, not just a literal instruction.
Constraints & Conventions
Your stack, patterns, coding standards, and the things never to do. This is what a persistent project context file (a CLAUDE.md, a rules file) is for.
Relevant Code & Docs
The files, interfaces, and examples the task touches. Long context windows and MCP connections let the agent see the real system instead of guessing.
Guardrails
What the agent may and may not touch, which commands need approval, and where to stop and ask. Boundaries are part of the spec, not an afterthought.
Scope
A task small enough to review in one sitting. Tightly scoped work produces diffs you can actually understand - the opposite of a thousand-line surprise.
Feedback Loop
Tests, types, and lint the agent can run to check itself. The faster the agent can verify its own work, the less it depends on you to catch every mistake.
A Spec-Driven Loop
Write the Spec
State intent, constraints, scope, and acceptance criteria before any code. The spec is the artifact you iterate on - cheap to change here, expensive to change later.
Let the Agent Plan
Have the agent restate the plan before executing. A wrong plan is far cheaper to correct than a wrong diff.
Execute & Self-Check
The agent implements the task and runs the feedback loop - tests, types, lint - fixing what it can before it reaches you.
Review the Diff
Read every change with judgment. Where the output is wrong, the fix is usually upstream - sharpen the spec or context and run again.
Capture What You Learned
Fold recurring corrections back into your persistent context file so the next task starts smarter. Good context compounds.
From Context to Intent
Context engineering gets an agent the information it needs. The next question is sharper: what does success actually mean? Defining measurable objectives, constraints, tool permissions, and stop rules - so an agent achieves a goal rather than merely completing a task - is its own emerging discipline, sometimes framed as the wave after context engineering.
For a deeper treatment of writing intent into executable specifications, see Intent Engineering - a companion resource on aligning AI agents with business outcomes.
Frequently Asked Questions
Context engineering is the practice of giving an AI agent everything it needs to do a task well: clear intent and acceptance criteria, the relevant code and docs, your constraints and conventions, guardrails, and a feedback loop it can run. It is the upstream work that determines whether agent output is production-ready or throwaway.
Vibe coding means prompting loosely and accepting whatever the agent returns. Spec-driven development inverts that: you write a clear specification first, have the agent plan and execute against it, and review every diff with judgment. The spec gives you something concrete to iterate on and to hold the output accountable to.
Yes - more than ever for the parts that matter. You may type fewer lines, but you cannot write a good spec, set sensible guardrails, or review an agent's diff without understanding the code and the system. Engineering judgment is exactly what context engineering depends on.
Direct Agents With Discipline
See how context and review run through every phase of the AIDLC framework.