Engineering & Agentic Glossary

Status: Active Last Updated: 2026-08-31 Category: Reference Tags: glossary, vocabulary, engineering, agentic

AI Models & Platforms

Qwen 3.6 35B A3B: An advanced large language model variant.
Pi: Personal Intelligence, a conversational AI model.
Skills: Specific capabilities or tools that an AI agent can invoke to perform tasks.

Web & Frontend Features

Lightbox: A UI component that displays images or content by filling the screen and dimming out the rest of the web page.
Image upload (stripping EXIF): The process of removing metadata (like location, camera details, timestamps) from images during upload for privacy and security.

Software Development & Testing

Gherkin: A plain-text, domain-specific language used by Behavior-Driven Development (BDD) tools like Cucumber and Behave. It structures automated test scenarios using Given, When, Then, And, and But steps.

Agentic & Engineering Vocabulary Map

Below is a large, practical vocabulary map of terms engineers and programmers commonly use to communicate when building software. Grouped the way engineers naturally think about systems: concept → design → build → runtime → operations.

This is essentially the shared language of software engineering.

1. Fundamental Code Constructs

Core building blocks of code.

Function
Method
Procedure
Callback
Lambda
Closure
Coroutine
Generator
Iterator
Expression
Statement
Block
Parameter
Argument
Return value
Variable
Constant
Literal
Reference
Pointer
Type
Interface
Struct
Class
Object
Instance
Module
Package
Namespace

2. Control Flow

How execution moves through a program.

Conditional
Branch
Loop
Iteration
Recursion
Early return
Guard clause
Switch / match
Try / catch
Exception
Error handling
Fallback
Retry logic
Circuit breaker

3. Architecture Concepts

How systems are structured.

Architecture
Pattern
Paradigm
Design pattern
Component
Layer
Service
Microservice
Monolith
Module
Subsystem
Boundary
Domain
Context
Dependency
Abstraction
Interface
Implementation
Adapter
Facade
Proxy
Middleware

4. Data Structures

Ways data is organized.

Array
List
Linked list
Stack
Queue
Deque
Map
Hashmap
Dictionary
Set
Tree
Graph
Heap
Trie
Index
Table
Schema
Record
Tuple

5. State & Data Flow

How information moves through systems.

State
Mutation
Immutable
Snapshot
Event
Message
Payload
Stream
Pipeline
Channel
Queue
Buffer
Batch
Transaction
Commit
Rollback
Cache
Persistence

6. Asynchronous Programming

Very common in modern systems.

Async
Await
Future
Promise
Event loop
Task
Worker
Thread
Process
Concurrency
Parallelism
Scheduler
Job
Queue
Dispatcher

7. API & Integration Terms

How systems talk to each other.

API
Endpoint
Route
Handler
Request
Response
Header
Body
Query parameter
Path parameter
Status code
Webhook
RPC
gRPC
REST
GraphQL

8. UI / Frontend Terms

Common web or app terms.

Component
Widget
View
Template
Layout
Style
Theme
State
Props
Event handler
Hook
Directive
Binding
Render
Hydration
Virtual DOM

9. Engineering Workflow Terms

Used when discussing how something gets built.

Wireframe
Prototype
Mock
Stub
Scaffold
Skeleton
Boilerplate
Template
Specification
Requirements
Feature
Ticket
Issue
Task
Epic
Milestone

10. Testing Terms

Ensuring software works.

Unit test
Integration test
End-to-end test
Acceptance test
Regression test
Smoke test
Snapshot test
Test harness
Fixture
Mock
Stub
Assertion
Coverage

11. DevOps & Infrastructure

How software runs.

Deployment
Environment
Configuration
Provisioning
Container
Image
Orchestration
Cluster
Node
Instance
Load balancer
Reverse proxy
Gateway

12. Observability

How systems are monitored.

Log
Trace
Metric
Telemetry
Alert
Health check
Heartbeat
Dashboard
Profiling
Instrumentation

13. Security Terms

Essential system language.

Authentication
Authorization
Token
Session
Credential
Encryption
Hash
Signature
Key pair
Certificate
Secret
Vault

14. Data & Storage

Persistence and databases.

Database
Table
Row
Column
Index
Query
Transaction
Migration
Replication
Sharding
Backup
Restore

15. Performance Concepts

Used when optimizing systems.

Latency
Throughput
Bottleneck
Scalability
Load
Rate limit
Backpressure
Throttling
Caching
Prefetching

16. Code Quality Terms

Used in code review discussions.

Refactor
Rewrite
Optimize
Simplify
Abstract
Modularize
Encapsulate
Decouple
DRY
KISS
SOLID

17. Git & Collaboration

Version control language.

Repository
Commit
Branch
Merge
Rebase
Pull request
Diff
Patch
Tag
Release

18. Documentation Language

Used when explaining systems.

Specification
Design doc
RFC
ADR (Architecture Decision Record)
README
Changelog
API docs
Schema docs

19. AI / Agentic Engineering Terms

These are becoming very common now.

