In the early web era, the defining abstraction was the API. You exposed an interface, consumed data, composed services. The quality of your software depended on the quality of the interfaces you designed.
We are now in a different era. The defining abstraction is the context window.
The interface has moved
When you call an LLM, you do not invoke a function with parameters. You construct a context — a careful arrangement of text that encodes everything the model needs to reason well — and receive a completion in return. The quality of that completion depends entirely on the quality of your context.
This is not a trivial shift. APIs are typed. They are versioned. They are documented with schemas. They fail loudly when you pass the wrong thing.
Context windows are none of these things. They are permissive. They accept anything. They fail silently, producing outputs that are confidently wrong, subtly off, or just different from what you expected — without telling you why.
Context is where design happens
Most teams treat the context window as a delivery mechanism: write your logic, then figure out how to stuff it into a prompt. This is backwards.
The context window should be the primary design surface. Before you write a single line of code, you should be asking: what does this model need to know to do its job? What is the minimum viable context? What ordering of information produces the best reasoning?
These are the same questions you asked when designing an API — what should the interface expose? — just applied to a different medium.
The discipline is the same
Good API design requires you to think carefully about your caller. What do they need? What should they not need to know? Where should complexity be absorbed?
Good context engineering requires the same thinking, applied to an LLM. The model is your caller. You are designing the interface it will use to reason. Every token you include is a decision. Every token you exclude is also a decision.
The engineers who will be most effective in the next decade are the ones who treat context construction with the same rigor they once brought to API design. Not as an afterthought. Not as a prompt template they tweak until it works.
As a first-class engineering discipline.