Beyond the Prompt
Last reviewed
AdvancedWhat you'll learn
~12 min- Locate your current skill ceiling with a 7-point self-assessment
- Map the seven practices that separate daily users from agentic engineers
- Choose which lessons in this module to take and in what order
Modules 1-11 covered the floor: install the tools, prompt well, chunk work, ship code. If you have been using an AI CLI daily for months, you already know that floor. This module is the ceiling — or at least the current one.
The skill shift is architectural. A daily user operates one agent interactively and gets value from it. An agentic engineer designs systems of agents: shaped by per-project context, extended with tools, composed into pipelines, automated in CI, and reviewed by other models before anything risky ships. The gap between the two is not about prompting harder. It is about treating the agent layer as infrastructure.
This lesson is a map. It names what is in the module, gives you a self-assessment to find your gaps, and explains the 2026 ecosystem shifts that made these patterns table stakes rather than hobbyist experiments.
The skill stack
The practices in this module build on each other loosely, though each lesson stands alone:
Context Engineering ──► Extension (MCP / Skills / Hooks) │ │ └──────────┬──────────────┘ ▼ Subagent Orchestration │ ▼ Headless Agents & CI │ ▼ Spec-Driven Development ──► The Council Pattern │ ▼ RunbooksContext engineering underpins everything. Extension and orchestration multiply what a single well-contextualised agent can do. Automation, specs, and councils are how you make the whole stack reliable enough to trust in production.
Self-assessment: where is your ceiling?
Work through this list honestly. For each item you cannot do confidently today, there is a lesson that teaches it.
1. Keep an agent sharp across a week-long project without context rot.
Without active context management, every new session starts cold. The agent re-derives decisions you already made, contradicts earlier choices, and drifts toward generic answers. Context engineering is how you fix that structurally, not session by session.
2. Connect an MCP server — and vet it before you do.
Model Context Protocol servers give agents access to external tools: databases, APIs, file systems, browser automation. The ecosystem has over 10,000 public servers as of early 2026. Connecting one takes five minutes. Connecting the wrong one is a supply-chain risk. Knowing how to evaluate a server before adding it is the skill.
3. Author a skill that works across tools, and a hook that enforces a guardrail.
Skills (defined in SKILL.md-compatible formats) package reusable agent behaviors that travel with the project. Hooks fire automatically at defined lifecycle events — pre-commit, post-edit, on tool use. Together they let you encode team standards once and stop enforcing them manually.
→ Skills, Hooks & Custom Commands
4. Decompose work across parallel agents.
Some tasks are embarrassingly parallel — generating variants, reviewing multiple files, running independent pipelines simultaneously. Subagent orchestration is how you scale horizontally instead of waiting on a single context thread.
5. Run an agent from a script or CI pipeline, safely.
Interactive use is not enough when you need the same agent behavior on every pull request, every deploy, or every scheduled run. Headless agents run without a human in the loop — which means permission boundaries, output validation, and cost controls matter more, not less.
6. Drive a feature from spec to implementation with the spec as the source of truth.
When the agent is writing the code, the spec needs to be precise enough that you can tell whether the implementation matches it. Spec-driven development is not a new idea — but pairing it with an AI that can execute against the spec changes what a one-person team can ship.
7. Get an independent multi-model review before a risky change ships — then prove you did.
A single model reviewing its own output catches less than you want it to. The council pattern runs a decision past two or three frontier models independently and surfaces disagreements before they become production incidents. Runbooks turn the whole workflow — from spec through council review through deploy — into a repeatable, auditable process.
→ The Council Pattern, then Agent Runbooks
Why 2026 changed the job
These are not experimental techniques anymore. Here is what shifted:
- MCP became a foundation-level standard. Anthropic donated the Model Context Protocol to the Linux Foundation’s Agentic AI Foundation in December 2025. With over 10,000 public servers now in the ecosystem, MCP integration is an expected capability, not a differentiator.
- Agent Skills reached cross-vendor adoption. The SKILL.md open standard — defining portable, composable agent skills — was adopted by roughly 32 tools by early 2026. Writing a skill once and running it across Claude Code, Codex CLI, and others is the expected workflow.
- Spec-driven development hit mainstream tooling. GitHub’s Spec Kit crossed 111,000 stars. The pattern of committing a machine-readable spec and having the agent implement against it moved from blog-post theory to default practice.
- Background and async agents shipped everywhere. Every major CLI now treats long-running, non-interactive agent execution as a first-class feature. Headless operation is no longer a workaround — it is the product.
None of this is stable — the tool is always the source of truth for current flags, config schema, and version specifics. What is stable is the pattern layer: context, extension, orchestration, automation, systematization.
Every major AI CLI vendor now publishes free official training for their own tool — Anthropic Academy for Claude Code, Google’s Gemini developer learning paths, and so on. Those are worth bookmarking for tool-specific syntax and feature updates.
This module teaches the layer above that: vendor-neutral patterns that survive model upgrades and tool churn. The council pattern works whether your stack is Claude + Gemini, Claude + GPT, or something that ships next quarter. Learn tool syntax from the vendor; learn architecture here.
How to use this module
The lessons are designed to be taken in any order. If you identified a specific gap in the self-assessment, start there.
That said, Lesson 2 (Context Engineering) underpins every other lesson in the module. If you have never structured per-project context deliberately — CLAUDE.md, memory files, session priming — start there regardless of what else you want to learn. A well-contextualised agent makes every other technique more reliable.
Which lesson in this module underpins all the others and is worth taking first regardless of your specific gaps?
Key takeaways
- The shift is architectural. Daily use gets you value from one interactive agent. Agentic engineering means designing systems: context, extension, orchestration, automation, and systematization working together.
- MCP, Skills, background agents, and spec-driven workflows are table stakes in 2026 — not advanced experiments. The ecosystem moved while you were shipping.
- Seven practices separate daily users from agentic engineers. Use the self-assessment to find your specific gap and go there.
- Vendor courses cover tool syntax; this module covers architecture. Both are worth your time. Use them together.
- Start with Lesson 2. Context Engineering underpins everything else. Even if you only read one lesson in this module, read that one.
Next: Context Engineering