---
title: "The AI Coding Agent Dictionary: Colloquial Prompts vs Standard Tech Terms"
description: "A battle-tested dictionary translating everyday developer prompts into precision architectural terms for AI coding agents to generate robust code."
pubDate: "2026-09-02"
lang: "en"
slug: "ai-coding-agent-dictionary"
url: "https://hoangyell.com/ai-coding-agent-dictionary/"
author: "HoangYell"
translation_vi: "https://hoangyell.com/vi/ai-coding-agent-dictionary/"
categories: ["AI & Agents"]
tags: ["ai", "prompt-engineering", "architecture", "best-practices", "coding-agents"]
heroImage: "https://raw.githubusercontent.com/HoangGeek/store/refs/heads/main/webp/ai-coding-agent-dictionary.webp"
---
In [Part 1: High-Leverage Coding Terms & Jargon for AI Coding Agents](/coding-jargon-for-ai-agents/), we explored the mathematical mechanics of latent vector steering: AI coding agents do not understand human prompts through philosophical empathy. Instead, they calculate self-attention probability weights across high-dimensional token spaces. High-leverage architectural terms act like cryptographic routing hashes, pulling the model directly into elite subspaces trained on RFC specifications, the Linux Kernel, and battle-tested production systems.
However, during real-world daily sprints, the most frequent friction developers encounter is not typing speed - it is **not knowing what industry-standard terminology corresponds to the mundane bug they are currently fixing**.
You know that your system is suffering from "double-charge clicks", "two people saving over each other's edits", or "boolean flags conflicting and showing a loading spinner alongside an error banner". If you write those exact colloquial complaints to an AI agent, you inevitably get naive, bug-ridden code.
This article is **Part 2: The Master AI Coding Agent Dictionary**. Stripped of all filler prose, it organizes **28 common real-world software engineering challenges** into an actionable lookup matrix: **Colloquial Everyday Prompts vs Standard Tech Jargon**, accompanied by copy-pasteable senior prompt templates for Cursor, Claude Code, GitHub Copilot, and Antigravity.
## TL;DR
### Beginner Map: The 5 Tactical Domains
- **Core Purpose:** Provide an immediate lookup phrasebook mapping 28 common developer challenges (Database, Network, Frontend State, Refactoring, Testing & Security) from casual descriptions to precision architectural terminology.
- **Why It Matters:** Eliminates naive guessing by LLMs, eradicating race conditions, memory bloat, cascading network failures, and impossible UI states.
- **How to Use:** Scan the table matching your current scenario, copy the senior prompt template, adapt your variable names, and dispatch to your coding agent.
```markdy
scene width=1280 height=720
theme: light=doodle dark=nebula
layout auto
user Dev "Developer Prompt"
service Colloquial "Colloquial (Everyday Slang)"
service Precision "Senior Jargon (Precision Terms)"
service Agent "AI Coding Agent"
module Buggy "Fragile Hack (Race Conditions & Leaks)"
module Solid "Enterprise Architecture (Robust & Type-Safe)"
beat vague "The Colloquial Path: High Entropy":
show $nodes stagger=40ms
Dev -> Colloquial "casual everyday request"
Colloquial -> Agent "vague intent without boundaries"
Agent -> Buggy "synthesizes naive code"
glow Colloquial color=#ef4444
glow Buggy color=#ef4444
beat exact "The Precision Path: Zero Ambiguity":
Dev -> Precision "high-leverage architectural term"
Precision -> Agent "triggers production pattern subspace"
Agent -> Solid "generates tested, resilient module"
glow Precision color=#38bdf8
glow Solid color=#10b981
player:
playback:
loop true
controls:
speed true
speeds "0.25"
fullscreen true
gif true
theme true
interaction:
zoom true
pan true
click_to_play true
double_click_to_reset true
keyboard false
chrome:
badge true
progress none
```
***
## Part 1: Foundations & Investigation - The 28-Scenario Master Dictionary
### 1. Data Integrity, Concurrency & Transactions
| Everyday Scenario (Pain Point / Problem) | Standard Technical Jargon (Senior Terms) | Production Prompt Template (Copy-Paste) |
|:---|:---|:---|
| **Double-click charges twice**
User rapidly clicks buy button twice, charging credit card twice. | **Idempotent Consumer, Idempotency-Key, Distributed Lock (Redis SETNX with TTL)** | `"Implement this payment endpoint as an Idempotent Consumer. Extract 'Idempotency-Key' and acquire a Redis lock via SETNX with 60s lease. Store and return cached response on replay."` |
| **Users overwrite each other's edits**
Two editors edit same post, second person's save quietly overwrites first person. | **Optimistic Concurrency Control (OCC), Atomic Compare-And-Swap (CAS), Version Column** | `"Implement OCC on post updates using atomic CAS: 'UPDATE posts SET content = $1, version = version + 1 WHERE id = $2 AND version = $3'. Throw ConcurrencyConflictException if 0 rows affected."` |
| **DB saved but Kafka event dropped**
Order saved in Postgres but publishing to Kafka/Email fails, desyncing system. | **Transactional Outbox Pattern, Change Data Capture (CDC), Guaranteed Delivery** | `"Implement Transactional Outbox Pattern. Insert event into 'outbox' table in the same DB transaction as Order. Create a background poller with retries to publish events to Kafka."` |
| **Soft delete while allowing restore**
Hide records on delete so they can be restored later if deleted by accident. | **Soft Delete via deleted_at timestamp, Partial Unique Indexes** | `"Implement soft deletion using a nullable 'deleted_at' timestamp. Add a Partial Unique Index: 'CREATE UNIQUE INDEX idx_posts_slug ON posts(slug) WHERE deleted_at IS NULL'."` |
| **Huge tables freeze on OFFSET/LIMIT**
Deep pagination queries on 50M rows cause database memory and CPU spikes. | **Keyset Pagination (Seek Method), Composite Covering Index** | `"Replace OFFSET pagination with Keyset Pagination: 'WHERE (created_at, id) < ($1, $2) ORDER BY created_at DESC, id DESC LIMIT 20'. Add composite covering index on (created_at, id)."` |
| **Counting rows is painfully slow**
Running SELECT COUNT(*) on 50M rows takes 10+ seconds on Postgres. | **Counter Cache pattern, PostgreSQL System Rel-tuples Estimation** | `"Replace slow SELECT COUNT(*) with an atomic counter cache in Redis (INCR/DECR) or query PostgreSQL 'pg_class.reltuples' for instantaneous count approximations."` |
| **Deadlocks when updating batch records**
Concurrent transactions updating multiple rows trigger database deadlocks. | **Deterministic Lock Ordering, Row-Level Lock (SELECT FOR UPDATE)** | `"Prevent transaction deadlocks by sorting resource IDs in deterministic ascending order before acquiring row-level locks via 'SELECT ... FOR UPDATE'."` |
***
### 2. Network Resiliency, API Design & Distributed Systems
| Everyday Scenario (Pain Point / Problem) | Standard Technical Jargon (Senior Terms) | Production Prompt Template (Copy-Paste) |
|:---|:---|:---|
| **Stop spam clicks crashing server**
Users or bots hammer login/search endpoints, overwhelming server threads. | **Sliding Window Rate Limiter with Redis Atomic Sorted Sets (ZADD/ZCARD)** | `"Implement distributed sliding window rate limiter middleware in Redis enforcing 10 req/min per IP. Return HTTP 429 Too Many Requests with RFC 'Retry-After' header."` |
| **Slow third-party API freezes our app**
Downstream shipping/payment API latency saturates our server connection pool. | **Circuit Breaker Pattern (Closed/Open/Half-Open), Fallback Degradation** | `"Wrap third-party shipping client with Circuit Breaker. Trip OPEN on 50% failures over 10 calls, timeout at 3s, and return cached fallback estimates without downstream calls."` |
| **Uploading multi-GB files exhausts RAM**
Large video uploads load into server memory, causing Linux OOMKilled crashes. | **Zero-Copy Streaming Pipeline, Pass-through Stream with Backpressure** | `"Pipe incoming multipart HTTP stream directly to S3 via '@aws-sdk/lib-storage' using Node.js stream backpressure. Do not buffer chunks in memory or write to local disk."` |
| **Cannot trace bugs across microservices**
Request traverses 5 microservices, finding errors across logs is impossible. | **Distributed Tracing with W3C TraceContext (traceparent), OpenTelemetry Spans** | `"Add OpenTelemetry tracing middleware. Extract and propagate W3C 'traceparent' headers across outgoing HTTP requests and message queues to correlate logs by Trace ID."` |
| **Frontend calls 10 micro-endpoints**
Mobile app fires 10 small API calls and stitches data locally, degrading performance. | **Backend For Frontend (BFF) Pattern, Request Aggregator / ViewModel** | `"Implement a BFF aggregation endpoint. Parallelize internal microservice requests via Promise.allSettled and transform results into a single client-tailored ViewModel."` |
| **Duplicate webhook events double credit**
Payment provider retries webhooks, crediting user balance multiple times. | **Idempotent Webhook Consumer with Constant-Time HMAC Signature Verification** | `"Verify incoming webhook HMAC-SHA256 signature using 'crypto.timingSafeEqual', then process payload as an Idempotent Consumer backed by unique event ID database locks."` |
***
### 3. State Management & Frontend Architecture
| Everyday Scenario (Pain Point / Problem) | Standard Technical Jargon (Senior Terms) | Production Prompt Template (Copy-Paste) |
|:---|:---|:---|
| **Conflicting boolean state flags**
isLoading and isError flags conflict, showing spinner and error banner simultaneously. | **Finite State Machine (FSM) using TypeScript Discriminated Unions** | `"Model state as an explicit FSM using discriminated unions: 'type State = { status: 'idle' } \| { status: 'loading' } \| { status: 'success'; data: T } \| { status: 'error'; error: Error }'. Eliminate boolean flags."` |
| **Typing in input re-renders whole page**
Typing in a search filter triggers expensive full-dashboard re-renders and input lag. | **Referential Equality, Selector Memoization, Component Colocation** | `"Isolate high-frequency input state into a colocated leaf component. Use Reselect selector memoization with structural sharing to preserve referential equality of table data."` |
| **20,000-row table freezes browser DOM**
Rendering a large list creates 200k DOM nodes, locking the browser UI thread. | **Virtual Windowing, DOM Node Recycling (@tanstack/react-virtual)** | `"Implement virtual list windowing with '@tanstack/react-virtual' for this 20,000-row table. Render only intersecting viewport nodes with an overscan buffer of 5 items."` |
| **Scattered, inconsistent form validation**
Form validation rules scattered across components cause validation discrepancies. | **Schema-First Validation with Runtime Type Inference (Zod / Valibot)** | `"Implement schema-first form validation using Zod. Infer form types directly from the schema ('z.infer') and validate at input blur and submit boundaries."` |
| **Client cache serves stale mutation data**
Editing data and navigating back displays outdated cached values. | **Optimistic UI Mutation Updates with Query Key Cache Invalidation** | `"Implement optimistic UI mutation updates with TanStack Query. Immediately update local cache on click, roll back on server error, and invalidate query key ['profile'] on success."` |
***
### 4. Automated Refactoring & Architectural Decoupling
| Everyday Scenario (Pain Point / Problem) | Standard Technical Jargon (Senior Terms) | Production Prompt Template (Copy-Paste) |
|:---|:---|:---|
| **Rename function across 200 files**
Changing function name across repo via regex risks corrupting comments or strings. | **AST Codemod (Abstract Syntax Tree) via jscodeshift or ast-grep** | `"Write an AST Codemod script with jscodeshift targeting CallExpression nodes where 'callee.name === oldFn'. Rename to 'newFn' and wrap args into an object without touching comments."` |
| **10-level nested if-else pyramid**
Discount calculation function has 10 nested if-else checks, making it unmaintainable. | **Strategy Pattern with Typed Dispatch Map, Result Monad Pipeline** | `"Refactor nested if-else branching using the Strategy Pattern with a typed lookup dispatch map. Chain rule evaluations through a Railway-Oriented Result monad pipeline."` |
| **Decouple database from business logic**
Write code so migrating from MongoDB to PostgreSQL doesn't require rewriting core app. | **Hexagonal Architecture (Ports & Adapters) with Dependency Inversion (DIP)** | `"Structure this module using Hexagonal Architecture. The domain core must contain pure business entities with zero ORM dependencies. Define Repository Ports returning domain models."` |
| **Prop drilling through 8 component tiers**
Passing props down 8 component levels clutters intermediate component signatures. | **Component Composition (passing JSX children) or Context Selector** | `"Eliminate prop drilling by using Component Composition (passing JSX children) or a fine-grained Context selector to subscribe leaf nodes directly to state slices."` |
| **Primitive obsession causes data bugs**
Emails and phone numbers represented as raw strings allow invalid data to leak in. | **Domain Value Objects & TypeScript Branded Types (Parse Don't Validate)** | `"Model EmailAddress and PhoneNumber as immutable Domain Value Objects using TypeScript Branded Types ('type Email = string & { readonly __brand: unique symbol }')."` |
***
### 5. Testing, Security & Reliability
| Everyday Scenario (Pain Point / Problem) | Standard Technical Jargon (Senior Terms) | Production Prompt Template (Copy-Paste) |
|:---|:---|:---|
| **Verify math never has precision bugs**
Test calculation function against floating point drift (0.1 + 0.2 !== 0.3) edge cases. | **Property-Based Testing with fast-check asserting Algebraic Invariants** | `"Write property-based invariant tests using fast-check. Assert that 'applyTax(amount, rate) >= amount' across 2,000 randomly generated arbitrary float inputs."` |
| **Test payment API without real charges**
Test checkout flow without hitting live payment gateway and incurring fees. | **Mock Service Worker (MSW) Network-Level Contract Isolation** | `"Isolate third-party API integration tests using Mock Service Worker (MSW) at the network layer. Intercept HTTP requests and simulate 200, 400, and 504 timeout scenarios."` |
| **Integration tests dirty local dev DB**
Integration test runs pollute developer database with thousands of mock records. | **Ephemeral Test Containers (Testcontainers) with Isolated Lifecycle** | `"Configure integration tests using Testcontainers to spin up a disposable Docker PostgreSQL container for each test suite, running fresh migrations and tearing down on exit."` |
| **Prevent secret tokens leaking to client**
Accidentally importing server secret keys in client bundles exposes credentials to users. | **Environment Variable Boundary Isolation (Public vs Secret Env scoping)** | `"Enforce server-only environment variable boundaries. Restrict private API tokens to server runtime handlers and validate all process.env values with a type-safe env schema."` |
| **String comparison vulnerable to timing**
Comparing authentication tokens with '===' allows attackers to guess secrets via timing. | **Constant-Time String Comparison via crypto.timingSafeEqual** | `"Replace standard '===' string equality checks on authentication tokens with 'crypto.timingSafeEqual' to mitigate side-channel timing attacks."` |
***
## Part 3: Diagnosis - Code Example: Naive Prompt vs Dictionary Term
To observe the impact of the dictionary in real life, consider how an AI agent implements token verification:
```typescript
// ❌ Generated from casual prompt ("make sure token comparison is safe"):
export function naiveVerifyToken(provided: string, expected: string): boolean {
return provided === expected; // Vulnerable to side-channel timing attacks!
}
// ✅ Generated using Dictionary term ("crypto.timingSafeEqual constant-time string comparison"):
import crypto from "node:crypto";
export function constantTimeVerifyToken(provided: string, expected: string): boolean {
const bufA = Buffer.from(provided);
const bufB = Buffer.from(expected);
if (bufA.length !== bufB.length) return false;
return crypto.timingSafeEqual(bufA, bufB); // Constant-time byte verification
}
```
***
## Part 4: Resolution - Daily Workflow Integration
1. **Step 1:** When you encounter a challenging bug or architectural requirement, identify the domain (Database, Network, Frontend State, Refactoring, Security).
2. **Step 2:** Locate the problem row in the table above and copy the precision prompt.
3. **Step 3:** Substitute your specific file paths, types, and module names.
4. **Step 4:** Dispatch to Cursor, Claude Code, or Antigravity and review the clean, non-regressive diff.
***
## Final Take
Prompting an AI coding agent is equivalent to compiling thoughts into software artifacts:
- If your source input is **casual, colloquial slang**, the compiler is forced to guess, and heuristic guessing in software architecture always culminates in technical debt and production outages.
- When your input consists of **precision architectural terminology**, you trigger the most disciplined latent pathways of the neural network - the exact corridors trained on RFC specifications, standard libraries, and battle-tested distributed systems.
Bookmark this dictionary as your daily reference companion. Before drafting a multi-paragraph descriptive prompt, pause for two seconds, identify the standard engineering term in the lookup table, and watch your AI agent's code quality transform immediately.
### Student First Assignment: The Dictionary Stress Test (20 Mins)
1. **Pick one scenario from the table:** Choose a domain you frequently work in (e.g. *Optimistic Concurrency Control* or *FSM with Discriminated Unions*).
2. **Draft a colloquial prompt:** Write a 3-sentence casual description as if explaining the task to a non-technical friend.
3. **Draft the precision prompt:** Copy the corresponding prompt template from the dictionary table above.
4. **Run a side-by-side agent comparison:** Feed both prompts into your AI coding tool and compare:
- Did the naive prompt produce defensive error handling or silent race conditions?
- Did the precision prompt generate unit tests and invariant guards on its first attempt?