Prompt
Context
System prompt
Tool call
Function call
Agent
Workflow
Memory
Retrieval
Embedding
Vector store
RAG
Planning
Reflection
Evaluation

20. System Lifecycle Terms

Describing the entire build process.

Idea
Vision
Roadmap
Requirements
Specification
Design
Wireframe
Prototype
Scaffold
Implement
Test
Deploy
Monitor
Iterate
Maintain

Common Engineering Sentence Patterns

Engineers often communicate in short structured phrases like:

"Let's scaffold the service."
"We'll stub the dependency."
"Mock the API."
"Wire the components together."
"Add a handler for that route."
"Refactor the module."
"Ship the MVP."
"Add instrumentation."
"Deploy to staging."
"Run the E2E tests."

The 12 Most Universally Used Engineering Words

If you distilled the language down to the most common terms used daily:

Function
Component
Module
Service
API
State
Event
Handler
Hook
Pipeline
Workflow
Interface

Engineering Language Map

From Idea → Architecture → Code → Runtime → Operations

IDEA / PRODUCT
│
├─ Vision
│  ├─ Mission
│  ├─ Problem Statement
│  └─ Value Proposition
│
├─ Planning
│  ├─ Roadmap
│  ├─ Requirements
│  ├─ User Stories
│  ├─ PRD (Product Requirements Document)
│  └─ RFC
│
└─ Design
   ├─ Architecture
   │  ├─ Pattern
   │  ├─ Paradigm
   │  ├─ Monolith
   │  ├─ Microservices
   │  └─ Event Driven
   │
   ├─ System Components
   │  ├─ Service
   │  ├─ Module
   │  ├─ Library
   │  ├─ Package
   │  └─ Subsystem
   │
   └─ Interface Contracts
      ├─ API
      ├─ Endpoint
      ├─ Schema
      └─ Protocol

Implementation Layer (Actual Code)

IMPLEMENTATION
│
├─ Structure
│  ├─ Project
│  ├─ Repository
│  ├─ Directory
│  └─ Module
│
├─ Code Constructs
│  ├─ Function
│  ├─ Method
│  ├─ Class
│  ├─ Object
│  ├─ Interface
│  └─ Struct
│
├─ Logic
│  ├─ Conditional
│  ├─ Loop
│  ├─ Recursion
│  └─ Error Handling
│
├─ Composition
│  ├─ Dependency
│  ├─ Injection
│  ├─ Adapter
│  ├─ Wrapper
│  └─ Facade
│
└─ Utilities
   ├─ Helper
   ├─ Middleware
   ├─ Hook
   └─ Callback

Data & State Layer

DATA
│
├─ Structures
│  ├─ Array
│  ├─ List
│  ├─ Map
│  ├─ Set
│  ├─ Tree
│  └─ Graph
│
├─ Persistence
│  ├─ Database
│  ├─ Table
│  ├─ Row
│  ├─ Column
│  └─ Index
│
└─ State Management
   ├─ State
   ├─ Event
   ├─ Message
   ├─ Payload
   └─ Transaction

Runtime System

RUNTIME
│
├─ Execution
│  ├─ Process
│  ├─ Thread
│  ├─ Worker
│  └─ Task
│
├─ Concurrency
│  ├─ Async
│  ├─ Await
│  ├─ Future
│  └─ Promise
│
├─ Communication
│  ├─ Request
│  ├─ Response
│  ├─ Event
│  └─ Queue
│
└─ Pipelines
   ├─ Stream
   ├─ Channel
   ├─ Buffer
   └─ Dispatcher

Integration Layer

INTEGRATION
│
├─ APIs
│  ├─ REST
│  ├─ GraphQL
│  ├─ gRPC
│  └─ RPC
│
├─ Routing
│  ├─ Route
│  ├─ Endpoint
│  └─ Handler
│
└─ Messaging
   ├─ Pub/Sub
   ├─ Queue
   └─ Event Bus

Testing Layer

TESTING
│
├─ Unit Tests
├─ Integration Tests
├─ End-to-End Tests
├─ Acceptance Tests
│
├─ Test Utilities
│  ├─ Mock
│  ├─ Stub
│  ├─ Fixture
│  └─ Harness
│
└─ Validation
   ├─ Assertion
   └─ Coverage

Deployment Layer

DEPLOYMENT
│
├─ Build
│  ├─ Compile
│  ├─ Bundle
│  └─ Package
│
├─ Infrastructure
│  ├─ Container
│  ├─ Image
│  ├─ Node
│  └─ Cluster
│
└─ Environments
   ├─ Development
   ├─ Staging
   └─ Production

Operations Layer

OPERATIONS
│
├─ Monitoring
│  ├─ Logs
│  ├─ Metrics
│  ├─ Traces
│  └─ Telemetry
│
├─ Reliability
│  ├─ Health Check
│  ├─ Heartbeat
│  ├─ Retry
│  └─ Circuit Breaker
│
└─ Performance
   ├─ Latency
   ├─ Throughput
   ├─ Bottleneck
   └─ Scaling

AI / Agentic Layer (Modern Systems)

