The variety of choices we’ve to configure and enrich a coding agent’s context has exploded over the previous few months. Claude Code is main the cost with improvements on this area, however different coding assistants are shortly following go well with. Highly effective context engineering is changing into an enormous a part of the developer expertise of those instruments.
Context engineering is related for all sorts of brokers and LLM utilization after all. My colleague Bharani Subramaniam’s easy definition is: “Context engineering is curating what the mannequin sees so that you just get a greater consequence.”
For coding brokers, there may be an rising set of context engineering approaches and phrases. The inspiration of it are the configuration options provided by the instruments (e.g. “guidelines”, “abilities”), after which the nitty gritty of half is how we conceptually use these options (“specs”, numerous workflows).
This memo is a primer concerning the present state of context configuration options, utilizing Claude Code for instance on the finish.
What’s context in coding brokers?
“The whole lot is context” – nevertheless, these are the primary classes I consider as context configuration in coding brokers.
Reusable Prompts
Nearly all types of AI coding context engineering finally contain a bunch of markdown recordsdata with prompts. I exploit “immediate” within the broadest sense right here, prefer it’s 2023: A immediate is textual content that we ship to an LLM to get a response again. To me there are two most important classes of intentions behind these prompts, I’ll name them:
-
Directions: Prompts that inform an agent to do one thing, e.g. “Write an E2E take a look at within the following approach: …”
-
Steerage: (aka guidelines, guardrails) Common conventions that the agent ought to comply with, e.g. “All the time write assessments which can be impartial of one another.”
These two classes usually mix into one another, however I’ve nonetheless discovered it helpful to tell apart them.
Context interfaces
I couldn’t actually discover a longtime time period for what I’d name context interfaces: Descriptions for the LLM of the way it can get much more context, ought to it resolve to.
-
Instruments: Constructed-in capabilities like calling bash instructions, looking out recordsdata, and many others.
-
MCP Servers: Customized applications or scripts that run in your machine (or on a server) and provides the agent entry to information sources and different actions.
-
Abilities: These latest entrants into coding context engineering are descriptions of extra sources, directions, documentation, scripts, and many others. that the LLM can load on demand when it thinks it’s related for the duty at hand.
The extra of those you configure, the extra space they take up within the context. So it’s prudent to suppose strategically about what context interfaces are mandatory for a selected job.
Information in your workspace
Probably the most fundamental and highly effective context interfaces in coding brokers are file studying and looking out, to know your
If and when: Who decides to load context?
-
LLM: Permitting the LLM to resolve when to load context is a prerequisite for operating brokers in an unsupervised approach. However there at all times stays some uncertainty (dare I say non-determinism) if the LLM will really load the context after we would anticipate it to. Instance: Abilities
-
Human: A human invocation of context offers us management, however reduces the extent of automation general. Instance: Slash instructions
-
Agent software program: Some context options are triggered by the agent software program itself, at deterministic cut-off dates. Instance: Claude Code hooks
How a lot: Retaining the context as small as doable
One of many objectives of context engineering is to stability the quantity of context given – not too little, not an excessive amount of. Despite the fact that context home windows have technically gotten actually huge, that doesn’t imply that it’s a good suggestion to indiscriminately dump info in there. An agent’s effectiveness goes down when it will get an excessive amount of context, and an excessive amount of context is a price issue as nicely after all.
A few of this dimension administration is as much as the developer: How a lot context configuration we create, and the way a lot textual content we put in there. My advice could be to construct context like guidelines recordsdata up step by step, and never pump an excessive amount of stuff in there proper from the beginning. The fashions have gotten fairly highly effective, so what you might need needed to put into the context half a yr in the past may not even be mandatory anymore.
Transparency about how full the context is, and what’s taking over how a lot area, is a vital function within the instruments to assist us navigate this stability.
However it’s not all as much as us, some coding agent instruments are additionally higher at optimising context below the hood than others. They compact the dialog historical past periodically, or optimise the best way instruments are represented (like Claude Code’s Software Search Software).
Instance: Claude Code
Right here is an summary of Claude Code’s context configuration options as of January 2026, and the place they fall within the dimensions described above:
CLAUDE.md
What: Steerage
Who decides to load: Claude Code – All the time used at begin of a session
When to make use of: For many steadily repeated basic conventions that apply to the entire challenge
Instance use instances:
- “we use yarn, not npm”
- “don’t overlook to activate the digital setting earlier than operating something”
- “after we refactor, we don’t care about backwards compatibility”
Different coding assistants: Mainly all coding assistants have this function of a most important “guidelines file”; There are makes an attempt to standardise it as AGENTS.md
Guidelines
What: Steerage
Who decides to load: Claude Code, when recordsdata on the configured paths have been loaded
When to make use of: Helps organise and modularise steering, and due to this fact restrict dimension of the at all times loaded CLAUDE.md. Guidelines may be scoped to recordsdata (e.g. *.ts for all TypeScript recordsdata), which suggests they may then solely be loaded when related.
Instance use instances: “When writing bash scripts, variables needs to be known as ${var} not $var.” paths: **/*.sh
Different coding assistants: An increasing number of coding assistants enable this path-based guidelines configuration, e.g. GH Copilot and Cursor
Slash instructions
What: Directions
Who decides to load: Human
When to make use of: Frequent duties (evaluate, commit, take a look at, …) that you’ve got a particular longer immediate for, and that you just wish to set off your self, inside the primary context DEPRECATED in Claude Code, superceded by Abilities
Instance use instances: /code-review · /e2e-test · /prep-commit
Different coding assistants: Frequent function, e.g. GH Copilot and Cursor
Abilities
What: Steerage, directions, documentation, scripts, …
Who decides to load: LLM (primarily based on ability description) or Human
When to make use of: In its easiest kind, that is for steering or directions that you just solely wish to “lazy load” when related for the duty at hand. However you possibly can put no matter extra sources and scripts you need right into a ability’s folder, and reference them from the primary SKILL.md to be loaded.
Instance use instances:
- JIRA entry (ability e.g. describes how agent can use CLI to entry JIRA)
- “Conventions to comply with for React elements”
- “Find out how to combine the XYZ API”
Different coding assistants: Cursor’s “Apply intelligently” guidelines have been at all times a bit like this, however they’re now additionally switching to Claude Code fashion Abilities
Subagents
What: Directions + Configuration of mannequin and set of accessible instruments; Will run in its personal context window, may be parallelised
Who decides to load: LLM or Human
When to make use of:
- Frequent bigger duties which can be appropriate for and price operating in their very own context for effectivity (to enhance outcomes with extra intentional context), or to scale back prices).
- Duties for which you often wish to use a mannequin apart from your default mannequin
- Duties that want particular instruments / MCP servers that you just don’t wish to at all times have out there in your default context
- Orchestratable workflows
Instance use instances:
- Create an E2E take a look at for every thing that was simply constructed
- Code evaluate performed by a separate context and with a special mannequin to provide you a “second opinion” with out the luggage of your authentic session
- subagents are foundational for swarm experiments like claude-flow or Fuel City
Different coding assistants: Roo Code has had subagents for fairly some time, they name them “modes”; Cursor simply received them; GH Copilot permits agent configuration, however they’ll solely be triggered by people for now
MCP Servers
What: A program that runs in your machine (or on a server) and offers the agent entry to information sources and different actions through the Mannequin Context Protocol
Who decides to load: LLM
When to make use of: Use whenever you wish to give your agent entry to an API, or to a instrument operating in your machine. Consider it as a script in your machine with plenty of choices, and people choices are uncovered to the agent in a structured approach. As soon as the LLM decides to name this, the instrument name itself is often a deterministic factor. There’s a development now to supercede some MCP server performance with abilities that describe the best way to use scripts and CLIs.
Instance use instances: JIRA entry (MCP server that may execute API calls to Atlassian) · Browser navigation (e.g. Playwright MCP) · Entry to a information base in your machine
Different coding assistants: All frequent coding assistants assist MCP servers at this level
Hooks
What: Scripts
Who decides to load: Claude Code lifecycle occasions
When to make use of: If you need one thing to occur deterministically each single time you edit a file, execute a command, name an MCP server, and many others.
Instance use instances:
- Customized notifications
- After each file edit, examine if it’s a JS file and if that’s the case, then run prettier on it
- Claude Code observability use instances, like logging all executed instructions someplace
Different coding assistants: Hooks are a function that’s nonetheless fairly uncommon. Cursor has simply began supporting them.
Plugins
What: A approach to distribute all or any of this stuff
Instance use instances: Distribute a standard set of instructions, abilities and hooks to groups in an organisation
That is fairly a protracted record! Nevertheless, we’re in a “storming” part proper now and can absolutely converge on a less complicated set of options. I anticipate e.g. Abilities to not solely take up slash instructions, but in addition guidelines, which would cut back this record by two entries.
Sharing context configurations
As I stated at first, these options are simply the inspiration for people to do the precise work and filling these with cheap context. It takes fairly a little bit of time to construct up a superb setup, as a result of you must use a configuration for some time to have the ability to say if it’s working nicely or not – there aren’t any unit assessments for context engineering. Due to this fact, persons are eager to share good setups with one another.
Challenges for sharing:
- The context of the sharer and the receiver needs to be as related as doable – it really works loads higher within a group than between strangers on the web
- There’s a tendency to overengineer the context with pointless, copied & pasted directions up entrance, in my expertise it’s greatest to construct this up iteratively
- Completely different expertise ranges would possibly want totally different guidelines and directions
- When you’ve got low consciousness of what’s in your context since you copied loads from a stranger, you would possibly inadvertently repeat directions or contradict current ones, or blame the poor coding agent for being ineffective when it’s simply following your directions
Beware: Phantasm of management
Despite the title, finally this isn’t actually engineering… As soon as the agent will get all these directions and steering, execution nonetheless depends upon how nicely the LLM interprets them! Context engineering can positively make a coding agent more practical and improve the likelihood of helpful outcomes fairly a bit. Nevertheless, typically individuals speak about these options with phrases like “guarantee it does X”, or “forestall hallucinations”. However so long as LLMs are concerned, we are able to by no means be sure of something, we nonetheless have to suppose in chances and select the fitting stage of human oversight for the job.
