models able to automating a wide range of tasks, corresponding to research and coding. Nonetheless, often times, you’re employed with an LLM, complete a task, and the subsequent time you interact with the LLM, you begin from scratch.
It is a major problem when working with LLMs. We waste quite a lot of time simply repeating instructions to LLMs, corresponding to the specified code formatting or how you can perform tasks in line with your preferences.
That is where files are available: A technique to apply continual learning to LLMs, where the LLM learns your patterns and behaviours by storing generalizable information in a separate file. This file is then read each time you begin a brand new task, stopping the cold start problem and helping you avoid repeating instructions.
In this text, I’ll provide a high-level overview of how I achieve continual learning with LLMs by continually updating the file.
Why do we’d like continual learning?
Starting with a fresh agent context takes time. The agent needs to choose up in your preferences, and it is advisable spend more time interacting with the agent, getting it to do exactly what you would like.
For instance:
- Telling the agent to make use of Python 3.13 syntax, as an alternative of three.12
- Informing the agent to at all times use return types on functions
- Ensuring the agent never uses the type
I often needed to explicitly tell the agent to make use of Python 3.13 syntax, and never 3.12 syntax, probably because 3.12 syntax is more prevalent of their training dataset.
The entire point of using AI agents is to be fast. Thus, you don’t need to be spending time repeating instructions on which Python version to make use of, or that the agent should never use the Any type.
Moreover, the AI agent sometimes spends time beyond regulation determining information that you simply have already got available, for instance:
- The name of your documents table
- The names of your CloudWatch logs
- The prefixes in your S3 buckets
If the agent doesn’t know the name of your documents table, it has to:
- List all tables
- Discover a table that seems like the document table (might be several potential options)
- Either make a lookup to the table to verify, or ask the user
This takes quite a lot of time, and is something we will easily prevent by adding the document table name, CloudWatch logs, and S3 bucket prefixes into .
Thus, the essential reason we’d like continual learning is that repeating instructions is frustrating and time-consuming, and when working with AI agents, we would like to be as effective as possible.
Learn how to apply continual learning
There are two essential ways I approach continual learning, each involving heavy utilization of the file, which you must have in every repository you’re working on:
- Every time the agent makes a mistake, I inform the agent how you can correct the error, and to recollect this for later within the file
- After each thread I’ve had with the agent, I exploit the prompt below. This ensures that anything I told the agent throughout the thread, or information it discovered throughout the thread, is stored for later use. This makes later interactions far simpler.
Generalize the knowledge from this thread, and remember it for later.
Anything that might be useful to know for a later interaction,
when doing similar things. Store in agents.mdApplying these two easy concepts will get you 80% on the technique to continual learning with LLMs and make you a far simpler engineer.
Crucial point is to at all times keep the agentic memory with in mind. Every time the agent does something you don’t like, you mostly should remember to store it in
You would possibly think you’re risking bloating the file, which can make the agent each slower and more costly. Nonetheless, this isn’t really the case. LLMs are extremely good at condensing information down right into a file. Moreover, even when you’ve got an file consisting of 1000’s of words, it’s not likely an issue, neither with regard to context length or cost.
The context length of frontier LLMs is a whole lot of 1000’s of tokens, in order that’s no issue in any respect. And for the fee, you’ll probably start seeing the fee of using the LLM go down. The explanation for that is that the agent will spend fewer tokens determining information, because that information is already present in
Heavy usage of for agentic memory will each make LLM usage faster, and reduce cost
Some added suggestions
I’d also wish to add some additional suggestions which are useful when coping with agentic memory.
The primary tip is that when interacting with Claude Code, you may access the agent’s memory using “#”, after which write what to recollect. For instance, write this into the terminal when interacting with Claude Code:
# All the time use Python 3.13 syntax, avoid 3.12 syntaxYou’ll then get an option, as you see within the image below. Either you put it aside to the user memory, which stores the data for all of your interactions with Claude Code, regardless of the code repository. This is helpful for generic information, like at all times having a return type for functions.
The second and third options are to reserve it to the present folder you’re in or to the foundation folder of your project. This may be useful for either storing folder-specific information, for instance, only describing a selected service. Or for storing details about a code repository basically.
Moreover, different coding agents use different memory files.
- Claude Code uses CLAUDE.md
- Warp uses WARP.md
- Cursor uses .cursorrules
Nonetheless, all agents often read which is why I like to recommend storing information in that file, so you’ve got access to the agentic memory regardless of which coding agent you’re using. It is because someday Claude Code might be the perfect, but we’d see one other coding agent on top one other day.
AGI and continual learning
I’d also wish to add a note on AGI and continual learning. True continual learning is usually said to be one in every of the last hindrances to achieving AGI.
Currently, LLMs essentially fake continual learning by simply storing things they learn into files they read afterward (corresponding to agents.md). Nonetheless, the perfect could be that LLMs continually update their model weights each time learning recent information, essentially the best way humans learn instincts.
Unfortunately, true continual learning shouldn’t be achieved yet, but it surely’s likely a capability we’ll see more of in the approaching years.
Conclusion
In this text, I’ve talked about how you can develop into a far simpler engineer by utilizing agents.md for continual learning. With this, your agent will pick up in your habits, the mistakes you make, the data you often use, and lots of other useful pieces of data. This again will make later interactions together with your agent far simpler. I consider heavy utilization of the agents.md file is important to becoming an excellent engineer, and is something you must continuously strive to attain.
👉 My Free Resources
🚀 10x Your Engineering with LLMs (Free 3-Day Email Course)
📚 Get my free Vision Language Models ebook
💻 My webinar on Vision Language Models
👉 Find me on socials:
🧑💻 Get in contact
✍️ Medium
