# Understanding Data > James Phoenix on AI-native software engineering and context engineering: the vocabulary, the patterns, and the failure modes, written from building the systems rather than reading about them. This file indexes every reference entry and essay on https://understandingdata.com. Entries are human-written and human-reviewed, and each carries its type (pattern, antipattern, or concept) and, where it makes a claim, how well established that claim is (proven, validated, emerging, experimental, theory). Append `.md` to any dictionary entry URL for a clean Markdown copy, e.g. https://understandingdata.com/ai-coding-dictionary/harness.md ## Field guides - [AI Native Software Engineering](https://understandingdata.com/ai-native-software-engineering/): The vocabulary and workflow of building software with AI coding agents, from tokens and context windows through harnesses, subagents, and review discipline. - [Context Engineering](https://understandingdata.com/context-engineering/): A practical guide to deciding what a model sees: retrieval, agent patterns, reliability, evaluation, and the ways long-context systems break. ## AI Coding Dictionary (77 entries) Plain-English definitions for the vocabulary behind AI coding agents. ### Foundations - [AI](https://understandingdata.com/ai-coding-dictionary/ai/) (concept): In the coding-agent world, "AI" almost always means a large language model: a system that predicts the next chunk of text from everything it has been shown. It is not a mind and it is not a database. It is a very good pattern completer. - [Effort](https://understandingdata.com/ai-coding-dictionary/effort/) (concept): Effort is a dial for how much internal reasoning a model spends before it answers. Turn it up for genuinely hard problems; you pay for it in latency and extra output tokens. - [Inference](https://understandingdata.com/ai-coding-dictionary/inference/) (concept): Inference is the act of running a trained model to get an answer: text goes in, a prediction comes out. Every message you send to a coding agent is an inference. It is the opposite end of the lifecycle from training. - [Model](https://understandingdata.com/ai-coding-dictionary/model/) (concept): A model is the trained artifact at the centre of every AI coding tool: a large file of numbers (parameters) that, given some text, produces the most likely continuation. When people say "which model are you using," this is the thing they mean. - [Next-token prediction](https://understandingdata.com/ai-coding-dictionary/next-token-prediction/) (concept): Next-token prediction is the one job a language model does: given the text so far, predict the most likely next token, add it, and repeat. It is both the training objective and what runs at inference. - [Non-determinism](https://understandingdata.com/ai-coding-dictionary/non-determinism/) (concept): Non-determinism is why the same prompt can give you different answers. At inference the model samples among likely next tokens with a controlled amount of randomness, so runs vary. - [Parameters](https://understandingdata.com/ai-coding-dictionary/parameters/) (concept): Parameters are the learned numbers (weights) inside a model that hold everything it appears to know. The count of them is what people mean by model size, and they are fixed once training ends. - [Token](https://understandingdata.com/ai-coding-dictionary/token/) (concept): A token is the unit of text a model reads and writes: a chunk that is usually part of a word, not a whole word or a single character. Everything is measured in tokens, including your context window and your bill. - [Training](https://understandingdata.com/ai-coding-dictionary/training/) (concept): Training is the process that produces a model: showing it enormous amounts of text and adjusting its parameters until it gets good at predicting what comes next. It happens once, before you ever use the model. ### Providers & requests - [Cache tokens](https://understandingdata.com/ai-coding-dictionary/cache-tokens/) (concept): Cache tokens are input tokens served from the prefix cache at a reduced rate. They are how prompt caching shows up as a separate line in your usage numbers. - [Harness](https://understandingdata.com/ai-coding-dictionary/harness/) (concept): The harness is the code wrapped around a model that builds requests, runs tools, manages context, and enforces permissions. It is the agent minus the model, and it is where most of the real engineering lives. - [Input tokens](https://understandingdata.com/ai-coding-dictionary/input-tokens/) (concept): Input tokens are the tokens you send in a request: the system prompt, the conversation history, loaded files, and tool definitions. You are billed for them, and they count against the context window. - [Model provider](https://understandingdata.com/ai-coding-dictionary/model-provider/) (concept): A model provider is the company or service that hosts a model behind an API. Your agent sends requests to it and gets completions back; you never run the model yourself. - [Model provider request](https://understandingdata.com/ai-coding-dictionary/model-provider-request/) (concept): A model provider request is a single API call to the provider carrying the messages, tools, and settings for one step. It is the atomic unit of agent work, and one turn can be many requests. - [Output tokens](https://understandingdata.com/ai-coding-dictionary/output-tokens/) (concept): Output tokens are the tokens a model generates in its response, including any hidden reasoning. They are usually priced higher than input tokens, and turning up effort produces more of them. - [Prefix cache](https://understandingdata.com/ai-coding-dictionary/prefix-cache/) (concept): A prefix cache lets a provider reuse the unchanged front of your request instead of reprocessing it, so repeated prefixes are cheaper and faster. It is the main reason keeping the start of your prompt stable pays off. - [Stateful](https://understandingdata.com/ai-coding-dictionary/stateful/) (concept): Stateful describes anything that keeps state across requests: conversation history, memory, a session. In an agent that job belongs to the harness or app, never to the stateless model API. - [Stateless](https://understandingdata.com/ai-coding-dictionary/stateless/) (concept): Stateless means the model API keeps no memory between requests. Each call starts blank, so every request must carry all the context the model needs. This is foundational to how agents are built. ### Context - [Autocompact](https://understandingdata.com/ai-coding-dictionary/autocompact/) (concept): Autocompact is the agent compacting the context automatically when the window nears full. Convenient, but it can silently drop detail you cared about. - [Clearing](https://understandingdata.com/ai-coding-dictionary/clearing/) (pattern, proven): Clearing is deliberately wiping the context to start fresh. It is often the cleanest fix for a bloated or confused window. - [Compaction](https://understandingdata.com/ai-coding-dictionary/compaction/) (concept): Compaction is condensing older conversation history into a summary to reclaim context-window space while keeping the important gist. It is lossy by design. - [Context](https://understandingdata.com/ai-coding-dictionary/context/) (concept): Context is all the text a model can see for a single request: the system prompt, your message, the conversation so far, and any files or tool output the agent has pulled in. It is the only thing the model knows about your specific situation. - [Context window](https://understandingdata.com/ai-coding-dictionary/context-window/) (concept): The context window is the maximum amount of text, measured in tokens, that a model can consider for a single request. It is a hard ceiling, and it is the main resource you manage when working with an agent. - [Lost in the middle](https://understandingdata.com/ai-coding-dictionary/lost-in-the-middle/) (antipattern, proven): Lost in the middle is the well-known tendency for models to attend best to the start and end of a long context and to miss information buried in the middle. - [Session](https://understandingdata.com/ai-coding-dictionary/session/) (concept): A session is one continuous conversation with an agent that accumulates history in the context window. Resetting or ending it clears that history and starts the agent from a blank slate. - [System prompt](https://understandingdata.com/ai-coding-dictionary/system-prompt/) (concept): The system prompt is the standing instruction placed at the very start of the context that sets the model’s role, rules, and tone before the conversation begins. It shapes every reply without being part of the back-and-forth. - [Turn](https://understandingdata.com/ai-coding-dictionary/turn/) (concept): A turn is one round of the agent loop: your input, the model doing its work (possibly several tool calls), and its response. A single turn can span many provider requests. ### Agents & tools - [Agent](https://understandingdata.com/ai-coding-dictionary/agent/) (concept): An agent is a language model wrapped in a loop that lets it call tools, read the results, and decide what to do next. The model supplies the judgement; the loop and the tools give it hands. - [Agent mode](https://understandingdata.com/ai-coding-dictionary/agent-mode/) (concept): Agent mode is a setting where the model runs the loop autonomously, planning and acting on its own, rather than giving a single chat reply or edit. More capable, and it needs more trust. - [Environment](https://understandingdata.com/ai-coding-dictionary/environment/) (concept): The environment is the surroundings an agent acts in: working directory, files, shell, environment variables, and network. It defines what the agent's tools can actually reach. - [Filesystem](https://understandingdata.com/ai-coding-dictionary/filesystem/) (concept): The filesystem is the set of files an agent can read and write. It is its main source of truth and its main way to make durable changes. - [MCP (Model Context Protocol)](https://understandingdata.com/ai-coding-dictionary/mcp/) (concept): MCP is an open standard for connecting agents to tools and data. Instead of hard-coding an integration into every agent, you run an MCP server once and any MCP-aware agent can use it. - [Skill](https://understandingdata.com/ai-coding-dictionary/skill/) (concept): A skill is a packaged, reusable set of instructions an agent loads on demand for a specific kind of task. It is progressive disclosure of know-how instead of cramming everything into the system prompt. - [Subagent](https://understandingdata.com/ai-coding-dictionary/subagent/) (concept): A subagent is a separate agent that a main agent spawns to handle a scoped subtask, with its own fresh context. It does the work, returns a short result, and the noise of how it got there never touches the main conversation. - [Tool](https://understandingdata.com/ai-coding-dictionary/tool/) (concept): A tool is a named action, with a typed input schema, that a model is allowed to call. Tools are how a model that can only produce text gets to actually do things: read a file, run a command, search the web. - [Tool call](https://understandingdata.com/ai-coding-dictionary/tool-call/) (concept): A tool call is the model’s request to use a tool: it names the tool and supplies the arguments, then pauses. It has not run anything. Your harness is what actually executes the action. - [Tool result](https://understandingdata.com/ai-coding-dictionary/tool-result/) (concept): A tool result is the output of running a tool, fed back into the conversation so the model can use it. It is tied to the tool call that requested it, and it is how the model sees the consequences of its own actions. ### Permissions & safety - [AFK](https://understandingdata.com/ai-coding-dictionary/afk/) (pattern, validated): AFK means running an agent unattended for long stretches while you are away from the keyboard. It is only safe with strong guardrails and automated checks, since no human is watching each step. - [Agent trap](https://understandingdata.com/ai-coding-dictionary/agent-trap/) (antipattern, emerging): An agent trap is content placed where an agent will find it, designed to work on an agent rather than a human reader. The target is not a person browsing but an automated reader that acts on what it reads. - [Blast radius](https://understandingdata.com/ai-coding-dictionary/blast-radius/) (concept): Blast radius is how much damage an action can do if it turns out to be wrong. It is the measure that lets you scale review and permissions to consequence instead of treating every change the same. - [Egress control](https://understandingdata.com/ai-coding-dictionary/egress-control/) (pattern, validated): Egress control restricts where an agent can send data, rather than what it can read. It is usually the cheapest leg of the lethal trifecta to remove, because most agent work needs very few outbound destinations. - [Human in the loop](https://understandingdata.com/ai-coding-dictionary/human-in-the-loop/) (pattern, proven): Human in the loop means keeping a person in the agent's decision path to approve, steer, or verify its work. It is the deliberate counterweight to full autonomy. - [Least privilege](https://understandingdata.com/ai-coding-dictionary/least-privilege/) (pattern, proven): Least privilege means giving an agent only the access the current task needs, and no more. It is the one defence that works without knowing how the attack arrives, because it shrinks what any attack can accomplish. - [Lethal trifecta](https://understandingdata.com/ai-coding-dictionary/lethal-trifecta/) (antipattern, proven): The lethal trifecta is an agent having access to private data, exposure to untrusted content, and a way to communicate outward, all at once. Any two are usually survivable; all three make data theft a matter of someone asking. - [Permission mode](https://understandingdata.com/ai-coding-dictionary/permission-mode/) (concept): Permission mode is the policy that decides which actions an agent can take on its own and which ones need your approval, ranging from ask-every-time to full auto. It trades safety for flow. - [Permission request](https://understandingdata.com/ai-coding-dictionary/permission-request/) (concept): A permission request is the moment an agent stops and asks you to approve a consequential action, such as running a command or writing a file, before it happens. It is the seam where a human can catch a mistake before it lands. - [RAG poisoning](https://understandingdata.com/ai-coding-dictionary/rag-poisoning/) (antipattern, validated): RAG poisoning is planting content in a corpus so it gets retrieved and shapes the answer. The attack is on the index rather than the model, and it persists until someone removes the document. - [Sandbox](https://understandingdata.com/ai-coding-dictionary/sandbox/) (concept): A sandbox is an isolated environment that limits what an agent can touch, such as the filesystem and network, so a mistake stays contained and cannot damage the real system. - [Sandbox escape](https://understandingdata.com/ai-coding-dictionary/sandbox-escape/) (antipattern, validated): A sandbox escape is an agent reaching something the sandbox was meant to keep it away from. In practice it is almost never a container exploit; it is a mount, a socket, or a credential that was inside the boundary all along. - [Tool poisoning](https://understandingdata.com/ai-coding-dictionary/tool-poisoning/) (antipattern, proven): Tool poisoning is a tool whose own description or schema instructs the model, rather than merely describing what the tool does. Tool definitions go into the context as trusted text, so whoever writes them is writing your prompt. ### Knowledge & failure modes - [Attention](https://understandingdata.com/ai-coding-dictionary/attention/) (concept): Attention is the mechanism a model uses to weigh how strongly each token in its context relates to the others when predicting the next one. It is the basis of how a model actually uses context. - [Attention budget](https://understandingdata.com/ai-coding-dictionary/attention-budget/) (concept): The attention budget is the idea that a model's effective attention is a finite resource spread across the whole context window. The more you put in, the thinner the attention on each piece. - [Attention degradation](https://understandingdata.com/ai-coding-dictionary/attention-degradation/) (antipattern, proven): Attention degradation is the quality drop a model shows as its context grows: recall weakens and it misses or confuses buried details, often well below the hard token limit. It is also called context rot. - [Contextual knowledge](https://understandingdata.com/ai-coding-dictionary/contextual-knowledge/) (concept): Contextual knowledge is what a model knows because it is in the context right now: the files, docs, and output you gave it. It is current and grounded, and it is the main lever against hallucination. - [Hallucination](https://understandingdata.com/ai-coding-dictionary/hallucination/) (antipattern, proven): A hallucination is a confident, plausible-sounding output that is simply wrong: an invented API, a fabricated file path, a made-up citation. It is not the model lying. It is the model doing exactly what it always does, predicting plausible text, with no built-in sense of truth. - [Knowledge cutoff](https://understandingdata.com/ai-coding-dictionary/knowledge-cutoff/) (concept): The knowledge cutoff is the date after which a model learned nothing from training. It is a common source of outdated APIs, so give the model current docs to compensate. - [Parametric knowledge](https://understandingdata.com/ai-coding-dictionary/parametric-knowledge/) (concept): Parametric knowledge is what a model knows from training, stored in its parameters. It is broad and instantly available but frozen, unsourced, and not always reliable. - [Sycophancy](https://understandingdata.com/ai-coding-dictionary/sycophancy/) (antipattern, proven): Sycophancy is a model's tendency to agree with you and tell you what you want to hear rather than push back. It is why "am I right?" is a leading question that produces a leading answer. ### Context engineering - [AGENTS.md](https://understandingdata.com/ai-coding-dictionary/agents-md/) (pattern, proven): AGENTS.md is a project file of standing instructions and conventions that an agent loads into context at the start of a session. It gives a repo its own durable memory, checked into version control next to the code. - [Context pointer](https://understandingdata.com/ai-coding-dictionary/context-pointer/) (pattern, validated): A context pointer is a reference (a path, URL, or id) you give an agent instead of the full content, so it can fetch the material only if and when it needs it. It is a cheap way to make a lot of context available. - [Handoff](https://understandingdata.com/ai-coding-dictionary/handoff/) (pattern, proven): A handoff is passing work from one session or agent to the next by summarising the current state, so the successor can continue without relearning everything. It is the antidote to a dead or overflowing window. - [Handoff artifact](https://understandingdata.com/ai-coding-dictionary/handoff-artifact/) (concept): A handoff artifact is the concrete document produced at a handoff, recording what is done, what is next, and the key decisions. The next session reads it to get up to speed fast. - [Memory system](https://understandingdata.com/ai-coding-dictionary/memory-system/) (concept): A memory system is an external store the harness uses to persist facts across sessions and reload them into context. It is how a stateless model ends up behaving as if it remembers you and your project. - [Primary source](https://understandingdata.com/ai-coding-dictionary/primary-source/) (concept): A primary source is the authoritative original: the actual code, the real types, the official docs. Point agents at primary sources so they read reality instead of guessing from memory. - [Progressive disclosure](https://understandingdata.com/ai-coding-dictionary/progressive-disclosure/) (pattern, proven): Progressive disclosure is revealing detail to the model only when it is needed, via pointers and on-demand loading, instead of putting everything into context up front. It saves window space and attention. - [Secondary source](https://understandingdata.com/ai-coding-dictionary/secondary-source/) (concept): A secondary source is second-hand information: blog posts, summaries, or the model's own memory. It is useful for orientation but must be checked against the primary source before you rely on it. - [Spec](https://understandingdata.com/ai-coding-dictionary/spec/) (concept): A spec is a written description of what to build and why, handed to the agent up front. Specs-as-context reliably beat vague one-line requests. - [Ticket](https://understandingdata.com/ai-coding-dictionary/ticket/) (concept): A ticket is a scoped unit of work carrying enough context to act on. Well-formed tickets are ideal agent inputs. ### Workflow & practice - [Automated check](https://understandingdata.com/ai-coding-dictionary/automated-check/) (concept): An automated check is a machine-verifiable gate that agent output has to pass, like tests, a type check, a linter, or a build. It either passes or fails with no judgment, which makes it the backbone of trusting agent code, especially when you are running unattended. - [Automated review](https://understandingdata.com/ai-coding-dictionary/automated-review/) (pattern, validated): Automated review is putting a change through an AI reviewer before a person sees it, so a second agent flags likely bugs, missed edge cases, and smells. It catches the obvious cheaply, but it does not replace human judgment about whether the change is right. - [AX](https://understandingdata.com/ai-coding-dictionary/ax/) (concept): AX, agent experience, is how well a codebase or tool is set up for AI agents to work inside it: clear structure, written-down conventions, an AGENTS.md, and automated checks the agent can verify against. It is the emerging sibling of developer experience. - [Design doc](https://understandingdata.com/ai-coding-dictionary/design-doc/) (pattern, proven): A design doc is a short written description of how you plan to build something, written before you build it. It forces you and the agent to commit to an approach and surfaces problems while they are still cheap to fix. - [DX](https://understandingdata.com/ai-coding-dictionary/dx/) (concept): DX, developer experience, is how good it feels for a human to work with a tool, library, or codebase: fast feedback, clear errors, sensible defaults, docs that answer the real question. It still matters in the agent era, and it tends to track how well agents work in the same codebase. - [Human review](https://understandingdata.com/ai-coding-dictionary/human-review/) (pattern, proven): Human review is a person actually reading what an agent produced, understanding it, and taking responsibility for shipping it. It is the final quality gate that tests and automated review can support but never replace. - [Prototyping](https://understandingdata.com/ai-coding-dictionary/prototyping/) (pattern, validated): Prototyping is using an agent to throw together a rough, disposable version of something fast, so you can see an idea working and decide what to actually build. You optimise for speed and learning, not polish, and you discard the result freely. - [Self-critique](https://understandingdata.com/ai-coding-dictionary/self-critique/) (pattern, emerging): Self-critique is asking a model to attack its own output, or having a fresh agent do it, to catch bugs and bad assumptions before you ship. It is a direct counter to a model's tendency to agree with whatever it just produced. - [Vibe coding](https://understandingdata.com/ai-coding-dictionary/vibe-coding/) (antipattern, proven): Vibe coding is building software by prompting an agent and steering on feel, accepting the code it writes without reading every line. It is fast and freeing for prototypes and personal tools, and genuinely risky the moment the code has to run in production. ## Context Engineering Dictionary (36 entries) Definitions for the techniques that decide what reaches a model, each with a runnable example where one applies. ### Foundations - [Context engineering](https://understandingdata.com/context-engineering-dictionary/context-engineering/) (concept): Context engineering is the discipline of deciding what a model sees. Since a model can only work from the text in front of it, the quality of any answer is capped by the quality of the context you assemble. ### Retrieval & RAG - [Chunking](https://understandingdata.com/context-engineering-dictionary/chunking/) (concept): Chunking is splitting a long document into smaller pieces before you embed and retrieve them. The size and overlap of the chunks decide what can be found as a unit, so it quietly makes or breaks a retrieval system. - [Contextual retrieval](https://understandingdata.com/context-engineering-dictionary/contextual-retrieval/) (pattern, validated): Contextual retrieval prepends a short, generated description of where a chunk came from before embedding it. It fixes the fact that chunking strips away the context a chunk needs in order to be findable. - [Embeddings](https://understandingdata.com/context-engineering-dictionary/embeddings/) (concept): An embedding turns a piece of text into a list of numbers that captures its meaning, so that similar ideas land near each other. Embeddings are what let you search by meaning instead of by exact keyword. - [GraphRAG](https://understandingdata.com/context-engineering-dictionary/graphrag/) (pattern, emerging): GraphRAG retrieves over a graph of entities and relationships rather than a flat pile of chunks, so the model can follow connections between facts. It answers questions that need several hops, which similarity search cannot reach. - [Hybrid search](https://understandingdata.com/context-engineering-dictionary/hybrid-search/) (pattern, validated): Hybrid search runs a keyword search and a vector search over the same corpus and merges the two result lists. It exists because embeddings are good at meaning and bad at exact strings, and keyword search is the other way round. - [Reranking](https://understandingdata.com/context-engineering-dictionary/reranking/) (pattern, proven): Reranking retrieves a generous set of candidates cheaply, then reorders them with a slower, more accurate model before any of it reaches the context. It buys precision at the top of the list without paying that cost across the whole corpus. - [Retrieval-augmented generation (RAG)](https://understandingdata.com/context-engineering-dictionary/retrieval-augmented-generation/) (pattern, proven): RAG is the workhorse pattern of context engineering: retrieve the material relevant to a request, put it in the context, and let the model generate an answer grounded in it rather than guessing from memory. - [Vector database](https://understandingdata.com/context-engineering-dictionary/vector-database/) (concept): A vector database stores embeddings and finds the nearest ones to a query vector quickly. It is an index for meaning, and for small corpora you very often do not need one. ### Agent patterns - [Agents vs. workflows](https://understandingdata.com/context-engineering-dictionary/agents-vs-workflows/) (concept): A workflow follows a path you designed in advance; an agent decides its own path at run time by calling tools in a loop toward a goal. Knowing which one you actually need is the first context-engineering decision. - [Evaluator-optimizer](https://understandingdata.com/context-engineering-dictionary/evaluator-optimizer/) (pattern, validated): Evaluator-optimizer pairs a generator with a separate critic that scores its output and sends it back for revision. It works when quality is easier to judge than to produce, which is more often than you would expect. - [Orchestrator-workers](https://understandingdata.com/context-engineering-dictionary/orchestrator-workers/) (pattern, validated): Orchestrator-workers has a central model decide how to break a task down at run time, dispatch the pieces to workers, and combine what comes back. It is parallelization for tasks whose shape you cannot know in advance. - [Parallelization](https://understandingdata.com/context-engineering-dictionary/parallelization/) (pattern, proven): Parallelization runs several model calls at once and combines the results, either by splitting a task into independent parts or by asking the same question repeatedly and aggregating. It buys latency in one form and reliability in the other. - [Plan-and-execute](https://understandingdata.com/context-engineering-dictionary/plan-and-execute/) (pattern, validated): Plan-and-execute writes the whole plan first, then carries out the steps. Separating the two makes the plan reviewable before any work happens, which is the entire point. - [Prompt chaining](https://understandingdata.com/context-engineering-dictionary/prompt-chaining/) (pattern, proven): Prompt chaining breaks a task into a fixed sequence of steps, feeding each step’s output into the next. It is the simplest workflow pattern, and it beats one giant prompt whenever a task has natural stages. - [ReAct](https://understandingdata.com/context-engineering-dictionary/react/) (pattern, proven): ReAct interleaves reasoning and acting: the model thinks, takes one action, reads the result, and thinks again. It is the loop underneath most agents, and its defining property is that the next step is chosen after seeing the last result. - [Routing](https://understandingdata.com/context-engineering-dictionary/routing/) (pattern, validated): Routing classifies an input and sends it to the handler built for it. It keeps each path specialised and lets you send easy cases to a cheap model and hard cases to an expensive one, without any of the cost of a full agent. - [Tool use](https://understandingdata.com/context-engineering-dictionary/tool-use/) (pattern, proven): Tool use lets a model do more than produce text: you expose named actions with typed inputs, and the model calls them to read data, run code, or reach the outside world. It is the bridge from talking to doing. ### Reliability techniques - [Guardrail](https://understandingdata.com/context-engineering-dictionary/guardrail/) (concept): A guardrail is a deterministic check that runs around a model call, on the way in or the way out, and refuses to pass something through. It is ordinary code enforcing what a prompt can only request. - [Retry and repair](https://understandingdata.com/context-engineering-dictionary/retry-and-repair/) (pattern, validated): Retry and repair feeds a failed validation back to the model as the next input, so it fixes its own output instead of you regenerating blind. It converts a hard failure into one more turn, with the error as the instruction. - [Self-consistency](https://understandingdata.com/context-engineering-dictionary/self-consistency/) (pattern, validated): Self-consistency samples the same prompt several times and takes the majority answer. It trades a few extra calls for a big drop in variance, turning a model that sometimes slips into one that reliably lands on its best answer. - [Structured outputs](https://understandingdata.com/context-engineering-dictionary/structured-outputs/) (pattern, proven): Structured outputs constrain a model to return data matching a schema you define, rather than prose you have to parse. It removes an entire class of failure: the model answered correctly and your code could not read it. ### Evaluation - [Eval set](https://understandingdata.com/context-engineering-dictionary/eval-set/) (concept): An eval set is a fixed collection of real inputs with known-good outputs that you score your system against. It is what turns "that felt better" into a number you can compare across changes. - [Goodharting](https://understandingdata.com/context-engineering-dictionary/goodharting/) (antipattern, proven): Goodharting is optimising a system until it satisfies the metric rather than the goal the metric stood for. Your eval score climbs, real quality does not, and the number you trusted is now the thing hiding the problem. - [LLM-as-judge](https://understandingdata.com/context-engineering-dictionary/llm-as-judge/) (pattern, validated): An LLM-as-judge uses one model call to score the output of another against a rubric. It is how you evaluate fuzzy, open-ended work at scale when there is no single correct answer to match against. - [Pairwise comparison](https://understandingdata.com/context-engineering-dictionary/pairwise-comparison/) (pattern, validated): Pairwise comparison asks which of two outputs is better rather than scoring either in isolation. Relative judgements are far more consistent than absolute ones, which makes it the reliable way to tell whether a change actually helped. - [Rubric](https://understandingdata.com/context-engineering-dictionary/rubric/) (concept): A rubric is the explicit set of criteria a judge scores against, with each level spelled out. Without one, asking a model to rate quality from 1 to 10 produces numbers that mean nothing and drift between runs. ### Failure modes - [Context pollution](https://understandingdata.com/context-engineering-dictionary/context-pollution/) (antipattern, proven): Context pollution is one wrong or irrelevant thing in the window steering everything downstream of it. Unlike context rot it is not gradual: a single bad passage is enough, and the model treats it as given. - [Context rot](https://understandingdata.com/context-engineering-dictionary/context-rot/) (antipattern, proven): Context rot is the gradual decay of a long session as stale, superseded, and irrelevant text accumulates in the window. Nothing breaks at any single step, which is why it is usually diagnosed as the model getting worse. - [Lost in the middle](https://understandingdata.com/context-engineering-dictionary/lost-in-the-middle/) (antipattern, proven): Lost in the middle is the tendency of models to use information at the start and end of a long context well, while missing what sits in the middle. It means a bigger context window does not automatically mean better recall. - [Prompt injection](https://understandingdata.com/context-engineering-dictionary/prompt-injection/) (antipattern, proven): Prompt injection is untrusted content in the context being followed as instruction. It is not a prompting bug to be patched but a structural consequence of putting data and instructions in the same channel. ### Memory - [Checkpoint](https://understandingdata.com/context-engineering-dictionary/checkpoint/) (pattern, validated): A checkpoint is a deliberate save point holding enough state to resume a task from there. It turns a long run from something that either finishes or is lost into something that can be picked up. - [Conversation history](https://understandingdata.com/context-engineering-dictionary/conversation-history/) (concept): Conversation history is the running list of past turns you re-send on every request so the model appears to remember. It is the simplest form of memory, and the first thing to overflow a context window if you never prune it. - [Externalized state](https://understandingdata.com/context-engineering-dictionary/externalized-state/) (pattern, proven): Externalized state keeps the durable facts of a task in files rather than in the conversation, so the window holds pointers instead of being the record. It is what makes a long task survive a context that cannot. - [Memory write policy](https://understandingdata.com/context-engineering-dictionary/memory-write-policy/) (concept): A memory write policy is the rule deciding what gets remembered, when, and for how long. Most memory systems fail on the write side rather than the read side: they save too much, and retrieval drowns. - [Scratchpad](https://understandingdata.com/context-engineering-dictionary/scratchpad/) (pattern, validated): A scratchpad is a place the model writes intermediate work it will read back later, rather than holding it in the answer. It separates thinking from output, and gives the working a home that is not the context window. ## Field notes: AI native software engineering The dictionary above defines the parts. These are the field notes: essays where I work through how those parts fit together once you are actually building with agents, not just reading about them. Start anywhere, each one stands on its own. ### The harness and the environment - [Building the Harness Around Claude Code](https://understandingdata.com/posts/building-the-harness/) (pattern, proven): Claude Code harnesses a model; here is how you harness Claude Code in turn. - [The Execution Harness That Lets Agents Ship Code](https://understandingdata.com/posts/execution-harness-for-agentic-coding/) (pattern, proven): Why determinism, schema isolation, and enforced layering are the real agentic-coding unlocks. - [The Sandbox Is a Harness](https://understandingdata.com/posts/the-sandbox-is-a-harness/) (pattern, validated): How a sandbox stops being a security fence and becomes a tool for intent. - [The Environment Leads The Agent](https://understandingdata.com/posts/the-environment-leads-the-agent/) (pattern, proven): Why fixing repo boilerplate steers an agent better than ever-cleverer prompts do. - [Generator-Evaluator Harness Design: Anthropic’s GAN-Inspired Architecture for Long-Running Apps](https://understandingdata.com/posts/generator-evaluator-harness-design/) (pattern, validated): Splitting generation from evaluation, a GAN-inspired shape for long-running agent apps. ### Loops that run on their own - [The RALPH Loop](https://understandingdata.com/posts/ralph-loop/) (pattern, proven): A fresh context each pass, with memory kept in git, docs, and task files. - [Loop Engineering](https://understandingdata.com/posts/loop-engineering/) (pattern, proven): A durable loop needs three parts: a trigger, a bounded runner, and a gate. - [Autonomous Loops Need a Scoring Function](https://understandingdata.com/posts/autonomous-loops-need-benchmarks/) (pattern, validated): Without a scoring function a loop is chaos, not hill-climbing toward better code. - [AI Daemons: Persistent Background Agents for Operational Debt](https://understandingdata.com/posts/ai-daemons-maintenance-roles/) (pattern, emerging): Persistent background agents that quietly pay down operational and maintenance debt over time. ### Many agents at once - [Sub-Agent Architecture: Specialized Agents for Higher Quality Code](https://understandingdata.com/posts/sub-agent-architecture/) (pattern, proven): Splitting work across specialized sub-agents to isolate concerns and raise code quality. - [Contracts Parallelize Agents](https://understandingdata.com/posts/contracts-parallelize-agents/) (pattern, validated): Define the contract between agents first, then dispatch them concurrently rather than in sequence. - [Orchestration Patterns: Coordinator, Swarm, and Pipeline](https://understandingdata.com/posts/orchestration-patterns/) (pattern, validated): Three ways to coordinate multiple agents: coordinator, swarm, and pipeline. - [Git Worktrees for Parallel Development: 3x Throughput with AI Agents](https://understandingdata.com/posts/git-worktrees-parallel-dev/) (pattern, proven): Using separate worktrees to run parallel agent sessions without context-switching costs. - [Sub-Agent Swarm Convergence: Why Swarms Converge or Explode](https://understandingdata.com/posts/swarm-convergence-theory/) (concept): Why a swarm of agents reduces system error instead of amplifying it. ### Review and verification - [AI Code Review](https://understandingdata.com/posts/blast-radius-code-review-dial/) (pattern, proven): Scaling how hard you review by the blast radius of the change. - [The Verification Ladder](https://understandingdata.com/posts/verification-ladder/) (pattern, proven): Types, schema, unit, property, formal: each rung catches what lower ones miss. - [Claude Code Hooks as Automated Quality Gates](https://understandingdata.com/posts/claude-code-hooks-quality-gates/) (pattern, proven): Wiring hooks to run linters, type checks, and tests on every tool call. - [Quality Gates as Information Filters: Reducing State Space Through Verification](https://understandingdata.com/posts/quality-gates-as-information-filters/) (pattern, validated): Seeing each gate as an intersection that shrinks the space of possible outputs. ### Designing for agents, and the shift in the work - [Agent-Native Architecture](https://understandingdata.com/posts/agent-native-architecture/) (pattern, validated): Designing software where AI agents are first-class citizens, not later bolt-ons. - [Writing a Good CLAUDE.md](https://understandingdata.com/posts/writing-a-good-claude-md/) (pattern, proven): What belongs in a CLAUDE.md: WHY, WHAT, HOW, kept deliberately minimal. - [Rewrite Your CLI for AI Agents](https://understandingdata.com/posts/rewrite-cli-for-agents/) (pattern, validated): Optimising a CLI for agent predictability and defense-in-depth, not human discoverability. - [Developers Are Having an Identity Crisis](https://understandingdata.com/posts/developers-are-having-an-identity-crisis/) (concept): A calmer reframe of the engineer identity crisis that AI-assisted coding set off. ## Field notes: context engineering The dictionary tells you what each term means. These are the essays behind them: longer pieces where I work the same ideas through on real systems, and note what held up and what broke. Read whichever one matches the problem in front of you, or follow them from foundations down to the ways long context falls apart. ### Deciding what the model sees - [Progressive Disclosure: Load Context Only When Needed](https://understandingdata.com/posts/progressive-disclosure-context/) (pattern, proven): How agents load files only when a task needs them, not all at once. - [Hierarchical Context Patterns](https://understandingdata.com/posts/hierarchical-context-patterns/) (pattern, proven): Why directory-level CLAUDE.md files give agents local, relevant context over one big file. - [Layered Prompts: Onion Architecture for AI Coding Agents](https://understandingdata.com/posts/layered-prompts-architecture/) (pattern, validated): Structuring a prompt in core, domain, application, and task layers. - [Token Budgeting Strategies: Allocating Context by Information Density](https://understandingdata.com/posts/token-budgeting-strategies/) (pattern, validated): Spending a finite window on the tokens that carry the most information. - [Don’t Let the Model Read the File](https://understandingdata.com/posts/dont-let-the-model-read-the-file/) (pattern, validated): Keeping oversized files on disk and letting the model drive computation instead of reading. ### Retrieval without the ceremony - [Vectorless RAG: Hierarchical Tree Retrieval Without Embeddings](https://understandingdata.com/posts/vectorless-rag-hierarchical-tree-retrieval/) (pattern, validated): Letting an LLM navigate a document tree instead of embedding similarity search. - [GraphRAG for Production Engineer Agents](https://understandingdata.com/posts/graphrag-for-production-agents/) (pattern, emerging): Turning organizational knowledge into a graph that agents traverse during incident response. - [Vendor the Source, Skip the Search](https://understandingdata.com/posts/vendored-source-beats-retrieval/) (pattern, validated): Vendoring real library source beside your code so agents read it, not guess. - [Frontmatter as Document Schema: Why Your Knowledge Base Needs Type Signatures](https://understandingdata.com/posts/frontmatter-as-document-schema/) (pattern, proven): Using frontmatter type signatures to declare what documents are and how to find them. ### Memory that outlives the session - [Memory Engineering as Data Modelling](https://understandingdata.com/posts/memory-engineering-as-data-modelling/) (pattern, validated): Treating agent memory as a data-modelling problem with a lifecycle, not a bolt-on. - [Agent Memory Patterns: Checkpoint, Resume, and State Persistence](https://understandingdata.com/posts/agent-memory-patterns/) (pattern, proven): Externalizing state so a stateless agent can checkpoint, resume, and persist. - [Institutional Memory with Learning Files: Teaching LLMs Past Decisions](https://understandingdata.com/posts/institutional-memory-learning-files/) (pattern, validated): Recording past decisions and rationale so the model stops re-proposing rejected ideas. - [Skill Graphs: Networked Knowledge Beats Monolithic Skill Files](https://understandingdata.com/posts/skill-graphs-networked-agent-knowledge/) (pattern, emerging): Capturing a whole domain as a linked graph rather than isolated skill files. ### Prompts as contracts - [Prompt Contracts: Formal Specifications That Eliminate Vibe Coding](https://understandingdata.com/posts/prompt-contracts-specification-before-code/) (pattern, validated): Writing an eight-section spec of objective, invariants, and scope before any code. - [Declarative Constraints Over Imperative Instructions](https://understandingdata.com/posts/constraint-based-prompting/) (pattern, validated): Declaring constraints and desired state, then letting the model choose the implementation. - [Few-Shot Prompting with Project Examples: Teaching Patterns Through Concrete Code](https://understandingdata.com/posts/few-shot-prompting-project-examples/) (pattern, proven): Why two or three real codebase examples teach patterns better than explanations. - [Chain-of-Thought Prompting for Complex Logic](https://understandingdata.com/posts/chain-of-thought-prompting/) (pattern, proven): Asking the model to reason step by step before implementing complex logic. ### When long context breaks - [Lost in the Middle: Preventing Context Window Attention Degradation](https://understandingdata.com/posts/lost-in-the-middle-mitigation/) (pattern, proven): Countering the U-shaped attention that quietly neglects the middle of the window. - [Context Rot Prevention: Auto-Compacting for Long AI Sessions](https://understandingdata.com/posts/context-rot-auto-compacting/) (pattern, proven): Auto-compacting the sediment that accumulates and degrades quality across long sessions. - [Context Pollution Recovery: Diagnosing and Fixing Degraded AI Sessions](https://understandingdata.com/posts/context-pollution-recovery/) (pattern, validated): Diagnosing and clearing the accumulated noise that drags a session's output down. - [Session Compaction Preserves Agent Trajectory](https://understandingdata.com/posts/session-compaction-preserves-agent-trajectory/) (pattern, validated): Compacting to preserve an agent's working trajectory, not merely to save tokens. ## All posts (380) - [AI Eats Cliché, Not Complexity](https://understandingdata.com/posts/ai-eats-cliche-not-complexity/): Most software is not being eaten because it is simple. - [How to Automate Agentic Engineering Failure-Mode Detection in the SDLC](https://understandingdata.com/posts/automate-agentic-engineering-failure-modes-in-the-sdlc/): **Every engineer running Claude Code is already writing a diary of where the SDLC breaks**: every stalled task, every abandoned plan, every loop they gave up on and finished by hand. - [Lights-On vs. Dark Software Factories](https://understandingdata.com/posts/lights-on-vs-dark-software-factories/): The difference between the two is not how much code agents write. It’s who verifies it. - [How I Find Article Ideas From 30 Days of Coding Transcripts](https://understandingdata.com/posts/mining-article-ideas-from-transcripts/): The article already happened. It’s sitting in a transcript I never reread. - [Retrieval Beats Reading for Comprehension Debt](https://understandingdata.com/posts/retrieval-beats-reading-for-comprehension-debt/): Comprehension debt is not a reading problem, it is a generation problem. - [Software Is Becoming Pay to Win](https://understandingdata.com/posts/software-is-becoming-pay-to-win/): Software production is shifting from labour-constrained to compute-constrained. - [Seniority Was a Proxy for Typing Speed](https://understandingdata.com/posts/seniority-was-a-proxy-for-typing-speed/): Most of what we called seniority was never judgment. - [Which Code Is Allowed to Be Understood by Nobody](https://understandingdata.com/posts/which-code-is-allowed-to-be-understood-by-nobody/): The problem with agentic coding is not speed. - [Measuring Coding Agent Leverage](https://understandingdata.com/posts/measuring-coding-agent-leverage/): Token volume measures spend, not output. - [Using DSL Languages for LLM Harnesses](https://understandingdata.com/posts/using-dsl-languages-for-llm-harnesses/): Unmesh Joshi’s article [DSLs Enable Reliable Use of LLMs](https://martinfowler.com/articles/llm-and-dsls.html) (martinfowler.com, July 2026) names the endgame of something I have been documenting... - [Answer Keys Are Authored, Not Found](https://understandingdata.com/posts/answer-keys-are-authored/): Addy Osmani says anything with an answer key gets automated, so build your career on the ungradeable parts: judgment, taste, accountability. - [AI Can’t Have the Hard Conversation](https://understandingdata.com/posts/ai-cant-have-the-hard-conversation/): The biggest risk in AI-assisted engineering isn’t bad code. It’s what faster output allows teams to avoid. - [The Most Important Language for Software Engineers Is English](https://understandingdata.com/posts/english-is-the-most-important-language-for-software-engineers/): The software I build is only as good as the language I use to define it. - [The First Agents Were Human](https://understandingdata.com/posts/the-first-agents-were-human/): SEOs were running agent harnesses a decade before the word existed. The executors were people, the prompts were briefs, and the eval suite was an editor with a checklist. - [Hosted Builds Are the Wrong Abstraction for Agentic Coding](https://understandingdata.com/posts/hosted-builds-wrong-abstraction-agentic-coding/): Once agents increase commit throughput, the expensive part is no longer writing code. - [Skill Erosion Is a Choice](https://understandingdata.com/posts/skill-erosion-is-a-choice/): The AI-and-atrophy debate is stuck on the wrong question. - [The 30% Cliff Is a Comprehension Problem, Not a Knowledge Gap](https://understandingdata.com/posts/the-30-percent-cliff/): The most repeated observation about AI coding is the 70% problem: vibe coding sprints you to a working-ish prototype and then stalls, and the final 30% turns brutal. The usual diagnosis is that the la - [MCP Tool Poisoning: The Description Is an Attack Surface](https://understandingdata.com/posts/mcp-tool-poisoning/): An MCP tool ships two things to your model: what it does, and a description of what it does. **The model reads that description as trusted guidance, which means whoever wrote the description can put i - [The Lethal Trifecta: Three Capabilities That Turn Injection Into Theft](https://understandingdata.com/posts/lethal-trifecta/): Simon Willison’s lethal trifecta names the exact conditions under which prompt injection stops being annoying and becomes data theft. An agent is dangerous when it holds all three of: access to privat - [Prompt Injection: Your Retrieved Text Is Executable](https://understandingdata.com/posts/prompt-injection/): Prompt injection is what happens when text you treated as data gets read by the model as instructions. **A language model has no reliable boundary between “here is content to work on” and “here is a c - [Contextual Retrieval: Situate the Chunk Before You Embed It](https://understandingdata.com/posts/contextual-retrieval/): Contextual retrieval prepends a short, generated line of context to each chunk before embedding it, so a chunk that is opaque on its own becomes findable. **The chunk you store and the chunk a human w - [Hybrid Search: Keywords and Vectors Cover Each Other’s Blind Spots](https://understandingdata.com/posts/hybrid-search/): Hybrid search runs lexical retrieval (BM25) and semantic retrieval (vectors) side by side, then fuses the two rankings. **Exact-keyword matching and meaning matching fail in opposite directions, so ru - [Reranking: Cheap Recall, Then Expensive Precision](https://understandingdata.com/posts/reranking/): Reranking splits retrieval into two stages. A cheap vector search over-fetches a shortlist, then a stronger model reorders it. **The first pass optimises for recall, the second for precision, and each - [The Same Endpoint Now Has Three Callers](https://understandingdata.com/posts/one-endpoint-three-callers/): In an AI-native product the same route is hit by a browser, an API key, and an agent. - [Agents Broke the Economics of Your CI](https://understandingdata.com/posts/agents-broke-your-ci-economics/): Handing the commit button to agents does not just change how code gets written. It quietly rewrites your build cost model, and the multiplier is no longer you. - [The Ops Tax Was the Real Cost of Self-Hosting](https://understandingdata.com/posts/self-hosting-ops-tax-collapsed/): Self-hosting was never expensive because of hardware. It was expensive because of the operational labor. Agents just repriced that labor to near zero. - [How to Make Tool Calling Safe, Secure and With Guard Rails](https://understandingdata.com/posts/tool-calling-guardrails-article/): () {} - [Three Execution Modes: When Your Agent Needs Temporal](https://understandingdata.com/posts/three-execution-modes-api-temporal-agents/): The most common mistake I see in agentic system design is treating Temporal as either the answer to everything or a scary add-on you defer until later. The reality is there are three distinct executio - [Closed-Loop Agent Observability: IDs + Injected Prompts](https://understandingdata.com/posts/closed-loop-agent-observability/): The typical approach to improving your local coding agent observability when generating features is to add logging and hope the agent reads it after the fact. That is backwards. **The right pattern is - [Never Build the First Version: Async Design Variations with Claude Code](https://understandingdata.com/posts/enumerate-before-commit/): Ask for options before building. Drop the artifact to the desktop. Pick while something else runs. - [Ask Your Agent to Create a Live Progress Report](https://understandingdata.com/posts/live-progress-report/): When an agent runs for an hour, make it write the log you will actually read. Markdown to skim, JSON to resume. - [Two Files Keep a Long /goal Run Alive](https://understandingdata.com/posts/split-the-goal-from-the-state/): The brief never changes; the state changes every turn. - [Recursive Self-Improvement Loop for Agent Tooling](https://understandingdata.com/posts/recursive-self-improvement-agent-loop/): A high-leverage loop for agentic engineering is: - [Ask the LLM Where Your Plan Contradicts Itself](https://understandingdata.com/posts/ask-the-llm-where-your-plan-contradicts-itself/): A spec is not pure because it is detailed. A spec is pure when its parts stop fighting each other. - [Developers Are Having an Identity Crisis](https://understandingdata.com/posts/developers-are-having-an-identity-crisis/): Deedy Das named it: most software engineers are facing an identity crisis bordering on depression. - [Why a Pure Reducer Beat MailerLite for Lifecycle Email](https://understandingdata.com/posts/lifecycle-email-engine/): How a pure reducer plus Resend collapsed the cost of running lifecycle email, and why the automation-SaaS calculus flipped. - [The Evolution of AI Coding up to 2026](https://understandingdata.com/posts/evolution-of-ai-coding/): Software was always written in a loop: change something, run it, check the result, repeat. - [AI Code Review](https://understandingdata.com/posts/blast-radius-code-review-dial/): The bottleneck moved. Writing code is the cheap part now, and deciding whether to trust it is the job. Most of the advice I read about agentic code review treats that job as one problem with one answe - [Loop Engineering](https://understandingdata.com/posts/loop-engineering/): A loop is engineered, not launched. - [Comprehension Debt Is Refinanceable](https://understandingdata.com/posts/comprehension-debt-is-refinanceable/): Addy Osmani is right that AI widens the gap between code that exists and code anyone understands. - [Parallel Worktrees Leak Dev Servers. Reap Them Idempotently.](https://understandingdata.com/posts/keeping-parallel-agentic-development-tidy-and-clean/): I ran my dev loop across a dozen git worktrees for months and never thought about what happened to a worktree’s servers when the worktree went away. - [When Parallelism Makes Tests Slower](https://understandingdata.com/posts/scaling-1k-integration-tests/): *A thousand integration tests, sixteen cores, and not much faster. The fix was the easy part. The lasting lesson is that your test suite is the feedback loop your coding agents iterate against, and sc - [The Five Levels Are Gated by Verification, Not Intelligence](https://understandingdata.com/posts/five-levels-gated-by-verification/): Your autonomy level is a property of the repository, not the developer and not the model. - [Computer Use Kills the Config Tax, Not the Trust Tax](https://understandingdata.com/posts/computer-use-kills-the-config-tax/): My sister hates job applications because they make her re-submit information she already has. - [Sentry Errors Should Spawn Agents on Your Own Machine](https://understandingdata.com/posts/sentry-errors-spawn-local-agents/): A new production error is an event. - [The Environment Leads The Agent](https://understandingdata.com/posts/the-environment-leads-the-agent/): For a long time I tried to lead my coding agents with better and better prompts, and they kept drifting. - [Your Own Life Is a Queryable, Validated Corpus](https://understandingdata.com/posts/your-own-life-is-a-queryable-validated-corpus/): Your private data exhaust deserves the same treatment as production data: indexed, validated, version-controlled, and queried by an agent. - [Fabricate The Telemetry Before The Traffic Exists](https://understandingdata.com/posts/fabricate-the-telemetry-before-the-traffic-exists/): You cannot validate a dashboard or an alert with zero traffic, so manufacture the traffic. - [Don’t Let the Model Read the File](https://understandingdata.com/posts/dont-let-the-model-read-the-file/): I built an agent that diagnoses a coding transcript far too big for any context window. The trick was never letting it read the transcript. The model drives computation; the file stays on disk. - [Vendor the Source, Skip the Search](https://understandingdata.com/posts/vendored-source-beats-retrieval/): Give a coding agent the real library source next to your code, and it stops guessing from docs. It reads the patterns instead. - [Fast Playwright E2E Without the Bloat](https://understandingdata.com/posts/fast-playwright-e2e-without-bloat/): Most end-to-end suites die the same way. They start fast, then they bloat. A run creeps from forty seconds to four minutes. A few specs go flaky, so someone bumps the retries. The retries hide the fla - [Write the Pseudocode, Let the LLM Type](https://understandingdata.com/posts/pseudocode-driven-development/): I asked Codex to “build a worker.” - [A DESIGN.md Should Be a Full Spec, Not a Mood Board](https://understandingdata.com/posts/design-md-as-a-full-spec/): If you cannot delete the CSS and regenerate it from the doc, you do not have a design spec. You have a mood board with extra steps. - [How to Easily Translate High Fidelity Prototypes into Functional Apps](https://understandingdata.com/posts/pixel-diffs-are-the-prototype-spec/): Vague specs do not converge. Scalar loss functions do. If you can hand the agent a number that says “you are 0.66 wrong,” it will close the gap on its own. - [The Four-Layer Wall Around Your Library’s Public API](https://understandingdata.com/posts/curated-public-api-as-agent-guardrail/): When an agent loop writes most of your library, the largest risk is not a bug in a feature. - [The Domain Glossary Is a Constraint, Not Documentation](https://understandingdata.com/posts/domain-glossary-as-agent-constraint/): A glossary file at the repo root is the cheapest way I have found to stop an agent loop from quietly inventing a new vocabulary every iteration. - [Coupling Analyzers Were Solved In 2003](https://understandingdata.com/posts/coupling-analyzers-were-solved-in-2003/): Java and C# had topology-aware static analysis for twenty years. JavaScript skipped it. Then AI made the gap load-bearing. - [Three Ways to Track Experiment Config Upstream](https://understandingdata.com/posts/three-ways-to-track-experiment-config/): If I cannot answer “what exactly was running when this experiment scored 0.74”, I do not have an experiment. I have an anecdote. - [The Six Evergreen Levers of Agent Performance](https://understandingdata.com/posts/six-evergreen-levers-of-agent-performance/): Whenever I am stuck in an agent loop chasing the same failure mode for the third time, the bug is rarely the agent. - [Dotfiles as a Shared Agent Brain](https://understandingdata.com/posts/dotfiles-as-shared-agent-brain/): Most dotfiles repos sync your shell. Mine syncs my agents. The same Claude and Codex brain runs on both my machines because their global instructions live in a git-tracked symlink. - [Self-Hostable Observability Is Local Infra, Not SaaS](https://understandingdata.com/posts/self-hostable-observability-is-local-infra/): When I am building my own agent observability I want the agent to be able to read both ends of the stack. - [The Semantic Triangle: Mock Screens, PoC Backend, and Spec File Beat Any One Alone](https://understandingdata.com/posts/semantic-triangle-mock-poc-spec/): Three artefacts. Three reduced ambiguities. One projection task instead of three inventions. - [Contracts Parallelize Agents](https://understandingdata.com/posts/contracts-parallelize-agents/): If you’re waiting for Agent A to finish before starting Agent B, you’re wasting time. Define the contract between them and dispatch both now. - [Mock the LLM, Keep the Tools Real](https://understandingdata.com/posts/mock-the-llm-keep-tools-real/): Agent systems have exactly one non-deterministic component: the model’s choice of tool call. Stub that. Let everything else run. - [Hand-Roll the Core](https://understandingdata.com/posts/hand-roll-the-core/): The further a piece of code sits from the core of your system, the more you can give to agents. - [Techniques for Overcoming Chat Psychosis Bias](https://understandingdata.com/posts/techniques-for-overcoming-chat-psychosis-bias/): Chatbots are trained to preserve rapport with the user. - [DRY: Dev Utils Panels Beat Manual State Setup](https://understandingdata.com/posts/dev-utils-panels-beat-manual-state-setup/): Every repeated setup ritual is an undeclared API waiting to be formalised. Build the panel once, skip the ritual forever. - [How to Protect Your Coding Harness from Longer Integration Test Runs](https://understandingdata.com/posts/protect-harness-from-longer-integration-tests/): Integration test suites get slower under LLM-assisted development. Not because the tests themselves are fundamentally slow, but because agents have every incentive to bump the timeout when they hit it - [Skills Need Evals, Not Vibes](https://understandingdata.com/posts/skills-need-evals-not-vibes/): A skill you cannot measure against no skill is just a prompt you felt good about. - [Code Complexity Is Agent Drag](https://understandingdata.com/posts/code-complexity-as-agent-drag/): Complexity used to be a tax on the humans who read the code. In the agent era, it is a tax on every inference, every edit, and every tool call that touches the file. - [Edit-Locking Hand-Crafted Logic with Agent Hooks](https://understandingdata.com/posts/edit-locking-hand-crafted-logic/): Some functions in my codebase are finished. I have hand-tuned them, stress-tested them, and paid in incidents for every edge case they handle. I do not want a coding agent to “improve” them. The fix i - [The Execution Harness That Lets Agents Ship Code](https://understandingdata.com/posts/execution-harness-for-agentic-coding/): Why determinism, schema isolation, and enforced layering are the real unlocks for agentic coding. - [Throw Errors as Agent Trajectory Corrections](https://understandingdata.com/posts/throw-errors-as-agent-trajectory-corrections/): When AI agents drive development, they mutate state. They create files, run scripts, generate configs. Sometimes they skip a step or do something in the wrong order. Traditional error messages describ - [Dependency Chains Gate Your Throughput](https://understandingdata.com/posts/dependency-chains-gate-throughput/): When your work is serial, agent latency becomes wall-clock latency. No amount of tooling eliminates the wait. The productive move is redirecting your energy, not fighting the constraint. - [The Sandbox Is a Harness](https://understandingdata.com/posts/the-sandbox-is-a-harness/): When code becomes the interface between users and systems, the sandbox stops being a security primitive. It becomes a harness for intent. - [Architecture Is a Gradient, Not a Binary](https://understandingdata.com/posts/architecture-is-a-gradient/): Every layer of structure you add buys you something and costs you something. The skill is knowing the exchange rate. - [DDD, FP, and Event-Driven Architecture: Meaning, Control, and Flow](https://understandingdata.com/posts/ddd-fp-event-driven-stack/): DDD tells you who owns what. FP tells you how to compose it safely. Event-driven architecture tells you how change moves through the system. - [Memory Engineering as Data Modelling](https://understandingdata.com/posts/memory-engineering-as-data-modelling/): Agent memory is not a feature. It is a data modelling problem with a lifecycle. - [Concept Template](https://understandingdata.com/posts/concept-template/): Use this template for each new concept. Copy and rename. - [Jobs, Money & Safety](https://understandingdata.com/posts/jobs-and-money/): A job is not shame; it’s a tool. - [Emotional Discipline](https://understandingdata.com/posts/emotional-discipline/): Your job is not to feel good; it’s to stay rational. - [2026 Systems Engineering Roadmap](https://understandingdata.com/posts/2026-systems-engineering/): Deep understanding of Linux, distributed systems, and Effect.ts to build production-grade agent infrastructure. - [Agentic Observability](https://understandingdata.com/posts/agentic-observability/): If you cannot trace what an agent did and why, you cannot debug it or improve it. - [Risk Management](https://understandingdata.com/posts/risk-management/): You can take asymmetric bets only if the floor is protected. - [When to Persist vs Stop](https://understandingdata.com/posts/persistence-framework/): Persistence without feedback is stubbornness. Persistence with feedback is strategy. - [Value Creation as North Star](https://understandingdata.com/posts/value-creation/): In the long run, the true measure of success is not revenue milestones, vanity metrics, or even personal freedom, but the amount of real value created for customers. - [Probability & Statistics](https://understandingdata.com/posts/probability/): Foundational for decision-making under uncertainty. - [Optimisation](https://understandingdata.com/posts/optimisation/): Finding the best solution under constraints. - [Control Theory & Feedback](https://understandingdata.com/posts/control-theory/): Systems thinking in mathematical form. - [Prompt Contracts: Formal Specifications That Eliminate Vibe Coding](https://understandingdata.com/posts/prompt-contracts-specification-before-code/): A prompt contract is a structured 8-section specification you generate before an AI agent writes any code. It defines the objective, pre-conditions, invariants (what must not change), exact file scope - [Buy Orchestration, Own Semantics](https://understandingdata.com/posts/buy-orchestration-own-semantics/): The five layers of an agent system are not mutually exclusive. You do not need alpha in all of them. But you need to know which ones are hard and which ones are solved. - [Moats vs Execution: Code Was Never a Moat](https://understandingdata.com/posts/moats-vs-execution/): Moats set the ceiling on value capture. Execution determines how close you actually get. They are fully independent variables. - [Model Downgrade Testing Hardens Agent Skills](https://understandingdata.com/posts/model-downgrade-testing-hardens-agent-skills/): If your skill only works with Opus, you don’t have a good skill. You have a good model compensating for bad instructions. - [Adaptive Query Expansion for Agent Review](https://understandingdata.com/posts/adaptive-query-expansion-for-agent-review/): Static review checklists miss context-specific issues. Borrowing “query expansion” from information retrieval, a coordinator agent dynamically generates review queries tailored to the artifact under r - [ESLint Rules Are Programs](https://understandingdata.com/posts/eslint-rules-as-programs/): Lint rules don’t just catch mistakes. When stacked deliberately, they form a declarative program that guides agent behaviour through a codebase. - [Doc Drift Detection in CI: Catching Stale Docs on Every Merge](https://understandingdata.com/posts/doc-drift-detection-ci/): **Source:** [Dosu – Taylor Dolezal](https://dosu.dev/blog/how-to-catch-documentation-drift-claude-code-github-actions) | **Date:** March 6, 2026 - [Context Graphs Turn Decisions Into Data](https://understandingdata.com/posts/context-graphs-turn-decisions-into-data/): Systems of record store the final state. Context graphs store the reasoning, exceptions, and approvals that made that state legitimate. - [Progressive Disclosure Beats Context Dumping](https://understandingdata.com/posts/progressive-disclosure-beats-context-dumping/): Do not start by dumping memory into the context window. Start by showing what exists and what it costs to load. - [Skills Marketplaces Turn Agent Workflows Into Installable Infrastructure](https://understandingdata.com/posts/skills-marketplaces-turn-agent-workflows-into-installable-infrastructure/): Prompt marketplaces distributed text. Skills marketplaces distribute operating behavior. - [Vectorless RAG: Hierarchical Tree Retrieval Without Embeddings](https://understandingdata.com/posts/vectorless-rag-hierarchical-tree-retrieval/): Instead of embedding documents and doing similarity search, build a tree from the document and let an LLM navigate it level by level, like scanning a table of contents. - [Runtime Skills Turn Documentation Into Capability](https://understandingdata.com/posts/runtime-skills-turn-documentation-into-capability/): A workflow written in a note is advice. A workflow encoded as a skill is capability. - [Frontmatter Coverage Determines Retrieval Quality](https://understandingdata.com/posts/frontmatter-coverage-determines-retrieval-quality/): A frontmatter schema is only as useful as its coverage. Partial typing creates a split knowledge base. - [Session Compaction Preserves Agent Trajectory](https://understandingdata.com/posts/session-compaction-preserves-agent-trajectory/): The point of compaction is not to save tokens. The point is to preserve the working trajectory of the session. - [How I’m Optimising Diffcore for Semantic Grouping](https://understandingdata.com/posts/optimising-diffcore-semantic-grouping/): Diffcore turns raw diffs into review flows. This is how I’m improving its AST and IR pipeline, deterministic grouping engine, and LLM refinement pass so semantically similar changes land together. - [Outsourced Tables Are Anti-Agent](https://understandingdata.com/posts/outsourced-tables-cost-agent-accuracy/): Every third-party table you depend on is a join you’ll pay for forever. When agents reason over your domain, the schema IS the context. Split it across systems and you split their ability to think. - [Throughput Inverts Merge Philosophy](https://understandingdata.com/posts/throughput-inverts-merge-philosophy/): When agent throughput exceeds human review capacity, corrections become cheap and waiting becomes expensive. - [Build a Harness Is the New Reverse a Linked List](https://understandingdata.com/posts/build-a-harness-is-the-new-reverse-a-linked-list/): The interview question used to be “reverse a linked list.” Now it’s “build me a small agent harness.” - [The Human Bottleneck Is a Quality Mechanism](https://understandingdata.com/posts/human-bottleneck-is-quality-mechanism/): The speed limit humans impose on code production isn’t a limitation to overcome. It’s the mechanism that keeps codebases maintainable. - [Ship the Prompt: CLIs That Onboard Their Own Agents](https://understandingdata.com/posts/ship-the-prompt-cli-agent-onboarding/): The most effective CLI distribution strategy for agents isn’t MCP, docs, or –help. It’s shipping the prompt the agent should run upon installation. - [Zero-Cost Divergence: Generate Ten, Ship One](https://understandingdata.com/posts/zero-cost-divergence/): The cost of exploring bad ideas has dropped to zero. The winning strategy is no longer “design carefully, build once.” It is “build many cheaply, pick the best.” - [Tree-Sitter Turned Everyone Into a Toolsmith](https://understandingdata.com/posts/tree-sitter-turned-everyone-into-a-toolsmith/): Writing a parser used to mean writing a compiler. - [AI Daemons: Persistent Background Agents for Operational Debt](https://understandingdata.com/posts/ai-daemons-maintenance-roles/): **Source:** [Riley Tomasek (@rileytomasek)](https://x.com/rileytomasek) | **Date:** March 2026 - [Generator-Evaluator Harness Design: Anthropic’s GAN-Inspired Architecture for Long-Running Apps](https://understandingdata.com/posts/generator-evaluator-harness-design/): Separating generation from evaluation is far more tractable than making a generator critical of its own work. - [The MCP Abstraction Tax: Why Every Protocol Layer Costs You Fidelity](https://understandingdata.com/posts/mcp-abstraction-tax/): Every layer between an agent’s intent and an API loses expressiveness. MCP adds a layer. Understanding what that layer costs you matters more than picking a winner. - [Monitor Generation from Diffs: Self-Maintaining Production Systems](https://understandingdata.com/posts/monitor-generation-from-diffs/): When code changes, the observability surface should change with it. Instead of hand-writing monitors, an agent reads the PR diff on merge and generates monitors that instrument the new code. When a mo - [Conversational Code Review: Agent-Assisted Understanding of Large Diffs](https://understandingdata.com/posts/conversational-code-review/): Instead of staring at mega-diff walls, have an agent read the ticket and the diff, then hold a conversation with it about intent, impact, and risk. The agent surfaces things impacted by the change but - [Audio Notification Hooks: Know Which Session Finished](https://understandingdata.com/posts/audio-notification-hooks/): When running multiple Claude Code sessions in parallel, you need to know when each one finishes without constantly checking every terminal window. A Stop hook that plays a system sound via `afplay` le - [Voice-to-Agent Pipeline: Speech as the Fastest Input Modality](https://understandingdata.com/posts/voice-to-agent-pipeline/): Typing is the bottleneck for communicating intent to coding agents. Voice dictation tools like Monologue and WhisperFlow pipe speech directly into Claude Code, letting you describe features, bugs, and - [The Coder is Obsolete. The Programmer is Not.](https://understandingdata.com/posts/the-coder-is-obsolete-the-programmer-is-not/): AI agents now write code at over 80% success rates on standard tasks. Context engineering, better prompting, and iterative workflows have pushed them past the threshold of usefulness. The era where hu - [The Struggle Is the Product](https://understandingdata.com/posts/the-struggle-is-the-product/): AI makes it easy to skip the learning that makes you effective. - [The Ladder of Coding Abstraction](https://understandingdata.com/posts/ladder-of-coding-abstraction/): Match the tool to the task. A sanding machine for walls, a detail sander for corners, sandpaper by hand for banisters. The same principle governs how you use AI coding tools. - [Watch the Ralph](https://understandingdata.com/posts/watch-the-ralph/): What happens when you point the RALPH loop at a non-trivial Rust project and let it run for a full day. The raw output, the surprises, and the patterns that emerged. - [The Evaluator-Optimizer Loop: Evolutionary Search for Anything You Can Judge](https://understandingdata.com/posts/evaluator-optimizer-evolutionary-search/): The two most important ideas in applied AI right now share the same skeleton. Strip away the specifics and you get one pattern: **build a stable evaluator, then let agents search the space until they - [Zero-Friction Knowledge Capture Pipeline](https://understandingdata.com/posts/zero-friction-knowledge-capture/): Obsidian + Claude Code + QMD eliminates all friction between seeing an idea and having it searchable, deduplicated, and published. - [Linux Is the Execution Substrate](https://understandingdata.com/posts/linux-is-the-execution-substrate/): The only layer in your stack that AI does not abstract away. - [Markdown Files as State Machines for AI Development Workflows](https://understandingdata.com/posts/markdown-files-as-state-machines/): A structured markdown file can function as a reliable state machine for orchestrating multi-step AI development workflows. The key insight: prose instructions fail because LLMs treat them as suggestio - [Frontmatter as Document Schema: Why Your Knowledge Base Needs Type Signatures](https://understandingdata.com/posts/frontmatter-as-document-schema/): Frontmatter is structured metadata at the top of a file that declares what a document is, what it contains, and how it should be discovered. In agent-driven systems, frontmatter serves the same role t - [Pre-Commit Integration Tests: The LLM Regression Gate](https://understandingdata.com/posts/pre-commit-integration-tests-llm-regression-gate/): Pre-commit hooks that run integration tests are the sweet spot for preventing LLM-caused regressions from ever being committed. Pair this with linter configs that treat violations as errors (not warni - [AI Leverage Without Skill Atrophy](https://understandingdata.com/posts/ai-leverage-without-skill-atrophy/): Manual coding keeps the skill alive. Systems thinking is needed. Long term you need to leverage AI and leverage your brain. Not outsource thinking. - [Formal Verification for Agent Orchestration](https://understandingdata.com/posts/formal-verification-for-agent-orchestration/): Your LLM is non-deterministic. Your orchestrator is not. Verify the part you control. - [Autonomous Loops Need a Scoring Function](https://understandingdata.com/posts/autonomous-loops-need-benchmarks/): Without a benchmark, a RALPH loop is a chaos engine. With one, it becomes automated hill climbing. The difference is not the loop. It is the objective. - [Reverse Ralph Loop](https://understandingdata.com/posts/reverse-ralph-loop/): Use the Ralph Loop pattern to reverse-engineer existing software from public resources into clean-room specifications, then regenerate a functionally equivalent implementation. - [Skill Graphs: Networked Knowledge Beats Monolithic Skill Files](https://understandingdata.com/posts/skill-graphs-networked-agent-knowledge/): A single skill file captures one capability. A skill graph captures an entire domain. The difference is whether your agent can follow instructions or reason through a field. - [LLM VCR and Agent Trace Hierarchy: Deterministic Replay for Agent Pipelines](https://understandingdata.com/posts/llm-vcr-and-agent-trace-hierarchy/): Three patterns that turn agent pipelines from opaque prompt chains into debuggable, reproducible engineering systems: (1) an LLM VCR that records and replays model interactions, (2) a Run > Step > Mes - [Agent Search Observation Loop: Learning What Context to Provide](https://understandingdata.com/posts/agent-search-observation-loop/): Watch how the agent navigates your codebase. What it searches for tells you what to hand it next time. - [The Two Camps of Agentic Coding](https://understandingdata.com/posts/two-camps-of-agentic-coding/): One camp talks to models. The other camp specifies systems. The second camp is where the real leverage lives. - [Traditional ML vs AI Engineers](https://understandingdata.com/posts/traditional-ml-vs-ai-engineers/): The fundamental difference is the **order of operations**. - [The Harness Is Cheaper Now](https://understandingdata.com/posts/the-harness-is-cheaper-now/): Building the harness used to be overhead. Now it is cheaper than building the thing and figuring out what is wrong with it. - [Code Stewardship Over Authorship](https://understandingdata.com/posts/code-stewardship-over-authorship/): AI generates code faster than humans can reason about it. Ownership must shift from authorship to stewardship. - [Push Orchestration Down the Stack: A Three-System Model for AI Agents](https://understandingdata.com/posts/push-orchestration-down-the-stack/): The LLM should decide what to do. Everything else should happen somewhere else. - [Assume Wrong by Default: Mining LLM Latent Space for Correctness](https://understandingdata.com/posts/assume-wrong-by-default/): A single pass through a coding LLM is a single sample from a probability distribution. You would not ship a system tested once. Do not ship code reviewed once. - [Attention Arbitrage: Delegate to Agents](https://understandingdata.com/posts/attention-arbitrage-delegate-to-agents/): Human attention is scarce. Agents are cheap. Default to delegation. - [Zero-Cost Knowledge Extraction](https://understandingdata.com/posts/zero-cost-knowledge-extraction/): The bottleneck has shifted from execution to signal detection. - [The Session Audit Meta-Prompt](https://understandingdata.com/posts/session-audit-meta-prompt/): Run one prompt against your own usage history and it tells you exactly where to invest your automation effort. - [Function-Driven Development](https://understandingdata.com/posts/function-driven-development/): Give your agent a fake tool. Let it tell you what the real ones should be. - [Auto-Harness Synthesis](https://understandingdata.com/posts/auto-harness-synthesis/): The future of agent systems is agents that write their own constraint layers, not humans hand-coding guardrails. - [ASCII Previews Before Expensive Renders](https://understandingdata.com/posts/ascii-previews-before-expensive-renders/): Image and video generation are among the most expensive API calls you can make. A single image render costs $0.02-0.20+, and video generation can cost dollars per clip. Before triggering these renders - [The Six-Layer Lint Harness: What Actually Scales Agent-Written Code](https://understandingdata.com/posts/six-layer-lint-harness-case-study/): Rules eliminate entire bug classes permanently. But rules alone aren’t enough. You need the three-legged stool: structural constraints, behavioral verification, and generative scaffolding. - [The Rise of the AI Engineer](https://understandingdata.com/posts/rise-of-the-ai-engineer/): A new engineering role is emerging between ML research and software engineering, focused on building products with foundation models via APIs. - [Rewrite Your CLI for AI Agents](https://understandingdata.com/posts/rewrite-cli-for-agents/): Human DX optimizes for discoverability and forgiveness. Agent DX optimizes for predictability and defense-in-depth. - [Monte Carlo Quality Assurance: Brute-Force Stochastic Hardening for AI-Generated Code](https://understandingdata.com/posts/monte-carlo-quality-assurance/): Repeatedly prompting an agent to “harden everything” for hours works. The question is whether you automate the loop or pay for it with your time. - [Error Registry for Agents: Own the Primitives](https://understandingdata.com/posts/error-registry-for-agents/): Agents repeat errors they have no memory of. ERRORS.md files help, but they are flat, unstructured, and require manual curation. The next step is a proper **error registry**: a structured, queryable s - [Backend-First Products: The Agent-Era Indie Startup Playbook](https://understandingdata.com/posts/backend-first-for-indie-startups/): Build backend products, then ship a frontend. Agents are cracked at backend and limited at frontend. - [Agentic Engineering Patterns: Linear Walkthroughs](https://understandingdata.com/posts/agentic-engineering-patterns-linear-walkthroughs/): Linear walkthroughs are a practical technique for reducing ambiguity in agent runs. By forcing a step-by-step, inspectable path through a task, they improve reproducibility, debugging speed, and team - [Agentic Engineering Patterns: Code Is Cheap](https://understandingdata.com/posts/agentic-engineering-patterns-code-is-cheap/): This piece reframes a core operating principle for AI-assisted engineering: generating code is cheap, but validating behavior, preserving context quality, and maintaining system reliability are the re - [Agent Sprawl and the Two Constraint Modes](https://understandingdata.com/posts/agent-sprawl-two-constraint-modes/): Every agent task needs a termination condition. If the task has ambiguous completion criteria, the agent will sprawl until you run out of tokens. - [Agent Skill Bootstrapping: Agents That Build Their Own Capabilities](https://understandingdata.com/posts/agent-skill-bootstrapping/): The most interesting agents don’t just use skills. They create new ones when they find a gap, and those skills persist across sessions. - [AI-Native Principles](https://understandingdata.com/posts/ai-native-principles/): Principles for operating in a world where agents write most of the code and inference is cheap. - [Own Your Control Plane](https://understandingdata.com/posts/own-your-control-plane/): If you use someone else’s task manager, you inherit all of their abstractions. In a world where LLMs make software a solved problem, the cost of ownership has flipped. - [Indexed PRD and Design Doc Strategy](https://understandingdata.com/posts/indexed-prd-design-docs/): A documentation-driven development pattern where a single `index.md` links all PRDs and design documents, creating navigable context for both humans and AI agents. - [Why Effect Fits LLM Orchestration](https://understandingdata.com/posts/effect-fits-llm-orchestration/): LLMs are stochastic. Your infrastructure cannot be. Effect gives you deterministic orchestration around non-deterministic cores. - [Tool Call Validation: JSON Schema Validation for Tool Outputs](https://understandingdata.com/posts/tool-call-validation/): Tool call validation enforces type safety at the boundary between LLM outputs and deterministic code. When an agent returns a tool call, the response is a JSON object with a tool name and parameters. - [Tool Access Control: Restricting Sub-Agent Capabilities](https://understandingdata.com/posts/tool-access-control/): Tool access control enforces the principle of least privilege for AI sub-agents by restricting which tools each agent can use and which files it can access. A backend engineer gets Read, Write, Edit, - [Token Budgeting Strategies: Allocating Context by Information Density](https://understandingdata.com/posts/token-budgeting-strategies/): Token budgeting is the practice of allocating your finite context window to maximize information value per token spent. Like a financial budget, you have limited resources (tokens) and competing deman - [System Design and Invariants: The Meta Spec](https://understandingdata.com/posts/system-design-and-invariants-pattern/): One document to rule them all. Every table, every subsystem, every invariant, every relationship. PRDs and design docs are detail views. This is the holistic truth. - [Synthetic Loss Functions for Agent Swarms: Treating Software Production as Optimization](https://understandingdata.com/posts/synthetic-loss-functions-agent-swarms/): Traditional development measures progress by output (features shipped). The right measure is whether system error decreases over time. - [Symlinked Project Docs: Obsidian as Single Source of Truth for Agent Context](https://understandingdata.com/posts/symlinked-project-docs-for-agents/): Keep all project documentation in a single Obsidian vault, then symlink specific subfolders into each git repository. Agents working in a repo get project-specific docs without duplication. Edit in on - [Sub-Agent Swarm Convergence: Why Swarms Converge or Explode](https://understandingdata.com/posts/swarm-convergence-theory/): The hard problem is not generating code. The hard problem is ensuring that multiple autonomous agents acting in parallel reduce system error instead of amplifying it. - [Sub-Agent Context Hierarchy: Managing Context Isolation in Multi-Agent Systems](https://understandingdata.com/posts/sub-agent-context-hierarchy/): Sub-agent context hierarchy is a pattern for managing what context each specialized agent receives in a multi-agent system. By organizing context into three layers (Root, Agent, Package), you can give - [Prompt Injection Prevention](https://understandingdata.com/posts/prompt-injection-prevention/): Prompt injection attacks manipulate LLMs by inserting malicious instructions into user input, potentially bypassing system prompts, extracting sensitive data, or causing unintended behavior. Defense r - [PRD-Design-Code-Test Pipeline](https://understandingdata.com/posts/prd-design-code-test-pipeline/): Requirements docs for the WHAT. Design docs for the HOW. Code for the implementation. Tests for the proof. - [Orchestration Patterns: Coordinator, Swarm, and Pipeline](https://understandingdata.com/posts/orchestration-patterns/): Multi-agent systems require orchestration to coordinate work across specialized agents. Three fundamental patterns address different coordination needs: the **Coordinator** pattern uses a central orch - [Online Learning via Constraints: The Worker-Observe-Constrain Loop](https://understandingdata.com/posts/online-learning-via-constraints/): You are not “coding with an LLM.” You are running a compute fabric for reasoning, then constraining it based on observed failures. That is online learning applied to software production. - [Measuring Context Effectiveness with Mutual Information](https://understandingdata.com/posts/mutual-information-context/): Mutual information quantifies how much your context reduces uncertainty in LLM outputs. This article provides practical methods to measure context effectiveness: output variance testing, A/B compariso - [List of Values Filtering: Natural Language Replaces UI Controls](https://understandingdata.com/posts/lov-filtering-for-agent-tools/): Instead of sidebar filters and dropdowns, give the model a List of Values (LOV) for tool parameters and let natural language do the filtering. - [Lost in the Middle: Preventing Context Window Attention Degradation](https://understandingdata.com/posts/lost-in-the-middle-mitigation/): Large language models exhibit a U-shaped attention pattern: they attend most strongly to information at the beginning and end of their context window, while information in the middle receives reduced - [Long-Running Agent Patterns: Shell, Skills, and Compaction](https://understandingdata.com/posts/long-running-agent-patterns/): Production agents that run for extended periods need three primitives: reusable skills, persistent shell environments, and proactive compaction. - [Human-in-the-Loop Patterns: Approval, Input, and Escalation Workflows](https://understandingdata.com/posts/human-in-the-loop-patterns/): Human-in-the-loop (HITL) patterns enable AI agents to request human approval, gather information, or escalate problems mid-execution. The key insight from 12 Factor Agents (Factor 7) is treating human - [Growth vs Polish Phases: Phase Switching for Agentic Development](https://understandingdata.com/posts/growth-vs-polish-phases/): If you never switch modes, entropy wins. Growth without stabilization is just sophisticated destruction. - [GraphRAG for Production Engineer Agents](https://understandingdata.com/posts/graphrag-for-production-agents/): Your agent’s reasoning is fine. Its memory isn’t. GraphRAG turns organizational knowledge into a connected graph that agents can traverse for incident response. - [Goodharting Prevention in Agent Systems: When Agents Game Your Metrics](https://understandingdata.com/posts/goodharting-prevention-agent-systems/): “When a measure becomes a target, it ceases to be a good measure.” Goodhart’s Law applies to agent swarms with extra force because agents optimize faster than humans can audit. - [Event Sourcing for Agents: Log-Based Architecture for Stateless AI Systems](https://understandingdata.com/posts/event-sourcing-agents/): Event sourcing stores agent state as an append-only sequence of events rather than current values. This pattern enables complete audit trails, time-travel debugging, natural checkpoint/resume support, - [Context Pollution Recovery: Diagnosing and Fixing Degraded AI Sessions](https://understandingdata.com/posts/context-pollution-recovery/): Context pollution occurs when accumulated noise, contradictions, or stale information in an AI session degrades output quality. This article provides a systematic approach to detect pollution symptoms - [The Constraint Escalation Ladder: Choosing the Right Prevention Layer](https://understandingdata.com/posts/constraint-escalation-ladder/): When you catch something in the codebase, pick the lightest durable fix. If you jump straight to ESLint each time, you skip the layers that produce the strongest convergence. - [CI/CD Patterns for AI Agents: GitHub Actions for Agent Verification](https://understandingdata.com/posts/ci-cd-agent-patterns/): CI/CD for AI agents requires different patterns than traditional software. Agents are non-deterministic, expensive to run, and require behavioral verification beyond unit tests. This article covers Gi - [Checkpoint Commit Patterns: Git Strategies for AI-Assisted Development](https://understandingdata.com/posts/checkpoint-commit-patterns/): Git commits serve as safety checkpoints in AI-assisted development. Frequent, atomic commits after each successful change enable rapid recovery when AI-generated code fails, provide clear audit trails - [Batch API Patterns for Cost Reduction](https://understandingdata.com/posts/batch-api-patterns/): The Anthropic Batch API provides 50% cost reduction on API calls by processing requests asynchronously with up to 24-hour turnaround. For non-time-sensitive workloads like nightly code reviews, test g - [Agent Memory Patterns: Checkpoint, Resume, and State Persistence](https://understandingdata.com/posts/agent-memory-patterns/): AI agents are fundamentally stateless. Every conversation starts fresh, every context window eventually expires. Agent memory patterns solve this by externalizing state to durable storage, enabling ch - [The Actor-Critic Pattern: Writer + Reviewer Agents](https://understandingdata.com/posts/actor-critic-pattern/): The actor-critic pattern separates generation from evaluation. One agent (the actor/writer) produces output, while another (the critic/reviewer) evaluates and improves it. This separation creates high - [Agent-Driven Development](https://understandingdata.com/posts/agent-driven-development/): A workflow where AI agents execute development tasks from structured specs, with humans controlling the task layer rather than writing code directly. - [Thought Leaders](https://understandingdata.com/posts/thought-leaders/): People to follow for compound engineering, context engineering, and AI agent development. - [Systems Thinking & Observability](https://understandingdata.com/posts/systems-thinking/): Software should be treated as a measurable dynamical system, not as a collection of features. - [Career Archetypes](https://understandingdata.com/posts/software-archetypes/): How different people actually play the game - [50 Rules to Live By](https://understandingdata.com/posts/rules-to-live-by/): One-page grounding document for your 30s - [The Compound Systems Engineer Doctrine](https://understandingdata.com/posts/my-doctrine/): A personal doctrine, archetype map, and risk framework - [Liquidation Cadence](https://understandingdata.com/posts/liquidation-cadence/): Experimentation keeps my edge sharp. Liquidation cadence keeps my feet on the ground. - [Infrastructure Principles](https://understandingdata.com/posts/infrastructure-principles/): Anchor your career on a moat, not a role. - [Histogram Metrics in Batch Workloads](https://understandingdata.com/posts/histogram-metrics-batch-workloads/): When analyzing Prometheus histogram metrics (p50, p95, p99) for batch/nightly jobs, you’ll often see latency “spike” **after** the workload completes. This is a statistical artifact, not a real perfor - [Zero-Friction Onboarding: Setup Speed Predicts AI Effectiveness](https://understandingdata.com/posts/zero-friction-onboarding/): Setup time from git clone to working system directly correlates with AI coding agent effectiveness. If a junior developer can’t get the system running in 5 minutes, Claude Code will struggle too. Auto - [YOLO Mode Configuration: Eliminating Permission Prompts for Flow State](https://understandingdata.com/posts/yolo-mode-configuration/): Permission prompts destroy flow state by forcing context switches every few minutes. YOLO mode runs Claude Code with –dangerously-skip-permissions to eliminate all confirmation dialogs. While the fla - [Writing a Good CLAUDE.md](https://understandingdata.com/posts/writing-a-good-claude-md/): CLAUDE.md onboards Claude with WHY, WHAT, HOW. Keep it minimal, universally applicable, and carefully crafted. - [Verification Sandwich Pattern: Always Know Your Baseline](https://understandingdata.com/posts/verification-sandwich-pattern/): LLMs generate code without knowing if the current state is clean, leading to confusion about whether failures are new or pre-existing. The verification sandwich pattern solves this by running all qual - [The Verification Ladder](https://understandingdata.com/posts/verification-ladder/): Types → Schema → Unit tests → Property tests → Formal verification. Each rung catches what the lower rungs miss. - [Upfront Questioning Narrows Search Space](https://understandingdata.com/posts/upfront-questioning-narrows-search-space/): When specifications are vague, ask Claude Code to ask you lots of questions before implementing. This narrows the solution space before any code is written. - [Type-Driven Development: Specifications Over Implementation](https://understandingdata.com/posts/type-driven-development/): Type-Driven Development (TDD-inverted) writes types first as executable specifications, then implements code to satisfy those types. This approach is especially powerful for LLM-assisted development b - [Trust But Verify Protocol: AI-Generated Tests Over Manual Review](https://understandingdata.com/posts/trust-but-verify-protocol/): Reviewing all AI-generated code manually is time-consuming and error-prone. Instead of reviewing 1000+ lines of generated code, ask the AI to write verification tests and review just the test output. - [The Meta-Engineer Identity](https://understandingdata.com/posts/the-meta-engineer-identity/): You’re no longer building products. You’re building systems that build products. This is the meta-layer where leverage lives. - [Test-Driven Prompting: Write Tests Before Generating Code](https://understandingdata.com/posts/test-driven-prompting/): Write tests before prompting LLMs to generate code. Tests act as executable specifications that constrain the solution space, reducing entropy from millions of possible implementations to tens of corr - [Test Custom Infrastructure: Avoiding the House on Stilts](https://understandingdata.com/posts/test-custom-infrastructure/): Custom tooling that doesn’t work creates cascading failures downstream. Like building a house on stilts, this article shows how to treat custom infrastructure (test utilities, CLIs, parsers, build scr - [Test-Based Regression Patching: 50% Faster Bug Fixes](https://understandingdata.com/posts/test-based-regression-patching/): Write a failing test that reproduces the bug before asking an LLM to fix it. This reduces fix iterations by 50%+ by giving the LLM a concrete verification target and preventing regressions. The test b - [Symlinked Agent Configuration Files: Single Source of Truth for Multi-Tool AI Development](https://understandingdata.com/posts/symlinked-agent-configs/): Multiple AI coding tools require separate configuration files, leading to duplicated rules and drift between tools. Use symlinks to maintain a single source of truth for coding standards, patterns, an - [Sub-agents: Accuracy vs Latency Trade-off](https://understandingdata.com/posts/sub-agents-accuracy-vs-latency/): Sub-agents trade latency for accuracy. Use them when correctness matters more than speed. - [Sub-Agent Architecture: Specialized Agents for Higher Quality Code](https://understandingdata.com/posts/sub-agent-architecture/): **First time here?** Start with [[sub-agents-accuracy-vs-latency|Accuracy vs Latency]] to decide if sub-agents are right for your use case. - [Stateless Verification Loops: Preventing State Accumulation in AI Workflows](https://understandingdata.com/posts/stateless-verification-loops/): Stateless verification loops ensure each verification cycle starts from a clean slate, preventing accumulated state from causing drift and false positives. By resetting state between iterations, you a - [Sliding Window History for Bounded State Management](https://understandingdata.com/posts/sliding-window-history/): Prevent unbounded state growth in automated scanners by keeping only the last N months of history. This pattern ensures state files remain small, git-friendly, and contain only relevant data for trend - [Skill Atrophy: What to Keep, What to Let Go](https://understandingdata.com/posts/skill-atrophy-what-to-keep-what-to-let-go/): Some atrophy is inevitable. The key is steering it toward low-leverage skills while protecting high-leverage ones. - [Six Waves of AI Coding](https://understandingdata.com/posts/six-waves-of-ai-coding/): A framework for understanding the rapid evolution of AI-assisted software development and its career implications. - [Semantic Naming Patterns](https://understandingdata.com/posts/semantic-naming-patterns/): **Name things as you would search for them.** - [The RALPH Loop](https://understandingdata.com/posts/ralph-loop/): Fresh context each iteration. Memory lives in git, docs, and task files—not in the conversation. - [Quality Gates as Information Filters: Reducing State Space Through Verification](https://understandingdata.com/posts/quality-gates-as-information-filters/): Quality gates function as information filters that progressively reduce the state space of valid programs through set intersection. Each gate (type checker, linter, tests) eliminates invalid program s - [Property-Based Testing for LLM-Generated Code: Catching Edge Cases Automatically](https://understandingdata.com/posts/property-based-testing/): LLM-generated code often fails on edge cases that example-based tests don’t cover. Property-based testing uses libraries like fast-check to generate hundreds of random inputs and verify invariants aut - [Prompts Are the Asset, Not the Code](https://understandingdata.com/posts/prompts-are-the-asset-not-the-code/): The spec and prompts that generated the code are more valuable than the code itself. - [Prompt Caching Strategy for 90% Cost Reduction](https://understandingdata.com/posts/prompt-caching-strategy/): Structure prompts to maximize Claude’s prompt caching by putting stable context first and variable requests last. Achieves 90% cost reduction for iterative workflows by caching repeated context like C - [Progressive Disclosure: Load Context Only When Needed](https://understandingdata.com/posts/progressive-disclosure-context/): “Agents with filesystem and code execution tools don’t need to load entire skills into their context window—they can read files as needed.” - [Prevention Protocol: Turn Every Bug Into a Stepping Stone](https://understandingdata.com/posts/prevention-protocol/): After fixing any bug, ask one critical question: “How could we avoid this from happening again?” This simple protocol transforms recurring bugs into systematic improvements. By implementing 2-3 preven - [Playwright Script Loop: Generate Scripts for Faster Validation Cycles](https://understandingdata.com/posts/playwright-script-loop/): Using Playwright MCP tool calls for validation creates slow feedback loops with high overhead. Instead, generate Playwright validation scripts that can be run directly, creating faster iteration cycle - [Plan Mode for Strategic Thinking: Architecture Before Implementation](https://understandingdata.com/posts/plan-mode-strategic/): Claude Code often jumps directly to implementation without considering architectural complexity, leading to rework and technical debt. Plan Mode (Shift+Tab) enables strategic thinking before execution - [Parallel Agents for Monorepo-Wide Changes: 10x Speedup](https://understandingdata.com/posts/parallel-agents-for-monorepos/): “Update `@company/logger` from v2 to v3 across all 20 packages in our monorepo. The API changed—replace `logger.log()` with `logger.info()`.” - [One-Way Pattern Consistency: Eliminate Optionality for LLM Determinism](https://understandingdata.com/posts/one-way-pattern-consistency/): LLMs excel at pattern matching but struggle with optionality. Enforce exactly ONE way to solve each problem in your codebase—eliminate all alternatives through ESLint rules, CLAUDE.md constraints, and - [Negative Examples in Documentation: Teaching LLMs Through Contrast](https://understandingdata.com/posts/negative-examples-documentation/): When documenting coding patterns for AI agents, most developers only show **what to do**: - [Multi-Step Prompt Workflows for Complex Tasks](https://understandingdata.com/posts/multi-step-prompt-workflows/): Single prompts for complex tasks lead to incomplete or incorrect implementations. Break complex tasks into explicit multi-step workflows with verification at each step to reduce cognitive load, isolat - [Model Switching Strategy: Optimizing Cost vs Quality Tradeoffs](https://understandingdata.com/posts/model-switching-strategy/): Match AI model capabilities to task complexity for optimal cost-quality balance. Use Haiku for simple tasks (file reads, grep, simple edits), Sonnet for standard development (API endpoints, refactorin - [Model and Provider Agnostic Approach: Staying Ahead in the Rapidly Evolving AI Landscape](https://understandingdata.com/posts/model-provider-agnostic-approach/): Locking into a single AI model or provider prevents leveraging new capabilities as the ecosystem evolves rapidly. This proven approach advocates building provider abstractions, regularly evaluating ne - [Meta-Ticket Refinement: Using Claude to Transform Vague Tickets for AI Execution](https://understandingdata.com/posts/meta-ticket-refinement/): When working with AI coding agents like Claude Code, ticket quality directly determines execution quality. - [Meta-Questions for Recursive Agents](https://understandingdata.com/posts/meta-questions-for-recursive-agents/): There are questions you can ask agents at any point: “Is the work done? Are there bugs? What tests am I missing?” These spawn recursive improvement loops. - [MCP Server for Dynamic Project Context: Queryable Knowledge Beyond Static Files](https://understandingdata.com/posts/mcp-server-project-context/): Static CLAUDE.md files limit context retrieval to pre-written documentation. Build a custom MCP server to provide queryable project knowledge—dependency graphs, pattern examples, test coverage, recent - [Making Invalid States Impossible: Sculpting the LLM Computation Graph](https://understandingdata.com/posts/making-states-illegal-computation-graph/): **Prevent what you don’t want, not just validate what you do want.** - [Two Modes of LLM Usage: Exploring vs Implementing](https://understandingdata.com/posts/llm-usage-modes-explore-vs-implement/): When working with AI coding agents, developers often jump straight to code generation: - [The LLM as Recursive Function Generator: A Mental Model for AI Coding Agents](https://understandingdata.com/posts/llm-recursive-function-model/): AI coding agents function as recursive function generators following the pattern: AI_Agent = fn(Verify(Generate(Retrieve()))). They retrieve context, generate code probabilistically, verify through qu - [LLM Code Review in CI Pipeline: Automated Quality Gates](https://understandingdata.com/posts/llm-code-review-ci/): “Several issues: - [Learning Loops: Encoding Problems into Prevention](https://understandingdata.com/posts/learning-loops-encoding-problems-into-prevention/): Every problem is a lesson. Encode it into your harness so it never happens again. - [Layered Prompts: Onion Architecture for AI Coding Agents](https://understandingdata.com/posts/layered-prompts-architecture/): Structure prompts using onion architecture with four layers: Core (universal rules), Domain (project patterns), Application (feature context), and Task (specific request). This approach enables indepe - [Invariants in Programming and LLM Code Generation](https://understandingdata.com/posts/invariants-programming-llm-generation/): Invariants are properties that must always hold true during program execution. They form the foundation of quality gates in LLM code generation by constraining the valid state space. Type systems, tes - [Integration Testing Patterns](https://understandingdata.com/posts/integration-testing-patterns/): For LLM-assisted development, integration tests provide higher signal-to-noise ratio than unit tests. A single integration test verifies an entire feature’s correctness across all layers, while dozens - [Institutional Memory with Learning Files: Teaching LLMs Past Decisions](https://understandingdata.com/posts/institutional-memory-learning-files/): LLMs forget past decisions and repeatedly propose rejected ideas. Learning files (*-learning.json) track decisions, rationales, and context so LLMs can learn from past choices. When integrated with au - [Information Theory for Coding Agents: Mathematical Foundations of LLM Code Generation](https://understandingdata.com/posts/information-theory-coding-agents/): Information theory provides the mathematical foundation for understanding how coding agents process and generate code. Key concepts include entropy (measuring uncertainty), information content (value - [Context Engineering](https://understandingdata.com/posts/index/): The art of structuring information for LLM agents to maximize both token efficiency and comprehension. - [Incremental Development Pattern: 90% Error Rate Reduction Through Small Steps](https://understandingdata.com/posts/incremental-development-pattern/): “Build a complete authentication system with JWT tokens, password hashing, login/logout endpoints, password reset flow with email verification, session refresh tokens, rate limiting on auth... - [Human-First DX Philosophy: What’s Good for Humans is Good for AI](https://understandingdata.com/posts/human-first-dx-philosophy/): If your repository is easier to create, edit, build and test for humans, that translates directly to LLM performance. Clear documentation becomes better AI context. Simple build systems enable reliabl - [Highest Leverage Points: Plans and Validation](https://understandingdata.com/posts/highest-leverage-points-plans-and-validation/): In the age of AI agents, software engineers have maximum leverage at two points: planning and validation. Everything in between is increasingly automated. - [Hierarchical Rule Files with Collocation: Context at the Point of Need](https://understandingdata.com/posts/hierarchical-rule-files-collocation/): Global rules can’t capture domain-specific constraints, forcing developers to mentally context-switch and LLMs to hallucinate patterns. The hierarchical rule files pattern collocates documentation and - [Hierarchical Context Patterns](https://understandingdata.com/posts/hierarchical-context-patterns/): Place CLAUDE.md files at every directory level to provide LLMs with hyper-localized, contextual knowledge. This hierarchical approach ensures AI agents load only relevant patterns and constraints for - [Git Worktrees for Parallel Development: 3x Throughput with AI Agents](https://understandingdata.com/posts/git-worktrees-parallel-dev/): Git worktrees enable running multiple AI coding sessions in parallel by creating separate working directories from the same repository. This eliminates context-switching costs, enables risk-free exper - [Functional Programming Increases LLM Signal](https://understandingdata.com/posts/functional-programming-signal/): Errors as values, typed composition, and explicit effects give LLMs complete signal on what code actually does. - [Automated Flaky Test Detection: Diagnose Intermittent Failures Systematically](https://understandingdata.com/posts/flaky-test-diagnosis-script/): Flaky tests that pass sometimes and fail other times waste developer time and erode trust in CI/CD pipelines. This article presents a proven solution: automated diagnosis scripts that run tests multip - [Five-Point Error Diagnostic Framework: Systematic LLM Error Reduction](https://understandingdata.com/posts/five-point-error-diagnostic-framework/): LLM errors often seem random and unpredictable, making it difficult to diagnose and prevent recurring issues. This framework provides a systematic approach by categorizing every LLM problem into one o - [Few-Shot Prompting with Project Examples: Teaching Patterns Through Concrete Code](https://understandingdata.com/posts/few-shot-prompting-project-examples/): LLMs learn project-specific patterns best through 2-3 concrete examples from your actual codebase rather than abstract explanations. By showing real implementations before requesting new code, the LLM - [Evaluation Driven Development: Self-Healing Test Loops with AI Vision](https://understandingdata.com/posts/evaluation-driven-development/): Instead of asserting “does it return the right value?”, ask “does a human judge this as correct?” - [Error Messages as Training Data: Building Persistent Memory for LLMs](https://understandingdata.com/posts/error-messages-as-training/): LLMs lack persistent memory and repeat the same mistakes across sessions. Maintain an ERRORS.md file documenting common errors with symptoms, bad patterns, fixes, prevention strategies, and frequency - [Entropy in Code Generation: Understanding Uncertainty in LLM Outputs](https://understandingdata.com/posts/entropy-in-code-generation/): Entropy measures uncertainty in LLM code generation outputs. High entropy means many equally-likely outputs (unpredictable), while low entropy means few likely outputs (predictable). Quality gates, ty - [Early Linting Prevents Technical Debt Ratcheting](https://understandingdata.com/posts/early-linting-prevents-ratcheting/): Introducing linting late in a project forces you to either fix hundreds of accumulated violations or use ratcheting mechanisms that allow staged technical debt. Enable linting from day one and integra - [DDD Bounded Contexts: Clear Domain Boundaries for LLM Code Generation](https://understandingdata.com/posts/ddd-bounded-contexts-for-llms/): When LLMs work with monolithic codebases, they face a **cognitive overload problem**. Consider a typical monolithic application: - [Custom ESLint Rules for AI Determinism: Teaching LLMs Through Structured Errors](https://understandingdata.com/posts/custom-eslint-rules-determinism/): “Error messages are teaching prompts. Custom ESLint rules transform linting from error detection to architectural teaching.” - [Cursor Agent Workflows](https://understandingdata.com/posts/cursor-agent-workflows/): Practical patterns for maximizing coding agent effectiveness in day-to-day development. - [Context Rot Prevention: Auto-Compacting for Long AI Sessions](https://understandingdata.com/posts/context-rot-auto-compacting/): When you work with AI coding agents over extended sessions, context accumulates like sediment: - [Context-Efficient Backpressure](https://understandingdata.com/posts/context-efficient-backpressure/): Swallow all test/build/lint output and replace it with a single `✓` if the stage passes. If `exitCode != 0`, dump the stashed output. - [Context Debugging Framework: Systematic Problem-Solving for AI Code Generation](https://understandingdata.com/posts/context-debugging-framework/): When AI doesn’t produce desired output, follow a systematic debugging hierarchy: Context (60% of issues) → Prompting (25%) → Model Power (10%) → Manual (5%). This proven protocol maximizes fix probabi - [Constraint-First Development](https://understandingdata.com/posts/constraint-first-development/): Define constraints first. Let the system alter code until constraints are satisfied. This is how the best engineers will work. - [Declarative Constraints Over Imperative Instructions](https://understandingdata.com/posts/constraint-based-prompting/): Imperative prompts that specify step-by-step instructions are fragile and verbose. Declarative prompts that declare constraints and desired state let the LLM determine the implementation path, resulti - [Compounding Effects of Quality Gates: From Linear Gains to Exponential Quality](https://understandingdata.com/posts/compounding-effects-quality-gates/): Quality gates (types, tests, linters, CI/CD, CLAUDE.md) appear linearly beneficial individually, but exponentially improve code quality when stacked together. Each gate reduces entropy for the next ga - [Closed-Loop Telemetry-Driven Optimization](https://understandingdata.com/posts/closed-loop-telemetry-driven-optimization/): Turn observability from passive monitoring into an active feedback controller for code quality. This is control theory applied to software development. - [Clean Slate Recovery: Escaping Bad LLM Trajectories](https://understandingdata.com/posts/clean-slate-trajectory-recovery/): When an LLM gets stuck repeating failed approaches, context rot has set in. Clean slate recovery solves this by starting a fresh session with explicit constraints about what didn’t work and why. This - [Claude Code Hooks as Automated Quality Gates](https://understandingdata.com/posts/claude-code-hooks-quality-gates/): Manual verification of AI-generated code is time-consuming and error-prone. Claude Code hooks automatically run linters, type checkers, and tests on every tool call, catching errors instantly. With ke - [Chain-of-Thought Prompting for Complex Logic](https://understandingdata.com/posts/chain-of-thought-prompting/): LLMs often jump to implementation without reasoning through complex requirements, missing edge cases and error handling. Chain-of-thought prompting explicitly asks the LLM to think step-by-step before - [Building the Harness Around Claude Code](https://understandingdata.com/posts/building-the-harness/): Claude Code is a harness around an LLM. Your job is to build a harness around Claude Code. - [Building the Factory: Meta-Infrastructure for Exponential Productivity](https://understandingdata.com/posts/building-the-factory/): Most developers use AI to build features. Advanced developers use AI to build infrastructure that builds features. Elite developers build infrastructure that builds infrastructure. This article explor - [Boundary Enforcement with Layered Architecture: Preventing LLM Spaghetti Code](https://understandingdata.com/posts/boundary-enforcement-layered-architecture/): LLMs create spaghetti architectures by violating layer boundaries—routes accessing databases directly, domain logic mixed with infrastructure. ESLint boundary rules automatically enforce layered archi - [AST-Based Code Search: Precision Over False Positives](https://understandingdata.com/posts/ast-grep-for-precision/): **Scenario:** You need to find all places where `fetchUserData()` is called in your codebase. - [AI Workflow Notifications: Visibility for Silent Automation](https://understandingdata.com/posts/ai-workflow-notifications/): GitHub Actions and automated workflows run silently, leaving teams blind to successes and failures. Send rich Discord/Slack embeds with status, stats, and links to create visibility, enable debugging, - [Cost Protection with Multi-Layer Timeout Limits](https://understandingdata.com/posts/ai-cost-protection-timeouts/): Runaway LLM workflows can rack up hundreds of dollars in unexpected API costs. Implement multi-layer timeout protection at job level (GitHub Actions timeout-minutes), request level (max_tokens), and i - [Agentic Tool Detection: Preventing LLM Tool-Use Failures](https://understandingdata.com/posts/agentic-tool-detection/): rg “function authenticate” - [Agent Swarm Patterns for Thoroughness](https://understandingdata.com/posts/agent-swarm-patterns-for-thoroughness/): When you really want to make sure, run multiple sub-agents multiple times. Aggregate, de-dupe, then plan. - [The Agent Reliability Chasm](https://understandingdata.com/posts/agent-reliability-chasm/): Building a demo agent is easy. Building a reliable agent is exponentially harder. - [Agent-Native Architecture](https://understandingdata.com/posts/agent-native-architecture/): Designing software where AI agents are first-class citizens, not bolted-on features. - [Agent Capabilities: Tools and Eyes](https://understandingdata.com/posts/agent-capabilities-tools-and-eyes/): Agents with more tools don’t just DO more—they DO better. Give them hands AND eyes. - [ADRs for Agent Context](https://understandingdata.com/posts/adrs-for-agent-context/): Architecture Decision Records document WHY decisions were made. This context is invaluable for agents navigating your codebase. - [Ad-hoc Flows to Deterministic Scripts](https://understandingdata.com/posts/ad-hoc-flows-to-deterministic-scripts/): If you’re running the same agent flow regularly, convert it to a script. Deterministic beats probabilistic for known workflows. - [Actor-Critic Adversarial Coding: Multi-Pass Quality Through AI Self-Review](https://understandingdata.com/posts/actor-critic-adversarial-coding/): Single-pass LLM code generation misses edge cases, security vulnerabilities, and architectural flaws. The actor-critic pattern uses two agents—one to generate code (actor), another to critique it (cri - [24/7 Development Strategy: AI Agents Working While You Sleep](https://understandingdata.com/posts/24-7-development-strategy/): Traditional development is limited to human working hours (40 hours/week). Configure AI agents to autonomously consume tickets during nights and weekends, multiplying development time by 102%—from 40 - [12 Factor Agents](https://understandingdata.com/posts/12-factor-agents/): Principles for building production-ready LLM-powered software. - [Why I’m Betting on AI Agents as the Future of Work](https://understandingdata.com/posts/why-im-betting-on-ai-agents-as-the-future-of-work/): I’ve been spending a lot of time with Devin lately, and I’ve got to tell you – we’re thinking about AI agents all wrong. - [Supercharging Devin + Supabase: Fixing Docker Performance on EC2 with overlay2](https://understandingdata.com/posts/improving-docker-storage-performance-on-ec2-a-solution-for-devin-and-supabase-users/): The Problem While setting up Devin (a coding assistant) with Supabase CLI on an EC2 instance, I encountered significant performance issues. - [Soft Skills for Programmers: Why They Matter and How to Develop Them](https://understandingdata.com/posts/soft-skills-for-programmers-why-they-matter-and-how-to-develop-them/): Overview You need a variety of soft skills in addition to technical skills to succeed in the technology sector. - [What Are Webhooks? And How Do They Relate to Data Engineering?](https://understandingdata.com/posts/what-are-webhooks-and-how-do-they-relate-to-data-engineering/): Webhooks are a simple and powerful method for receiving real-time notifications when certain events occur. - [What is an API? And How Do They Relate to Data Engineering?](https://understandingdata.com/posts/what-is-an-api-and-how-do-they-relate-to-data-engineering/): An API, or Application Programming Interface, is a set of rules and protocols that allow different software systems to communicate with each other. - [How To Convert A .csv File Into A .json File](https://understandingdata.com/posts/how-to-convert-a-csv-file-into-a-json-file/): Depending upon your situation, you might need to change file formats to correctly upload your data into another platform. - [How To Extract The Text From Multiple Webpages In Python](https://understandingdata.com/posts/how-to-extract-the-text-from-multiple-webpages-in-python/): When performing content analysis at scale, you’ll need to automatically extract text content from web pages. - [How To Easily Find All Of The Sitemap.xml Files In Python](https://understandingdata.com/posts/how-to-easily-find-all-of-the-sitemap-xml-files-in-python/): To effectively analyse websites, knowing how to download all of the sitemap.xml files for a particular website is an incredibly useful skill. - [Asynchronous Web Scraping In Python](https://understandingdata.com/posts/asynchronous-web-scraping-in-python/): Learning Outcomes The following python installations are for a Jupyter Notebook, however if you are using a command line then simply exclude the ! - [Web Scraping With BeautifulSoup](https://understandingdata.com/posts/web-scraping-with-beautifulsoup/): Learning Outcomes The following installations are for a Jupyter Notebook, however if you are using a command line then simply exclude the ! - [How To Install Screaming Frog In The Cloud – Remote Desktop Version](https://understandingdata.com/posts/how-to-install-screaming-frog-in-the-cloud-remote-desktop-version/): Learning Outcomes As websites and web applications grow larger, often crawling it to investigate technical SEO issues can be too much for your local computer to handle. - [The Comprehensive Guide To Automating Screaming Frog](https://understandingdata.com/posts/the-comprehensive-guide-to-automating-screaming-frog/): Learning Outcomes Screaming Frog (SF) is a fantastic desktop crawler that’s available for Windows, Mac and Linux. - [How To Convert Your Images Into Next Generation Formats (.WebP) In Python](https://understandingdata.com/posts/how-to-convert-your-images-into-next-generation-formats-webp-in-python/): Learning Outcomes With the rise of recommended speed changes from Google including Web Vitals, its crucial that your website or web application is able to serve better image formats. - [How To Easily Resize & Compress Your Images In Python](https://understandingdata.com/posts/how-to-easily-resize-compress-your-images-in-python/): As different social media platforms often require different image and width formats, resizing images automatically with python can definitely save you time. - [How To Compress Multiple Images In Python](https://understandingdata.com/posts/how-to-compress-multiple-images-in-python/): Learning Outcomes As approximately 65% of today’s online content is made of image, decreasing the time your users have to wait to view content is an essential part of your website or application. - [How To Download Multiple Images In Python](https://understandingdata.com/posts/how-to-download-multiple-images-in-python/): Learning Outcomes Automatically downloading images from a number of your HTML pages is an essential skill, in this guide you’ll be learning 4 methods on how to download images using Python! - [The Comprehensive Guide To Google Sheets With Python](https://understandingdata.com/posts/the-comprehensive-guide-to-google-sheets-with-python/): Are you looking to level up your google sheets game with automation? - [How To Easily Setup A Google Cloud Project With APIs](https://understandingdata.com/posts/how-to-easily-setup-a-google-cloud-project-with-apis/): Learning Outcomes This will be a short guide on how you can get started as quickly as possible using Google Cloud Platform with some of Google’s APIs. - [How To Easily Delete Multiple Files And Folders In Python](https://understandingdata.com/posts/how-to-easily-delete-multiple-files-and-folders-in-python/): Learning Outcomes So in the last episode we learned how to combine multiple .csv files within Python. - [How To Combine Multiple CSV Files In Python](https://understandingdata.com/posts/how-to-combine-multiple-csv-files-in-python/): As this course is being progressively released, whenever a new article and video is released, after initially git cloning the repository. - [De-duplicating Keywords with Python, Pandas And Fuzzy Wuzzy](https://understandingdata.com/posts/de-duplicating-keywords-with-python-pandas-and-fuzzy-wuzzy/): Hey everyone, welcome to the first episode, covering a python for SEO course. - [How to export data from a postgres container inside of Docker](https://understandingdata.com/posts/how-to-export-data-from-a-postgres-container-inside-of-docker/): If you are running a postgres database inside of Docker, it can be a powerful tool for quickly and easily transferring data. - [Top 10 Books on Agile Software Development](https://understandingdata.com/posts/top-10-books-on-agile-software-development/): Agile software development was first based on the Agile Manifesto, which is some two decades old now. - [How To Successfully Lead A Training Bootcamp/Course (in-person or online)](https://understandingdata.com/posts/how-to-lead-a-teaching-course/): A bootcamp or training course can be a great way to learn new skills or improve existing ones. - [Ultimate Source of Datasets for Machine Learning Projects](https://understandingdata.com/posts/ultimate-source-of-datasets-for-machine-learning-projects/): Data science and machine learning require data – that much is obvious! - [How to Switch From Data Science to Data Engineering](https://understandingdata.com/posts/how-to-switch-from-data-science-to-data-engineering/): Data science and data engineering are neighbouring disciplines within a freelance, startup, agency or SME setting. - [Protecting Data Science Projects From Ransomware ](https://understandingdata.com/posts/protecting-data-science-projects-from-ransomware/): Ransomware is an extremely common cybercrime threat that targets both individuals, small teams, larger teams and enterprise-level businesses. - [What Are the Benefits of Machine Learning in Software Testing Processes?](https://understandingdata.com/posts/what-are-the-benefits-of-machine-learning-in-software-testing-processes/): Software applications must be usable on various devices, platforms, and browsers. - [Apache Airflow vs Prefect](https://understandingdata.com/posts/apache-airflow-vs-prefect/): In modern data engineering and MLOps, workflow management platforms are becoming increasingly important for orchestrating distributed data pipelines. - [Best 10 Python Books for Beginners & Advanced Programmers](https://understandingdata.com/posts/best-10-python-books-for-beginners-advanced-programmers/): For experienced programmers out there, Python needs little introduction. - [Apache Kafka 101: What are Kafka Streams + 5 Uses](https://understandingdata.com/posts/what-are-kafka-streams/): Apache Kafka is a fantastic tool for transferring data across apps. - [Top 10 Data Visualisation Books](https://understandingdata.com/posts/top-10-data-visualisation-books/): Humans are primarily visual creatures. - [Top 10 Software Architecture Books](https://understandingdata.com/posts/top-10-software-architecture-books/): Software architecture occupies a unique niche between software development and engineering and client or business-facing roles. - [11 Feature Engineering Tactics For Your Machine Learning Project](https://understandingdata.com/posts/11-feature-engineering-tactics-for-an-ml-project/): In machine learning, it’s often a case of garbage in, garbage out. - [How To Clean And Process Data](https://understandingdata.com/posts/how-to-clean-and-process-data/): Obtaining data is one thing, but ensuring that data is clean is another challenge altogether. - [The Data Engineer’s Roadmap](https://understandingdata.com/posts/the-data-engineers-roadmap/): There is a huge demand for data engineers right now, and it still doesn’t appear as if there are enough prospective data engineers to meet industry needs. - [Main Differences Between Data Engineers vs Software Engineers](https://understandingdata.com/posts/main-differences-between-data-engineers-vs-software-engineers/): Data is probably the world’s most valuable resource – the World Economic Forum states that the world’s data was worth some $3 trillion back in 2017. - [Overfitting and Underfitting in Machine Learning](https://understandingdata.com/posts/overfitting-and-underfitting-in-machine-learning/): Overfitting and underfitting are two foundational concepts in supervised machine learning (ML). - [Introduction to the Bias-Variance Trade-Off in Machine Learning](https://understandingdata.com/posts/introduction-to-the-bias-variance-trade-off-in-machine-learning/): The bias-variance trade-off in machine learning (ML) is a foundational concept that affects a supervised model’s predictive performance and accuracy. - [How to Scrape Twitter Data](https://understandingdata.com/posts/how-to-scrape-twitter-data/): The simple, structured format of Twitter and its various posting functions makes it relatively easy to navigate and scrape. - [Websites to Find Data for Data Science Projects](https://understandingdata.com/posts/websites-to-find-data-for-data-science-projects/): Data science projects of all varieties require data. - [What is Data Validation and When Do You Do It?](https://understandingdata.com/posts/what-is-data-validation-and-where-do-you-validate-data/): Data validation is relatively simple, but it’s a tricky problem to solve at scale. - [Salary of Data Engineers: Complete Guide](https://understandingdata.com/posts/salary-of-data-engineers-complete-guide/): Data engineers are fundamental to the entire concept and discipline that is data. - [The Future of the Modern Data Stack](https://understandingdata.com/posts/the-future-of-the-modern-data-stack/): The term ‘modern data stack’ has become entrenched in tech circles as businesses and organisations around the world race to become data-driven. - [What is Event Data, And How Do You Use It?](https://understandingdata.com/posts/what-is-event-data-and-how-do-you-use-it/): Event data describes the use of products, websites, software or practically anything else where a user interacts with trackable, measurable or otherwise analysable moving parts. - [How Do Entities Link To Event Data?](https://understandingdata.com/posts/how-do-entities-link-to-event-data/): Event data, also called interaction data or behavioural data, is essential to discover how users and customers interact with digital products and services. - [Event Data: How Do You Decide Which Events To Track?](https://understandingdata.com/posts/how-do-you-decide-which-events-to-track/): In this context, events document digital processes and can be tracked to uncover insights into how something (in this case, human users) interact with a digital product, device, or content. - [How Do You Create a Data Tracking Plan?](https://understandingdata.com/posts/how-do-you-create-a-data-tracking-plan/): Data tracking plans are the blueprint of successful data strategies. - [Data Types And Their Importance In Analytics](https://understandingdata.com/posts/what-are-data-types-and-why-are-they-important/): The data type is a means of classifying the type of value that a variable possesses. - [What is a Modern Data Stack for Businesses?](https://understandingdata.com/posts/modern-data-stack-for-businesses/): Data intercepts and interacts with multiple business processes and tasks, which is why the phrase ‘data stack’ is useful. - [What Are Customer Data Platforms?](https://understandingdata.com/posts/what-are-customer-data-platforms/): The rise of data needs little introduction – the numbers speak for themselves: Data from Statista shows that investment in Big Data is 10x higher in 2020 than in 2011. - [What is Customer Data?](https://understandingdata.com/posts/what-is-customer-data/): Customer data is composed primarily of data relating to customers, their behaviour and their relationship with businesses both on and offline. - [Top 10 Data Engineering Books](https://understandingdata.com/posts/top-10-data-engineering-books/): Data engineers are the unsung heroes of the data world. - [What is Data Democratisation? ](https://understandingdata.com/posts/what-is-data-democratisation/): Data democratisation is a modern concept that applies primarily to businesses and organisations. - [What is Behavioural Data And How Do You Use It?](https://understandingdata.com/posts/why-is-collecting-behavioral-data-so-important/): Behavioural data lies at the intersection of all customer touchpoints and channels. - [Top 15 Data Analysis and Data Science Books](https://understandingdata.com/posts/top-15-data-analysis-and-data-science-books/): The fields of data science, analysis and its neighbouring disciplines have risen to prominence in the last two decades or so. - [How Can You Become Anonymous Online?](https://understandingdata.com/posts/how-can-you-become-anonymous-on-the-internet/): The internet wasn’t built to be censored, it revolves around the paradigms of free speech, freedom of movement and free access to information. - [Advantages and Disadvantages of Python](https://understandingdata.com/posts/advantages-and-disadvantages-of-python/): Python is an object-orientated, multi-paradigm, high-level programming language that has rocketed to popularity since its inception in 1989 and release in 1991. - [How To Use Whoer to Cover Your Tracks When Using Proxies?](https://understandingdata.com/posts/how-to-use-whoer-to-cover-your-tracks-when-using-proxies/): Online anonymity is a growing problem in the 21st century. - [What is a Digital Fingerprint?](https://understandingdata.com/posts/what-is-a-digital-fingerprint/): Digital fingerprinting is a computational process used to identify and track internet users and devices online. - [What are the Benefits of Learning a Programming Language?](https://understandingdata.com/posts/what-are-the-benefits-of-learning-a-programming-language/): Programming languages are more diverse, complex and sophisticated than ever. - [AI in Manufacturing and Industry](https://understandingdata.com/posts/ai-in-manufacturing-and-industry/): AI has now been around for over half a century but it’s only just starting to roll out on a commercial scale. - [Top Data Science Problems and How to Avoid Them](https://understandingdata.com/posts/top-data-science-problems-and-how-to-avoid-them/): Data science is taking a central role in modern business and when allied to effective well-planned business strategies, it has enormous potential to augment practically any business. - [Machine learning in the Healthcare Industry](https://understandingdata.com/posts/machine-learning-in-the-healthcare-industry/): Machine learning (ML) is an integral part of artificial intelligence that has revolutionised a huge array of sectors and industries across the world, including the medical and healthcare industries. - [What Is Data Modelling In Software Engineering?](https://understandingdata.com/posts/what-is-data-modelling/): So you’re looking to improve how you work with data, store data or enhance data quality? - [Are Coding Bootcamps Worth It?](https://understandingdata.com/posts/are-coding-bootcamps-worth-it/): Deciding to go onto a coding bootcamp is a big decision and it’s essential that you weigh up all of your different possibilities. - [Data Science Vs Data Engineering](https://understandingdata.com/posts/data-science-vs-data-engineering/): There are many collaborators in the wonderful universe of data. - [What Is A Data Engineer?](https://understandingdata.com/posts/what-is-a-data-engineer/): Data engineers are just one member of a suite of specialised individuals that are trained to work with data. - [What Is A Data Pipeline?](https://understandingdata.com/posts/what-is-a-data-pipeline/): Data science is a burgeoning field with remarkably modern origins. - [How To Hire The Right AI Consulting Firm](https://understandingdata.com/posts/how-to-hire-the-right-ai-consulting-firm/): Whether you’re working on a specific project or require ongoing advice in the field of AI and machine learning, it’s important to choose the right consulting firm to suit your requirements. - [How is Machine Learning Used In Marketing?](https://understandingdata.com/posts/machine-learning-use-cases-marketing/): Marketing lies at the intersection of many business processes such as advertising, sales, ROI, customer acquisition and customer churn. - [Best Practices On How To Scrape The Web Without Getting Blocked](https://understandingdata.com/posts/how-to-avoid-being-blocked-web-scraping/): While web scraping small websites rarely leads to scraping issues, when you start web crawling on larger websites or even Google, you’ll often find your requests can be ignored or even blocked. - [Machine Learning For The Finance Industry](https://understandingdata.com/posts/machine-learning-in-the-finance-industry/): Machine learning (ML) is a component of artificial intelligence (AI) that allows computer algorithms to make accurate predictions when exposed to new data. - [The Complete List Of Python Assert Statements](https://understandingdata.com/posts/list-of-python-assert-statements-for-unit-tests/): Why Learn Assert Statements For Unit Tests? - [What Is Data Wrangling?](https://understandingdata.com/posts/what-is-data-wrangling/): Data wrangling is the act of and mapping raw data into another format suitable for another purpose. - [The Pros and Cons of Artificial Intelligence](https://understandingdata.com/posts/artificial-intelligence-advantages-and-disadvantages/): Artificial Intelligence – or AI – has grown from a fringe idea in 1950s computer science to a household term used across popular culture, science and technology. - [The Complete Guide to Residential, Backconnect and Rotating Proxies for Web Scraping](https://understandingdata.com/posts/web-scraping-proxy-providers/): Thanks to the ever-evolving world of proxy servers, web scraping is easier than ever. - [Is Web Scraping Legal?](https://understandingdata.com/posts/is-web-scraping-legal/): This question is asked a lot given the growth of web scraping and many recent legal cases related to this topic, it definitely comes as no surprise. - [The Essential Guide To Web Scraping Tools](https://understandingdata.com/posts/web-scraping-tools/): Web scraping is an effective and scalable method for automatically collecting data from websites and webpages. - [Instagram # Community Detection With Machine Learning](https://understandingdata.com/posts/instagram-community-detection-with-machine-learning/): Finding social communities can help you to easily identity sub-topical trends within a niche. - [What is Web Scraping?](https://understandingdata.com/posts/what-is-web-scraping/): Web scraping is the process of collecting information and data from websites and webpages. - [How To Install Google Chrome, Selenium & Chromedriver For AWS EC2 Instances](https://understandingdata.com/posts/install-google-chrome-selenium-ec2-aws/): If you’re looking to use selenium and headless browsers on amazon web services (AWS) its essential that you install the relevant versions of selenium, ChromeDriver and Google Chrome to your EC2 instance. - [How To Easily Install Anaconda Distribution on Mac Os X (Video + Article)](https://understandingdata.com/posts/how-to-install-anaconda-mac-os/): This tutorial will help you to install Anaconda for Mac OS. - [Web Scraping NinjaOutreach At Scale](https://understandingdata.com/posts/web-scraping-ninjaoutreach-at-scale/): Disclaimer: Please note that all code and methodologies within this post are to be used at your own risk. - [The Advantages & Disadvantages of Web Scraping Data](https://understandingdata.com/posts/the-advantages-disadvantages-of-web-scraping-data/): “Knowledge is power. - [Effective Local SEO Client Prospecting With 2180 GMB Categories & Python 🐍](https://understandingdata.com/posts/prospecting-local-seo-clients-python/): This guide aims to provide you with a detailed explanation on how to find good local SEO clients using data, python, API’s and automation. - [Redefining Traffic Opportunity Analysis With Ahrefs & Python](https://understandingdata.com/posts/ahrefs-traffic-opportunity-analysis-python/): Keyword research is a fundamental process that helps search engine marketers to understand where the market opportunity is and what searchers care about. - [How To Prospect For Companies Without Google My Business Using Python](https://understandingdata.com/posts/prospect-google-my-business-clients-with-python/): Google My Business is a local SEO directory and a vital marketing channel for local businesses as it helps them to acquire customers within their local search market. - [Click Through Rate Optimisation With Machine Learning & Google Search Console Data](https://understandingdata.com/posts/ctr-optimisation-with-machine-learning/): Whether you’re an SEO company like RaleighDigital, a publisher or an e-commerce store optimising your click through rate with machine learning can help you to get more clicks than your competitors! - [Predicting Article Shares With Machine Learning In The Digital Marketing Industry](https://understandingdata.com/posts/predicting-article-shares-with-machine-learning/): Content creation is a time consuming and valuable activity. --- Written by James Phoenix. Full URL list: https://understandingdata.com/sitemap.xml