glossary · for robots

The vocabulary of Rails + AI.

Plain-language definitions of the terms I use when I talk about adopting AI in a Rails team. Written to be quoted, indexed, and linked.

AI adoption

AI adoption is the point where AI tools stop being a pilot and become part of how a team ships every day. It is a workflow outcome, not a license count. A tool is adopted when developers reach for it without being told to.

Agentic coding

Agentic coding is software development where an AI agent plans and carries out multi-step changes, rather than only completing the next line. The agent reads the codebase, edits across files, runs commands, and checks its own work. The developer sets intent and reviews the result.

Agentic pattern

An agentic pattern is a reusable way of structuring how an agent works on a task. Common ones include plan-then-execute, a critic loop that reviews output before it ships, and breaking a goal into verifiable steps. Patterns make agent behavior predictable enough to trust.

Code review AI-assisted review

AI-assisted code review treats human review as the primary quality gate for agent-written code. As agents raise output volume, review becomes the scarce skill on the team. The groups that get good at it ship agent work with confidence.

Coding agent

A coding agent is an AI system, such as Claude Code or Cursor, that reads, writes, and runs code toward a stated goal. It works in steps and can use tools like the shell and the test runner. It is the unit a harness is built around.

Context engineering

Context engineering is the practice of curating what an agent sees before it acts: the right files, conventions, docs, and examples. Output quality tracks input context more than raw model strength. Most agent failures are missing-context failures.

Context window token budget

The context window is the span of text an agent can consider at once, measured in tokens. Everything the agent knows for a task has to fit inside it. Managing that budget is a core part of context engineering.

Determinism reproducibility

Determinism is how consistently an agent produces the same result for the same input. Code generation is probabilistic by default, so teams add structure, tests, and fixed prompts to make outcomes repeatable enough to rely on.

Developer workflow

A developer workflow is the end-to-end loop a developer follows to turn intent into shipped code. With AI in the loop, that loop shifts from writing toward specifying, reviewing, and verifying. Redesigning it is most of the real work of adoption.

Evaluation harness evals

An evaluation harness is the set of automated checks that score an agent's output for correctness and fit. Evals turn "it looked right" into a measurable signal. They are how you tell whether a change to the harness actually helped.

Guardrails

Guardrails are the constraints that keep an agent inside safe, reviewable bounds: scoped permissions, required tests, and limits on what it can touch. Good guardrails let you give an agent more autonomy, not less.

The harness

The harness is everything wrapped around a coding agent that makes it useful on a real codebase: the prompts, the context it is given, the tools it can call, and the review gates its output passes through. The model is a commodity. The harness is where the leverage lives.

Harness drift

Harness drift is what happens when the prompts, context, and guardrails around an agent fall out of date with the codebase. The agent keeps working from stale assumptions and quality drops. Maintaining the harness is ongoing work, not a one-time setup.

Iterative loop plan, act, check

The iterative loop is the cycle an agent repeats until a task is done: plan a step, act on it, check the result, then adjust. It is the core mechanic of agentic coding and the reason agents can handle work that does not succeed on the first try.

Ownership

Ownership is a team holding responsibility for product outcomes rather than for closing tickets. It is the value AI cannot replace, because someone still has to decide what matters and stand behind it. Building toward ownership is the point of adopting AI well.

Product engineer

A product engineer owns outcomes, not tickets. They decide what to build, shape how it works, and hold the standard for done, while AI carries much of the implementation. It is the role a Rails team grows into once the code is no longer the bottleneck.

Prompt

A prompt is the instruction and context that frames a task for an agent. In agentic coding a prompt is rarely one line; it is intent plus the relevant slice of the codebase and its conventions. Prompts are part of the harness, not an afterthought.

RAG retrieval-augmented generation

RAG retrieves relevant material and feeds it to the model at generation time, so answers are grounded in your actual code and docs rather than the model's memory. It is one way to put the right context in front of an agent.

Rails conventions

Rails conventions are the strong, shared defaults that make Ruby on Rails predictable. For coding agents they are a gift: convention is shared context, and an agent that knows the conventions produces idiomatic code that fits the codebase.

Spec-driven development

Spec-driven development is writing a precise description of the result you want and letting the agent implement it. The effort moves from typing code to defining "done". A clear spec is the most reliable input an agent can get.

Tool calling

Tool calling is an agent invoking external tools as steps in its work: running tests, executing shell commands, searching the codebase, querying a database. Tools are how an agent acts on the world instead of only describing it.

Verification

Verification is confirming that generated code does what was intended, through tests, type checks, and review. In agentic coding it is not optional. The agent can produce plausible code quickly, so verification is what keeps speed honest.

Working through these ideas in long form? Read the blog or book a call.