How to Facilitate Effective AI Programming

with AI is an effective way of increasing coding speed. AI agents can handle a lot of the simple and repetitive tasks, while you can act as an orchestrator for your agents.

A problem I often encounter, however, is that I have more context in my head than an AI agent could ever have. This could, for example, be:

• Business objective with a feature
• Technical discussions are happening orally in the office
• Meetings where we discussed different topics
• Historic knowledge

The similarity between all of these is that this information typically isn’t written down, and is definitely not available to your AI agent when implementing code.

However, we all know that to be as effective a programmer as possible, you need extensive context. You need to know why a feature is being built to make the right decisions when implementing the code. The technical discussions in the office are important to understanding the codebase, and projects are often shaped in meetings. The question then is:

How can we make AI have the same context as human programmers?

I’d argue the answer is to be strict about writing down all knowledge (which is now a lot simpler using AI tools), and providing tooling for the AI to have access to this information.

In this article, I’ll discuss how I’m trying to facilitate my coding agent to be as efficient as possible. I believe a large part of this is simply to make sure the AI has access to the same information I have, and I’ll discuss three specific techniques I use every day to make this happen.

I think an important point in why coding agent isn’t more effective, is simply because they don’t have access to the same context humans have access to

Why provide all context to the AI

The main reason for providing your AI coding agent as much context as possible is that the more information the AI has, the better it will perform.

Imagine you wanted to implement a feature, say, for example, a tool to summarize meetings. Developing this feature is incredibly difficult if you don’t know:

• Which repository should the code belong to?
• Should it summarize all meetings, or just external meetings?
• How fast does the summarization need to happen? 5 seconds, or 5 minutes?

These questions are all contexts that you get as a human that a coding agent doesn’t natively have access to.

You know which code repository to implement the code in, because you’ve worked in the repository before.

You know it should only summarize external meetings, and that it only needs to summarize in 5 minutes, because it was discussed during the shaping meeting last week.

However, if you don’t provide your coding agent with this context on implementation, it will never be able to implement the feature the way you want it implemented.

If the agent lacks context that you have, you’ll notice the agent starts performing undesired actions. This is frustrating and time-consuming, but can be eliminated by syncing your context, with the coding agent’s context

3 Techniques to Provide Context to AI

In this section, I’ll cover specific techniques I use in my day-to-day to provide my coding agents as much context as possible. I believe these techniques are critical to making me efficient as a programmer, and I’m constantly looking for more techniques to become even more effective.

Store IaC schema in a Markdown file

A simple technique you can use to give the AI more context is to store your Infrastructure as Code in a simple-to-access file.

IaC is the code representing information such as:

• Table names
• S3 buckets and prefixes
• Production logs
• Permissions,

When you’ve been working in a company for a while, you probably have all of this information memorized. You remember the table names of the most important tables, and which S3 buckets store what, and in which prefixes.

However, your coding agent doesn’t have simple access to this, unless you provide them access. The simplest way to do this is:

1. Store all your IaC repositories in one folder
2. Tell a coding agent to go through all of these repositories and summarize all the IaC in a single Markdown file
3. Now you can refer to this Markdown file whenever you want your agent to work with anything IaC

It’s difficult to explain how much time this has saved me. My agent doesn’t have to list all database tables before finding the right table storing the information it’s looking for. Instead, it simply knows all of these table names and directly accesses the right information. This makes the agent a lot faster and also cheaper, since it’s spending fewer tokens to find the information it’s looking for.

Notice when your coding agent is missing context

Another important point is to be alert to when your AI is missing context. If you didn’t summarize your IaC (as explained in the last section), you’ll probably notice the agent is always:

1. Listing all table names
2. Reasoning about which table is the correct one to access now
3. Try accessing one table, and sometimes be wrong, and have to try another table

This is a result of your coding agent missing important context. Whenever you notice a pattern like this, you should immediately interrupt and inform the coding agent:

When you look for documents, you can find them in the table called
DocumentTable. Memorize this in AGENTS.md

Now the agent will remember this for next time, and you’ll save a lot of time and tokens.

I urge you to always look for situations where your coding agent is struggling. If it’s taking longer than usual for a task, it’s usually because it’s missing context, and it’s your job to provide that context to the AI coding agent.

Summarize meetings with AI tools

Another simple technique you can use to provide 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 shaping meeting discussing how to implement a feature, you can summarize that meeting and provide it as context to your coding agent when implementing the feature.

This way, the agent has access to all of the information you do about how the feature should be implemented. This is a cheap and simple technique you can utilize to improve the context of your coding agent.

To amend the last section, I also want to highlight that shaping meetings should typically result in properly shaped tasks in project management tools such as Linear.

The feature you’re implementing, for example, should be summarized and shaped completely into a single Linear issue or project. If this is the case, you should only have to provide for AI agent access to the Linear issue (which you can do with the Linear MCP), to ensure it has access to all the relevant information.

Conclusion

In this article, I’ve covered how to facilitate more effective programming with AI coding agents. I’ve discussed how a very common problem for coding agents is that they don’t have access to the same context human programmers have. This is simple because topics are discussed in meetings and around the office, and this information is not written down. I’ve highlighted three specific techniques I use to give my coding agent as much context as possible. I believe that in the coming years, we’ll see great improvements in coding agents’ performance, simply because we’re better able to provide them all the context that is needed to effectively complete tasks.

👉 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:

📩 Subscribe to my newsletter

🧑‍💻 Get in touch

🔗 LinkedIn

🐦 X / Twitter

✍️ Medium