AGENTIC SYSTEMS
│
├─ Agent
│
├─ Memory
│  ├─ Short-term
│  ├─ Long-term
│  └─ Vector Store
│
├─ Reasoning
│  ├─ Planning
│  ├─ Reflection
│  └─ Evaluation
│
├─ Tool Use
│  ├─ Function Call
│  ├─ Tool Call
│  └─ Plugin
│
└─ Context
   ├─ Prompt
   ├─ System Prompt
   └─ Retrieval

The Universal Software Loop

Everything engineers build ultimately runs in this loop:

INPUT → PARSE → PROCESS → STATE CHANGE → OUTPUT

Or in modern systems:

Event → Handler → Function / Logic → State Update → Response

The Master Engineering Loop

The entire lifecycle of engineering systems:

IDEA → SPEC → ARCHITECTURE → IMPLEMENTATION → TEST → DEPLOY → OBSERVE → ITERATE

The 8 Core Concepts That Connect Everything

Nearly every engineering discussion revolves around these:

DATA
STATE
FUNCTION
EVENT
INTERFACE
SERVICE
PIPELINE
WORKFLOW

Programming Language of Engineers

The informal shorthand developers use to communicate quickly. These phrases compress complex engineering actions into a few words.

Building & Creating

Scaffold it: Generate the basic project structure and boilerplate.
Spin it up: Start a service, environment, container, or server.
Bootstrap the project: Initialize the repository and dependencies.
Wire it up: Connect components so they interact properly.
Hook it in: Attach functionality to an existing system.
Plumb it through: Pass data through multiple layers.
Stand up a service: Deploy and make a backend service available.

Temporary or Incomplete Code

Stub it out: Create a placeholder function with no real logic.
Mock it: Replace a dependency with a simulated version for testing.
Fake it: Simulate behavior without full implementation.
Hardcode it for now: Temporarily bypass dynamic logic.
Throw in a quick hack: Implement a temporary solution.

Code Organization

Break it out: Move logic into a separate function/module.
Extract that: Refactor code into a reusable component.
Wrap it: Add an abstraction layer around something.
Abstract that away: Hide complexity behind an interface.
Encapsulate it: Restrict internal implementation details.
Modularize it: Split a large system into modules.

Fixing Problems

Patch it: Apply a quick fix.
Hotfix it: Deploy a fix directly to production.
Work around it: Bypass a problem without fixing root cause.
Guard against that: Add validation or checks.
Handle that edge case: Account for unusual inputs.
Mitigate it: Reduce impact without full fix.

Optimization

Refactor it: Improve code structure without changing behavior.
Optimize it: Improve performance.
Simplify it: Reduce complexity.
Clean it up: Improve readability or structure.
De-duplicate it: Remove repeated logic.

Integration

Expose an endpoint: Make functionality available via API.
Add a handler: Implement code that processes an event or request.
Register the route: Add a URL path to an API router.
Subscribe to the event: Listen for system events.
Emit an event: Trigger an event notification.

Data & State

Persist it: Save data to storage.
Cache it: Store temporary data for faster access.
Invalidate the cache: Remove stale cached data.
Hydrate the state: Populate state with stored data.
Serialize it: Convert object into transferable format.
Normalize the data: Convert data into consistent structure.

Deployment

Ship it: Release the code.
Push it: Send commits to remote repository.
Deploy it: Release software to environment.
Roll it out: Gradually release a feature.
Rollback: Revert deployment.

Testing

Add coverage: Increase test coverage.
Write a quick test: Add minimal validation.
Smoke test it: Quick check to ensure system runs.
Run E2E: Execute end-to-end tests.
Reproduce the bug: Confirm steps causing failure.

Infrastructure

Scale it up: Increase resources.
Spin down the instance: Shut down compute resources.
Load balance it: Distribute traffic across servers.
Containerize it: Package application into container.

AI / Agentic Engineering

Ground the model: Provide context to reduce hallucination.
Call the tool: Trigger a function/tool from the LLM.
Inject context: Add external information to prompt.
Retrieve documents: Use RAG to fetch knowledge.
Chain the agents: Connect multiple agents into workflow.
Let the agent plan: Allow reasoning step before action.

Ultra-Common Engineering Commands

"Let's scaffold it."
"Just stub that for now."
"Wire the API into the service."
"Break that logic out."
"Wrap the SDK."
"Add a handler."
"Emit an event."
"Persist the state."
"Cache the response."
"Ship it."

The 12 Most Powerful Engineer Verbs

If you know these verbs, you understand most engineering conversations:

build
wire
hook
wrap
stub
mock
refactor
deploy
persist
cache
emit
scale

The 7 Core Nouns of Software Systems

Everything engineers build usually revolves around:

function
component
service
interface
event
state
pipeline

Real Engineer Conversation Example

Engineer Talk

"Let's scaffold the service, stub the API client, wire the handler into the router, persist the state in Redis, and ship a basic endpoint."

Actual Meaning

Generate project structure
Create placeholder API client
Connect request handler to router
Store state in Redis
Deploy minimal version