with AI is an effective way to increase the speed of coding. AI agents can handle many simple and repetitive tasks, while you can act as an orchestrator for your agents.
The problem I often run into, however, is that I have more context in my head than an AI agent can. This could, for example, be:
- Defective business purpose
- Technical discussions take place verbally in the office
- Meetings where we discussed different topics
- Historical information
The commonality between all of these is that this information is usually not written down, and is not available to your AI agent when you run the code.
However, we all know that to be the most effective editor possible, you need a broad context. You need to know why the feature was created in order to make the right decisions when using the code. Technical discussions in the office are important for understanding the codebase, and projects are often shaped in meetings. The question is:
How can we make AI have the same context as human programmers?
I would argue that the answer is to be proactive in documenting all information (which is now very easy to use for AI tools), and providing tools for AI to access this information.
In this article, I will discuss how I try to help my writing agent to be as efficient as possible. I believe a big part of this is making sure the AI has access to the same information I have, and I'm going to discuss three specific strategies I use every day to make this happen.
I think the main point of why the code agent doesn't work better, is because it doesn't have access to the same context that humans have access to.
Why give all context to AI
The main reason to provide your AI code agent with as much context as possible is that the more knowledge the AI has, the better it will perform.
Imagine you wanted to use a feature, say, for example, a meeting summary tool. Developing this feature is incredibly difficult if you don't know:
- What repository should the code belong to?
- Should it abbreviate all meetings, or just outside meetings?
- How quickly should the summary occur? 5 seconds, or 5 minutes?
These questions are the content you get as a human that a coding agent can't access.
You know what code you've coded into, because you've worked in the repository.
He knows that he should only summarize the external meetings, and that he only needs to summarize in 5 minutes, because it was discussed during the formation meeting last week.
However, if you don't provide your coding agent with this context in the implementation, it won't be able to use the feature the way you want it to.
If the agent lacks context, you will notice that the agent starts doing unwanted actions. This is frustrating and time consuming, but can be eliminated by synchronizing your context, with the context of the coding agent.
3 Strategies for Providing Content to AI
In this section, I will include some techniques that I use in my daily life to provide my coding agents with as much context as possible. I believe that these techniques are essential for me to be effective as an editor, and I am always looking for more techniques to be even more effective.
Save the IaC schema in a Markdown file
An easy way to give AI more context is to store your Infrastructure as Code in an easily accessible file.
IaC is a code that represents information such as:
- Table names
- S3 buckets and starters
- Timber for production
- Permissions,
When you've been working in a company for a while, you've probably memorized all of this information. You remember the table names of the most important tables, and which S3 buckets store what, and which ones start.
However, your coding agent does not have easy access to this, unless you grant them access. The easiest way to do this is:
- Keep all your IaC archives in one folder
- Tell the code agent to go through all these repositories and summarize all the IaCs in a single Markdown file.
- Now you can refer to this Markdown file whenever you want your agent to work with anything IaC
It's hard to explain how much time this has saved me. My agent doesn't have to list all the database tables before finding the right table that stores the information it wants. Instead, it just knows all these table names and directly accesses the correct information. This makes the agent much faster and cheaper, as it uses fewer tokens to get the information it wants.
Be aware if your writing agent is missing context
Another important point is to notice when your AI is missing context. If you haven't abstracted your IaC (as explained in the last section), you will probably notice that the agent resides:
- Lists all table names
- Thinking about which table is right to reach now
- Try to access one table, and sometimes you are wrong, and you have to try another table
This is a result of your agent's lack of critical coding. Any time you see a pattern like this, you should immediately interrupt and notify the code agent:
When you look for documents, you can find them in the table called
DocumentTable. Memorize this in AGENTS.mdNow the agent will remember this next time, and will save more time and tokens.
I urge you to keep an eye out for situations where your coding agent is struggling. If it takes longer than usual for a task, it's usually because there's a lack of context, and it's your job to provide that context to the AI code agent.
Summarize meetings with AI tools
Another simple method you can use to give your coding agent more context is to summarize meetings with AI tools, such as Granola, and provide this as context for your coding agent.
For example, if you had a coding session that discussed how to use a feature, you can summarize that session and provide it as context for your coding agent when using the feature.
This way, the agent has access to all the information you do about how the feature should be used. This is a cheap and easy method you can use to improve your agent's coding environment.
To amend the last section, I also want to highlight that design meetings should result in well-structured tasks in project management tools such as Linear.
A feature you use, for example, should be condensed and completely fixed into a single line issue or project. In that case, you should only give the AI agent access to the Linear issue (which you can do with Linear MCP), to ensure that it has access to all the relevant information.
The conclusion
In this article, I have covered how to make effective programs with AI coding agents. I've argued that the most common problem with coding agents is that they don't have access to the same context as human programmers. This is easy because topics are discussed in meetings and in the office, and this information is not written down. I've highlighted three specific techniques I use to provide my coding agent with as much context as possible. I believe that in the coming years, we will see great improvements in the performance of coding agents, simply because we are better able to provide them with all the context necessary to complete tasks successfully.
👉 My Free Resources
🚀 10x Your Engineering with LLMs (Free 3-Day Email Course)
📚 Get my free ebook Vision Language Models
💻 My webinar on Vision Language Models
👉 Find me on social media:
📩 Subscribe to my newsletter
🧑💻 Contact
🐦 X / Twitter
✍️ In the middle
