Plain-language and technical definitions for AI engineering concepts, plus memorable analogies to help explain complex ideas.
A method for AI agents to learn from their own mistakes and improve over time without human retraining
Technical: Agentic Context Engineering - framework for self-improving agents through execution feedback using Generator/Reflector/Curator pattern, updating strategies without retraining weights
The insight that ADHD brains and AI systems face the same fundamental challenge: limited working memory requiring external infrastructure
Technical: Structural isomorphism between ADHD working memory constraints and AI context window limitations, where both systems require external memory architecture to function effectively
A checkpoint ensuring system design is sound before coding begins
Technical: Quality gate requiring decision log, Mermaid diagrams, and constraint definitions, verifying all requirements are addressable within constraints
A large piece of content stored separately and referenced by pointer rather than included directly
Technical: Large object stored by reference rather than tokenized into context, enabling efficient handling of code files, documents, and other sizeable content
The limited mental bandwidth an AI has to weigh relationships between pieces of information
Technical: The finite capacity of a transformer model to weigh relationships between tokens, where every token included consumes attention due to n² pairwise computations
The tendency for AI summaries to become shorter and more generic, losing the specific details that matter
Technical: Tendency of LLM summarization to produce increasingly short, generic output that loses domain-specific information with each compression iteration
A discrete piece of context that can be scored for usefulness in the ACE framework
Technical: Discrete context item in ACE framework containing ID, content, and helpful/harmful counts for evolutionary selection of useful context
A DevOps-inspired process for managing how AI agents think and work at each development stage
Technical: DevOps-inspired process infrastructure that guides Claude Code thinking at each development stage, enforces quality gates, and provides visual oversight through dashboards
External systems that support and extend your brain's natural capabilities
Technical: External memory and process systems that compensate for working memory limitations by persisting context, automating recall, and reducing cognitive load
Reducing context size while preserving essential information
Technical: Process of reducing context token count while maintaining essential information through summarization, extraction, or reference substitution
A freshly prepared summary of only the relevant information for right now, instead of dumping everything into the conversation
Technical: Working context computed fresh for each LLM call from richer underlying state, projecting what's relevant NOW rather than accumulating a growing transcript
When infrastructure investments multiply their value over time rather than just adding up
Technical: Non-linear value accumulation where infrastructure investments yield increasing returns through reuse and composition, versus linear returns from direct effort
A visual approach to knowledge that treats ideas like stars - scattered but forming meaningful patterns when viewed together
Technical: Non-linear knowledge organization methodology treating thoughts as distributed nodes that form coherent constellations through semantic relationships, optimized for parallel association patterns
Explicit rules that enable autonomous AI operation within defined constraints
Technical: Governance approach using explicit, enforceable rules that enable autonomous agent operation while maintaining boundaries, analogous to constitutional law
When repeatedly summarizing information causes important details to gradually disappear
Technical: Degradation of accumulated knowledge through iterative summarization, where each compression pass loses domain-specific details leading to generic, unhelpful summaries
The practice of managing what information an AI sees when making decisions
Technical: The discipline of curating and maintaining the optimal set of tokens during LLM inference, treating context as a compiled view over richer stateful systems rather than an accumulating transcript
When AI performance gets worse as conversations get longer, even though the AI could technically handle more
Technical: Performance degradation as token count increases within supported context limits, manifesting as recency bias where recent information dominates regardless of actual importance
The amount of text an AI can consider at once when thinking - like working memory for AI
Technical: The maximum number of tokens an LLM can process in a single inference call, analogous to working memory capacity constraints
The part of a self-improving AI system that turns lessons into permanent improvements
Technical: ACE component that synthesizes Reflector lessons into delta entries that update the agent's context for future runs
A structured record of project goals, current state, and how things work that gives AI agents the context they need
Technical: A persistent, structured representation of work including explicit goals, current state (passing/failing/tried), and scaffolding (how to run/test/extend), distinct from simple vector database retrieval
Using outside systems to remember things your brain or AI can't hold onto
Technical: Strategy of offloading memory persistence to external systems when working memory capacity is insufficient, applicable to both ADHD cognition and AI context management
A system where AI stores information in four tiers: what it's thinking about now, recent conversation, searchable knowledge, and large files
Technical: Tiered memory model: Working Context (compiled view per call) → Sessions (structured event log) → Memory (searchable knowledge) → Artifacts (large objects by reference)
The part of a self-improving AI system that produces solutions and reasoning
Technical: ACE component that produces reasoning trajectories attempting to solve tasks, which are then evaluated by the Reflector
An enhanced version of RAG that also understands relationships between pieces of information
Technical: Graph-augmented retrieval combining semantic vector search with knowledge graph traversal for relationship-aware information retrieval
The supporting infrastructure that surrounds and enables an AI agent - its memory, tools, and context management
Technical: The infrastructure layer surrounding an agent that handles memory persistence, tool integration, context compilation, and behavioral constraints - distinct from the agent's reasoning capabilities
Keeping humans involved in AI decision-making at key checkpoints
Technical: Governance pattern requiring human review and approval at defined checkpoints, balancing autonomous AI capability with oversight and course correction
Searching that combines keyword matching with meaning-based matching for better results
Technical: Search strategy combining lexical/keyword matching (BM25/FTS) with semantic vector similarity for improved recall and precision
Building foundational systems before features, because good foundations create compounding returns
Technical: Development principle prioritizing tooling, pipelines, and scaffolding that create compounding capability returns over ad-hoc solutions with linear returns
A two-part AI system where one agent sets up the project scaffold and another agent repeatedly works within it
Technical: Two-agent architecture where an Initializer Agent populates domain memory scaffold once, then Worker Agent repeatedly reads memory, performs work, and updates state
A network of connected ideas where relationships between concepts are as important as the concepts themselves
Technical: Graph data structure representing entities as nodes and relationships as edges, enabling traversal-based discovery and multi-hop reasoning across connected knowledge
Coordinating different knowledge sources and retrieval methods to serve the right information at the right time
Technical: Architecture layer managing multiple knowledge sources, retrieval strategies, and delivery mechanisms to provide optimal context for specific tasks
A speed optimization that lets AI reuse previous calculations when the conversation start stays the same
Technical: Key-value cache enabling reuse of transformer attention computations when context prefix remains identical across calls, significantly reducing latency
Running AI and storing data on your own computer instead of relying on cloud services
Technical: Architecture principle prioritizing local compute and storage for AI inference, enabling privacy, offline operation, and reduced latency while maintaining optional cloud sync
A standard protocol that lets AI tools talk to each other and share capabilities
Technical: Model Context Protocol - standardized interface for AI models to interact with external tools, data sources, and services through a unified tool-calling pattern
Coordinating multiple specialized AI agents to work together on complex tasks
Technical: Architecture pattern where specialized agents with bounded contexts collaborate through shared memory and coordination protocols to accomplish tasks exceeding single-agent capability
The ability to understand what's happening inside a system by looking at its outputs
Technical: Property enabling system state inference from external outputs through structured logging, tracing, and metrics collection
How different parts work together to get things done
Technical: The coordination layer managing workflow execution, routing decisions, and multi-agent composition patterns
Keeping the beginning of AI conversations identical to take advantage of caching
Technical: Property where context beginning stays identical across calls, enabling KV-cache reuse and reducing computation costs
Learning in the open by sharing the messy process, not just polished results
Technical: Knowledge sharing philosophy prioritizing process visibility over polished outputs, enabling others to learn from iterations and mistakes
A checkpoint where work must meet specific standards before moving to the next stage
Technical: Explicit artifact-based checkpoint producing reviewable output that the next stage consumes, with defined quality thresholds that must be met
A technique that lets AI look up relevant information before answering, like consulting notes during an open-book test
Technical: Retrieval-Augmented Generation - architecture combining vector search over document embeddings with LLM generation, enabling models to access external knowledge without retraining
The part of a self-improving AI system that analyzes what worked and what didn't
Technical: ACE component that critiques Generator traces to extract lessons about what helped or hurt task completion
Summarizing information while preserving specific required fields rather than generic compression
Technical: Compaction strategy guided by explicit preservation requirements, ensuring domain-specific information is retained during summarization
Searching by meaning rather than exact keywords, finding conceptually related content
Technical: Information retrieval using vector similarity to find semantically related content regardless of lexical overlap
A structured record of an entire AI interaction that can be replayed or analyzed
Technical: Structured event log capturing full trajectory within an interaction, enabling replay, debugging, and decision provenance tracking
A checkpoint ensuring the problem is fully understood before architecture work begins
Technical: Quality gate requiring requirements document with acceptance criteria in EARS format (WHEN/IF/THEN), ensuring problem is fully understood and success metrics defined
Writing detailed specifications before code, letting the spec guide and validate the implementation
Technical: Development methodology where formal specifications with acceptance criteria drive implementation, enabling automated validation and reducing specification drift
A specialized AI helper that handles one specific task with its own focused context
Technical: Agent with isolated context handling a focused subtask, enabling the parent agent to offload complex work while keeping its own context clean
How much cleanup work is accumulating compared to new feature work
Technical: Metric tracking ratio of technical debt to productive work, with target threshold of ≤5% as deployment gate blocker
Bridging the gap between understanding something and actually building it
Technical: Development philosophy emphasizing that understanding without implementation is incomplete, and that production constraints reveal true system behavior
A conceptual throughline connecting related ideas across different content
Technical: Canonical conceptual category organizing content by theme rather than format, enabling deep-link navigation across artifact types
How well the completed work matches what was originally requested
Technical: Metric measuring percentage of acceptance criteria that are correctly verified by tests, with target threshold of ≥98%
A checkpoint confirming the implementation actually satisfies the original requirements
Technical: Quality gate requiring verification matrix mapping requirements to tests to results, with ≥98% validation accuracy threshold
Converting text into numerical coordinates so AI can measure how similar different pieces of content are
Technical: Dense numerical representations of text in high-dimensional space where semantic similarity corresponds to geometric proximity
The minimal set of information an AI actually needs to make its current decision
Technical: The compiled view sent to the model for a single invocation, kept as small as possible while containing instructions, identity, selected history, memory hits, and relevant tool outputs
Memorable phrases that map complex AI concepts to familiar mental models. Use these when explaining ideas to others or solidifying your own understanding.
"A multi-dimensional thinker living in a linear world"
ADHD brains process information in parallel, associative patterns that don't fit linear workflows. The brain isn't broken - it's optimized for a different environment.
"Acceleration through constraints"
Both ADHD brains and AI models perform better with clear constraints. The tighter the boundaries, the more creative the output within those bounds.
"Build the thing that builds the things"
Instead of building products directly, build the factory that produces products. Infrastructure creates exponential returns; direct effort creates linear returns.
"Context is a compiled view, not a chat transcript"
Like a compiler produces optimized output from source code, context should be computed fresh for each call from richer underlying state, not simply appended.
"Context management crisis - where did I put that information?"
Information exists but retrieving it requires the right trigger. Both systems have storage but struggle with retrieval without external scaffolding.
"Context windows are working memory"
Both AI context windows and ADHD working memory have limited capacity, requiring external systems to compensate. Neither can hold everything, so both need infrastructure to remember.
"Cross-session amnesia - agents forget everything between conversations"
Without memory infrastructure, every AI conversation starts fresh with no grounded sense of where things stand - exactly like ADHD without external systems.
"Documentation as survival, not just good practice"
When working memory can't hold implicit connections, everything must be externalized, made explicit, and searchable. What isn't documented effectively doesn't exist.
"Every token is attention spent - you're paying with focus, not just space"
Adding more information isn't free. Each token competes for limited attention. More context can mean worse performance as signal drowns in noise.
"Four-layer memory like computer architecture: cache, RAM, disk, cold storage"
Working Context is L1 cache (fast, small). Sessions are RAM (current state). Memory is disk (searchable). Artifacts are cold storage (reference only).
"Infrastructure creates increasing returns; effort creates diminishing returns"
Each hour spent on infrastructure makes future hours more productive. Each hour spent on direct work just adds one hour of output. The curves diverge over time.
"Infrastructure thinking is not compensation for limitation - it's optimization for capability"
External memory isn't admitting weakness; it's recognizing that offloading storage enables more processing power for creative work.
"Initializer sets up the scaffold, Worker builds within it"
One agent creates the project structure and domain memory once. Another agent repeatedly reads that memory, works, and updates state - like setting up a workspace vs. working in it.
"Just-in-time context feeding - information surfaced at the exact moment of use"
Don't preload everything; fetch relevant information exactly when the task needs it. Like looking up a reference when writing, not reading the whole library first.
"Pods for coherent output - breaking complex work into specialized focus areas"
Just as ADHD brains need to break work into focused modes, AI agents need specialization because neither can maintain global context while doing deep local work.
"Quality gates as constitutional governance - explicit rules enabling autonomy"
Like constitutional law enables freedom within bounds, explicit quality gates let AI work autonomously while maintaining control at key checkpoints.
"RAG treats the knowledge graph as external memory for an AI system"
Like using notes during an open-book test, RAG lets AI consult a knowledge base before answering rather than relying solely on what it memorized during training.
"Reduce, offload, isolate - the three strategies for context management"
Reduce: compress what you include. Offload: store large content externally. Isolate: give subtasks their own context. Three complementary strategies.
"Start with what you have - migration is incremental, not revolutionary"
You don't need to migrate everything immediately. Start capturing new knowledge properly. Over time, the new system becomes authoritative through use.
"The magic is in the memory, not the model"
Production agent success comes from memory infrastructure, not model intelligence. The same model with better memory outperforms a better model with poor memory.
"The structure is the same because the problem is the same"
ADHD external memory systems and AI agent harnesses solve the same fundamental problem: limited working memory requiring persistent external scaffolding.
"Thoughts scattered like stars, forming constellations when viewed together"
Individual ideas seem random in isolation but reveal meaningful patterns when mapped as a network. The value emerges from connections, not individual nodes.
"Tool results stored in full, context carries compact references"
Store complete tool outputs in filesystem. Keep just file paths in context window. Agent can fetch full results when needed but doesn't pay token cost unless relevant.
"Within-session degradation - getting worse the longer you run"
Agents repeat themselves, forget constraints, and retry failed approaches as sessions lengthen - performance degrades around the 20-30 minute mark without proper architecture.
"Working memory limits create a choice: struggle with the constraint or build around it"
You can fight limited working memory through sheer effort, or accept it and build systems that work with it. The second path scales.
"Your knowledge should compound. Does yours?"
Most knowledge work produces linear returns - each document standalone. Compounding knowledge connects everything, making each new piece more valuable.