---
title: "Context Is the New Code: Why in 2027 You Write Memory for the Machine, Not Functions"
description: "The bottleneck in software development has shifted from writing code to context engineering — creating a profession that doesn't exist in any diploma yet but already shows up on payslips."
author: "Дністер"
published: 2026-08-06T03:03:00.000Z
language: en
url: https://neurodrift.org/en/blog/kontekst-novyi-kod/
---
# Context Is the New Code: Why in 2027 You Write Memory for the Machine, Not Functions

A product manager at a Berlin fintech — call him Lucas — last Tuesday spent two hours without writing a single line of code. He wrote a file. A plain text file, 1,400 words: how their system calculates commission, which three exceptions broke it in 2023, why the `fee_legacy` column does not equal `fee`, and why it cannot be deleted. Then he fed this file to an agent and asked it to add a new pricing tier. The agent did it in four minutes. The year before, the same agent with the same request broke the billing three times — because it didn't know about `fee_legacy`.

For two hours Lucas was not writing a program. He was writing memory.

Here it's worth recalling a number from a completely different field. When OpenAI opened paid API access to GPT-3 in June 2020, the most powerful model — davinci — cost **$0.06 per thousand tokens**, or **$60 per million**; that price held until September 2022, when it was cut by a factor of three ([Neoteric, 2020](https://neoteric.eu/blog/how-much-does-it-cost-to-use-gpt-models-gpt-3-pricing-explained)). Today a token of comparable quality costs single-digit to low tens of cents per million. Epoch AI measured this precisely: the cost of reaching a fixed quality level fell **between 9× and 900× per year** depending on the benchmark, with a **median of ~50× per year**, and specifically for GPT-4-level performance on PhD-level science questions — **~40× per year** ([Epoch AI, 2026](https://epoch.ai/data-insights/llm-inference-price-trends)). Text generation was getting cheaper faster than compute did during the personal computer era.

This scene is not about a manager who "learned to work with AI." It is about the **mechanism** we call by the pretty word "productivity" — which is really **asset repricing**: what gets cheaper by orders of magnitude every year stops being the bottleneck, and the bottleneck quietly moves into the next room. I'll unpack this through three lenses: token economics, transformer attention physics, and the labor market. The razor thesis: **code became cheap to write — and that's precisely why memory became expensive**. What yesterday didn't exist as a craft today already has a salary band.

![A 1970s factory conveyor belt narrows to a single bottleneck gate tended by a worker consulting a handwritten ledger, a small amber-winged moth pinned to his lapel like a brooch.](./images/inline-1-bottleneck.png)

## So-what: when the bottleneck moves, nobody announces the move

For decades the bottleneck in software development was code generation itself. A programmer was someone who translated intentions into syntax, and that translation was slow, expensive, and scarce. Everything in the industry was built around that scarcity: hiring, leveling, whiteboard algorithm interviews, measuring "how many lines did you close this sprint."

Now imagine that translating intentions into syntax got cheaper by orders of magnitude and faster by tens of times. What becomes scarce then?

Intention. More precisely — **a complete, precise, machine-readable description of exactly what you mean**. Because the model now writes code instantly and nearly for free, but writes exactly what it understood from the context. And the context is everything you managed to tell it: architecture, history, edge cases, prohibitions, that cursed `fee_legacy`.

The dark joke is that the industry spent ten years hiring people for the ability to type solutions fast — and now pays for the ability to remember the problem slowly and precisely. We optimized the wrong end of the assembly line.

The parameter economists call the rate of cheapening is unprecedented here. When something gets cheaper by tens of percent every month, people stop looking at it. Nobody debates "how much does it cost to generate a function" anymore — just as nobody counts what it costs to send a megabyte of email. The resource became invisible precisely because it became nearly free. And an invisible resource is never the bottleneck. The bottleneck is always what you still have to look at.

