AI

Techniques for getting more out of AI coding agents and large language models, and an account of what those models actually are. Most of the section is practitioner-facing — how to make a model running in a loop produce correct work reliably and economically — and the last two entries go the other way, taking the machinery apart.

The section shares one running example: using Claude Code to write a page for this wiki. It is a real agentic workload over artifacts in this repository, so each topic below can point at the same concrete task instead of inventing a fresh hypothetical.

• Context engineering — managing what the model sees: the context budget, curation, compaction, sub-agent isolation, and the pitfalls that cause wrong actions.
  • Anatomy of a request — what the model actually receives: one flat token sequence, and who writes each part of it.
  • Claude Code — those techniques applied end-to-end in a real harness; the section’s worked example.
• Prompt engineering — wording the instructions the model receives.
• LLM overused words — the delve/tapestry vocabulary, why preference training installs it, and what actually removes it.
• LLM verbal tics — the same habit above the word: sentence patterns, paragraph shapes and reply openers that recur whatever the subject, and why each model has its own.
  • Mitigating verbal tics — the four places a tic can be intercepted, and why banning the phrase fails.
  • Verbal tics by application — which of those a chat user, an integrator, an agent operator and a novelist can reach.
  • Claude’s verbal tics — an open list for one model family, each entry marked by how it is known.
• Pastiche — writing in a named author’s style, what actually transfers, and why the identifying features do not.
• Prompt caching & cost — the token economics behind latency and spend.
• Agentic workflows — planning, tool use, delegation, and verification loops.
• Loop engineering — writing the program that prompts the agent: what starts each run, what carries over between runs, and the check that replaces a person reading the output.
  • The Ralph loop — one prompt file fed to an agent by a shell loop, with a fresh context on every pass.
  • Loops in Claude Code — /loop, /goal, Stop hooks, routines and claude -p, sorted by what starts the next turn.
• Agentic engineering — the lifecycle around the loop: evaluation, observability, guardrails, and cost engineering.
• AI plugins — bundled extensions to an agentic harness: what they are, when to install one, and when to author your own.
  • Using a Claude Code plugin — anatomy, install, context cost, and trust applied to Anthropic’s harness.
  • Authoring a plugin — why packaging pays off even with one user, and the minimum scaffold to get started.
• MCP — the open protocol underneath most plugin tool surfaces.
• Neural networks — the other direction, and the foundation of it: what a fitted model is made of, why each part is there, and how training fills in the blanks. Architecture-neutral.
• Large language models — those parts arranged into a transformer: what a model actually is, from a token going in to a guess coming out, plus how it was trained and what it costs to run.
• Model builders — who actually trains these models: the eight labs at the frontier, how their families are named and tiered, and what each one does and does not disclose about how its models are built.