Agentic Engineering
Work coding agents like an engineer: context files, subagents, prompt injection, guardrails, model routing and cost, and reviewing what the machine actually wrote.
88 concepts528 live tasks
Start practicing freeWhat's inside
How Coding Agents Work
An agent is a language model in a loop with tools
Most of an agent's personality is the harness
The agent's world is exactly its context
The model never executes anything itself
Sampling makes runs diverge; artifacts make work reproducible
Agents fail on ambiguity more than on difficulty
Everything the model sees is one flat token stream
An agent remembers nothing it did not write down
Context Files & Repo Memory
An agent memory file is an extension of the system prompt
Every line in a memory file is a tax paid on every request
Memory files layer by scope, and cross-level conflicts fail silently
Checkable imperatives beat aspirational guidance
A stale rule carries the same authority as a live one
A pointer costs one line; inlining the document costs every turn
The repository steers an agent more reliably than prose about it
Memory files earn their cost with facts the agent cannot derive
Context Windows & Token Economics
The context window is working memory, not knowledge
Long conversations get more expensive and less accurate together
Output tokens are the expensive ones, and reasoning spends them unseen
Prompt caching pays for stability and punishes churn at the top
Three relevant files beat the pasted repository
A failed attempt never leaves the room
Compaction lets a model choose what the agent forgets
Starting fresh is a technique, not an admission of failure
Prompting & Spec Discipline
Every unstated assumption is resolved by sampling
A definition of done outperforms a list of steps
Non-goals bound the blast radius requirements cannot
A stated verification path turns one shot into a loop
A wrong plan costs a paragraph; a wrong diff costs an afternoon
A leading question buys agreement, not information
One counterexample outbinds a paragraph of adjectives
Two wrong outputs point at the prompt, not the model
Tools, MCP & Extensions
The model requests tools; the harness runs them
Writing a tool description is prompt engineering
MCP collapses N-by-M integrations into N-plus-M
Every loaded tool taxes context and dilutes selection
Progressive disclosure keeps expertise cheap until needed
A procedure worth repeating is worth teaching once
Hooks guarantee what instructions merely request
A fully specified task deserves a script, not an agent
Subagents & Orchestration
A subagent's real product is context isolation
The context firewall is lossy in both directions
Fan-out pays only when the subtasks are independent
Concurrent edits to one working tree are a race condition
A model checking its own work is anchored to it
Refutation surfaces defects that confirmation waves through
Three identical reviewers share one blind spot
Orchestration buys wall-clock time, not fewer tokens
Guardrails, Permissions & Safety
Permission design is blast-radius design
Everything an agent reads shares one instruction channel
The lethal trifecta breaks when any one leg is removed
Telling a model to ignore injected instructions is not a boundary
A sandbox plans for the agent being wrong
A secret that enters context has already started leaking
Agent confidence carries no information about correctness
An agent approving its own work is no approval at all
Models, Cost & Routing
Model choice is a routing decision, not a preference
Frontier capability is wasted on mechanical work
A cheap generator plus a strong critic beats an expensive soloist
Reasoning effort belongs where being wrong is expensive
An uncached loop pays for its whole history every turn
A subscription buys predictability; metered billing buys elasticity
Local inference removes the meter and caps the model
Memory decides which local model runs; bandwidth decides how fast
Automation, Integration & Environments
Headless invocation is the primitive; interactivity is just a UI
CI is the only ground truth an unattended agent has
An automated agent needs its own identity, not a human's
Retries are normal, so automation must be idempotent and bounded
An integration's real payload is context, not posting rights
The script decides the flow; the model decides the judgment
Long-running agents belong on machines that do not sleep
An agent fleet is bounded by review capacity, not output
Reviewing Agent Output
Whoever merges the change owns its defects
Invented APIs read exactly like real ones
Passing tests are a claim until the tests are read
The highest-risk lines are the ones nobody asked for
Machine-written code fails by being plausible
Reviewing exercises recognition; writing exercises recall
Once the frame is wrong, restarting beats repairing
Verification needs a signal the agent did not generate
The Tool Landscape
Deployment shape determines what an agent can touch
Agent tools should be evaluated by harness, not by model
Agent CLIs are converging on the same primitives
Open-source agents decouple the harness from the model
Lock-in lives in the workflow, not the model weights
A chat app cannot close a feedback loop
Speech raises the bandwidth of specification
A phone can supervise an agent it does not host