![A craftsman stands at the ordered half of a workbench with exactly three sheets laid out flat, pointing at them with a stylus, while the other half is buried under a chaotic pile of papers; a glass bell jar with an amber-winged moth sits at the bench's edge.](./images/inline-2-workbench.png)

## Mechanism: why memory is not "more tokens"

The intuitive answer sounds like this: fine, if the problem is memory — let's give the model more memory. And the market did exactly that, literally. The context window — the volume of text a model "sees" simultaneously — grew explosively. GPT-3.5 at the end of 2022 held **4,096 tokens**; the first Llama models had only **2,048**, doubled to 4,096 in Llama 2 ([Crazyrouter, 2026](https://crazyrouter.com/en/blog/context-window-token-limits-ai-models-guide-2026)). Today Gemini 3.1 Pro holds up to **2 million tokens** in general availability on Vertex, and Anthropic in March 2026 brought **1 million tokens** to GA for Claude — and notably **removed the former surcharge for long context** ([Claude5 Hub, 2026](https://claude5.com/news/context-window-race-2026-how-200k-to-1m-tokens-transform-ai)). Over three and a half years — a **hundredfold increase**.

And here is where it gets interesting, because more memory does not mean better memory.

In September 2025, Anthropic published a technical piece that put a name to what practitioners had already felt in their hands: **context rot**. The formulation is literal: "as the number of tokens in the context window grows, the model's ability to accurately recall information from that context degrades" ([Anthropic, 29.09.2025](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)).

The cause lies in the physics of the transformer itself. The architecture requires each token to "attend" to every other token: for *n* tokens that means **n² pairwise connections**. The longer the context, the thinner attention is spread. Models were also trained predominantly on shorter sequences, so for long-range dependencies they simply have fewer well-exercised connections ([Anthropic, 29.09.2025](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)). Hence the notorious "lost in the middle" effect: a fact placed at the center of a million-token window is retrieved less reliably than that same fact at the beginning or end ([IBM, context window](https://www.ibm.com/think/topics/context-window)).

In practice this looks equal parts comic and expensive. You load the agent with the entire codebase "so it definitely knows everything," ask a simple question — and it confidently cites a function that was deleted nine months ago, because its mention sat right in that dead center of the window where attention never reached. More memory produced not a better answer but a more confident hallucination. The desk is piled high — and the page you need is somewhere at the bottom.

The conclusion is uncomfortable for anyone hoping to solve everything with sheer volume: **context is not a warehouse, it's a workbench**. Anthropic frames it exactly this way — context should be "treated as a finite resource with diminishing marginal returns" ([Anthropic, 29.09.2025](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)). Burying a desk in paper is not the same as laying out the three right pages in plain sight. Memory for a machine is not "dump everything you know." It is **curation**: what to place, in what order, what to discard.

This is where the named framework around which the whole article is built enters. Anthropic contrasts two disciplines:

- **Prompt engineering** — "techniques for writing and organizing instructions for the model to achieve an optimal result": how to phrase a single query.
- **Context engineering** — "the set of strategies for curating and maintaining the optimal set of tokens during inference, including all the other information that enters beyond the prompts themselves" ([Anthropic, 29.09.2025](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)).

In other words: prompt engineering is about words. Context engineering is about **memory, architecture, and order**. The first is dying as a standalone profession precisely because models have become smart enough. The second is being born for the same reason.

And lest any illusion remain that this is merely an academic game in terminology: Anthropic in that same piece lays out exactly what should sit in the context and in what order — first system instructions, then relevant memory, then tool definitions, and only then the dialogue history. The placement and quality of these blocks influence agent behavior more than any other factor ([Anthropic, 29.09.2025](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)). Note: this is not about "what to write to the model." This is an **engineering schematic** — how to design the information flow so that the finite workbench doesn't get overloaded and the most important things don't fall into that same "lost center." Engineering schematic — therefore engineering profession.

![A 1980s New York recruiter in a loosened tie holds a large printed bar chart showing one bar towering above all others while the applicant leans forward in quiet surprise; on the wall behind the recruiter hangs a framed amber-winged moth specimen between two identical diplomas.](./images/inline-3-salary.png)

## Evidence ladder: from token price to salary band

Let's build the proof on three levels — from a distant hook to a tool the reader can pick up tomorrow.

**First level — economic.** What we've seen: tokens got cheaper by orders of magnitude, context windows grew a hundredfold. Two curves that since 2020 have moved in the same direction — generation is becoming nearly free and nearly boundless. Classic economics: when a resource approaches zero in price, value migrates to the adjacent complementary resource. Hardware got cheaper — software got more expensive. Code generation got cheaper — the description of what to generate got more expensive.

**Second level — structural.** Anthropic writes explicitly that working with language models "is becoming less about finding the right words and phrases in prompts and more about the broader question: what context configuration is most likely to elicit the desired behavior from the model" ([Anthropic, 29.09.2025](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)). This is not marketing — it's an engineering team rewriting its own best practices. There is also a quantitative attempt to measure the effect: in an observational study of 200 documented sessions, incomplete context accompanied **72% of rework cycles**, while structured context assembly reduced the average number of iterations from **3.8 to 2.0** per task and raised the share of first-attempt accepted responses from **32% to 55%** ([Calboreanu, arXiv 2026 — preprint, observational, not RCT](https://arxiv.org/abs/2604.04258)). This is one independent preprint with self-reported numbers, so read them as illustration rather than law: correlation is not causation, since engineers who curate context better may also frame tasks more clearly. But the direction is stubborn and converges with the rest of the picture.

**Third level — the market, the one the reader will feel personally.** The profession "context engineer" does not appear on any university diploma. Yet it already shows up on payslips. In May 2026, ZipRecruiter shows a distinct vacancy category "Context Engineer" with a range of approximately **$84k–$140k** per year, while the broader category "context engineering" (including managerial roles) runs **$116k–$300k**, with a median around **$147k** ([ZipRecruiter — Context Engineer](https://www.ziprecruiter.com/Jobs/Context-Engineer); [ZipRecruiter — Context Engineering](https://www.ziprecruiter.com/Jobs/Context-Engineering)). Major consultancies are already posting positions with this title in the headline — for instance, EY is recruiting a "Context Engineer — Manager — Consulting" ([EY careers](https://careers.ey.com/ey/job/New-York-Context-Engineer-Manager-Consulting-Location-OPEN-NY-10001-8604/1370274733/)). The labor market is always more honest than any dictionary: it names a thing in money before academia names it in syllabi.

| What changed | Then | Now | Shift |
|---|---|---|---|
| Price per 1M tokens (top model) | $60 (davinci, 2020) | single to low tens of cents | drop ~40–50× per year (Epoch AI) |
| Context window | 2–4K tokens (2020–22) | 1–2M tokens (2026) | hundredfold increase |
| Prompt engineer as a job title | hyped title of 2023 | "the model itself writes better prompts" | ↓ |
| Context engineer as a job title | didn't exist | ~$84k–$300k band (05.2026) | ↑ |
| Scarce resource | writing code | remembering the system | has moved |

One table and the whole story is visible: everything multiplying up and down converges on one point. Scarcity moved from the keyboard to the documentation.

## Counter-pressure: what if this is all temporary?

Now let me honestly attack my own thesis — because otherwise this is a sermon, not an argument.

First and strongest counterargument: **what if the next generation of models simply makes context engineering obsolete?** The logic mirrors my own. If models absorbed prompt engineering ("they already understand clunky requests"), why wouldn't they absorb context engineering too — learn to retrieve what they need from a codebase themselves, ask clarifying questions themselves, build their own memory? Even now agents can read a repository and pull relevant files. One more step and the agent will write Lucas's file for itself.

This is a strong argument and I can't afford to soften it. It will partly come true: routine context curation will be automated, just as syntax highlighting was. But there is a wall this logic runs into. **`fee_legacy` cannot be inferred from the code.** The fact that this column must not be deleted because in 2023 someone tied regulatory reporting to it doesn't exist in the repository at all. It lives in the heads of three people, in a message thread, and in the fear of an audit. The model can read everything that is written. It cannot read what is written nowhere — and that is exactly where the most expensive business decisions live.

Second counterargument: **this is just good old technical documentation under a fashionable name.** Senior engineers have always documented architecture. True. But the difference lies in the audience and the cost of failure. Before, documentation was written for humans who already had context and read it diagonally. Now it is written for an executor that literally knows nothing beyond the text it was handed and will carry out what is written literally and immediately. Documentation has ceased to be insurance "for later" — it has become **a working input whose accuracy determines what gets generated in the next four minutes**.

**What would falsify my thesis?** If over 2026–2027 models learned to reliably and autonomously reconstruct unwritten institutional context — to extract from humans what isn't in the code, without the human first having to articulate it — then context engineering would indeed turn out to be a temporary bridge, not a profession. So far we observe the opposite: salary bands are rising, consultancies are opening positions, and Anthropic is rewriting its own documentation. If a year from now vacancies with this title start disappearing rather than multiplying, I was wrong, and I'll honestly record that.

**Why right now, in the window 2018–2026?** Because before 2020 generation was too expensive and too erratic to think about memory — people were fighting for the mere fact of working text. In 2023 the hype focused on prompts: it seemed the secret lay in magic phrasings. Only when in 2024–2026 the token got cheaper by orders of magnitude and the window grew a hundredfold did the real bottleneck become visible — and Anthropic gave it a name precisely when it stopped being a niche pain and became a mass one (September 2025 is not a coincidental date).

## Human mirror: you're already doing this, you're just not getting paid for it

Now about you. Not the abstract "developer of the future" — you, reading this on your work laptop.

You open a chat with the model and type: "make me a report." You get generic garbage, curse, add: "no, about our product, for May, in board format, no fluff." Second attempt — closer. Third — almost there. You just manually, blindly, without a salary band, completed three iterations of context engineering — exactly those 3.8 cycles from the study that structured context compresses to two.

The difference between you and that Berlin Lucas is not intelligence and not the model. You have identical access to the same Claude or GPT. The difference is that Lucas once sat down and wrote memory — a file that now works for him every time. And you start from a blank page every time, paying not in money but in your evenings and three rewrites per task.

The most uncomfortable mirror: the company you work for also starts from a blank page every time. Its most expensive unwritten context — why we decided this, what broke three times, what we're afraid of — still lives in people's heads, in lost message threads, and in the person who "if they leave, nobody will know how this works." Before, this was simply bad practice. Now it is literally money: because the machine that could do the work in four minutes will, without that context, break the billing again.

**A tool you can pick up tonight.** Not theory — three steps. First: pick one system everyone is afraid to touch and write down what's not in the code — why it was built this way, what broke, what can't be deleted and why. Second: arrange it in the order Anthropic recommends — rules and prohibitions first, then facts and history, details last. Third: give this file to an agent on a real small task and count how many iterations it took versus your usual "blank page." If the number dropped — you just did what earns a six-figure salary band in New York.

## Three cases where context beat the model

The Berlin Lucas is a composite figure, but behind it stand entirely concrete documented cases where memory, not the model, won. Worth laying out three, because each reveals the same mechanism from a different angle.

**First — Etsy.** Engineers at the marketplace described how they built responses to platform-specific queries: not "make a smarter model," but assemble the right context around the question — internal product data, policies, history — so that the same model answered accurately where it had previously hallucinated ([Etsy Code as Craft](https://www.etsy.com/codeascraft/context-engineering-case-studies-etsy-specific-question-answering)). The model didn't change. What changed was the table set for it.

**Second — retail and legal teams.** In application surveys, retailers report order-of-magnitude improvements in the accuracy of personalized recommendations after switching to agents with engineered context, and legal departments report faster contract preparation and fewer missed compliance risks ([MarkTechPost, 08.2025](https://www.marktechpost.com/2025/08/12/case-studies-real-world-applications-of-context-engineering/)). Numbers in such surveys should be read carefully — these are vendor case studies, not controlled experiments — but the direction aligns with everything else: the same model plus better context produces different results.

**Third — the most honest one, because it is an admission of failure.** A whole wave of practitioners in 2025–2026 wrote essentially the same thing: "RAG turned out to be insufficient." Meaning even automated retrieval of relevant documents — the very thing that had been held up as a magic wand — doesn't save you if there's no separate layer deciding *exactly what* and *in what order* to place on the model's desk ([Towards Data Science, 2026](https://towardsdatascience.com/rag-isnt-enough-i-built-the-missing-context-layer-that-makes-llm-systems-work/); [RAGFlow, 2025](https://ragflow.io/blog/rag-review-2025-from-rag-to-context)). Engineers built this layer by hand — and called it the context layer. The craft defined itself not from a textbook but from pain: first they broke against its absence, then they gave it a name.

The common denominator of the three cases is simple to the point of discomfort. In none of them was the solution "a smarter model." In each of them the solution was **better-organized memory**.

## Re-plating: so what does this mean in practice

Let's plate the dish again. If the bottleneck has moved from generation to memory, then the most valuable skill of the next several years is **not "knowing how to code" and not "knowing how to prompt," but knowing how to build and curate context** so that the model's finite workbench always holds exactly the pages it needs.

This is not a metaphor and not futurology. It is already a distinct discipline with its own techniques — memory management, data quality gates, relevance selection, ordering — where RAG turns out to be just one of the tools, not the entire craft ([Atlan, 2026](https://atlan.com/know/context-engineering-vs-rag/); [Weaviate, 2026](https://weaviate.io/blog/context-engineering)). And it is a discipline where **owning the context matters more than owning the model**. You rent the model for cents per million tokens — and your competitor rents the same one. But <mark>the curated context of your system is something that cannot be rented, because no one else has it except you; whoever owns the context is renting the model, not the other way around</mark>.

Hence three firm conclusions. First: documentation has ceased to be hygiene "for some day" — it has become a production asset that works daily. Second: the profession that doesn't exist in diplomas already exists in paychecks — and the $84k–$300k band says this is not a hype title but a role. Third, the most practical: the cheapest investment you can make this week is to sit down and write your `fee_legacy` file once. Not code. Memory.

## Hard kicker

Lucas closed his laptop at six. The 1,400-word file stayed alive in the repository — without a single line of code, with one column that cannot be deleted, and with the history of three crashes that will not happen again. The next morning a new developer on the team asked where to look to understand how billing works.

They weren't given access to the code. They were given the memory to read.