If you're using AI agents in a real codebase, here are three things I've learned that actually work.
Agents and LLMs are really good at extrapolating from whatever context they are provided out into infinity if you let them. A concrete example of this is when you're working with microservices and you have several codebases that interact with each other. Asking an LLM to create a feature that depends on external services while only providing the context of a single service will cause the agent to make up system architecture based on the context you have instead of reality.
A useful way that I've found to address this problem is to checkout all of the repositories that I need and organize them hierarchically based on service groupings. Once that's done you can open an agent at the top level directory and tell it to walk the tree and create an architecture.md document that describes the system at a high level. Then, when you want to create a feature that spans multiple service boundaries you can ask your agent to create a plan based on this concrete high level architecture.
When it's time to implement the feature you zoom into the specific service directory, plan in hand, and ask a different agent to implement the feature and take advantage of the much narrower context window.
The next hot tip would be to take advantage of skills and goals, I picked this up from my friends who use Claude a lot but skills work with Codex as well. A skill is a reusable set of well-defined instructions for an agent.
A lot of the grunt work we do every day should be reviewed to see if that job can be handed off to an agent. For example, one of my daily chores as a senior engineer is to get latest on all of the repos I work in and review the changes to keep up to date and stay aware of how things are changing.
As more of my colleagues start doing agentic work this has become an absolute deluge, to the point where I was just going through the motions and not really absorbing anything. So, I decided to address that, and this ties directly back into my previous tip. I wrote a skill that reviews all of the changes across all codebases and then generates a report and highlights trends and links to specific commits in git so that I can zoom in for further review.
The skill is called git-catch-me-up or something along those lines, and when I ask my agent to "catch me up over date range X" it triggers the skill to create a working directory with my entire service hierarchy inside (if it doesn't already exist), this is to avoid trampling any work I have in progress. Then it gets latest from main on all projects and analyzes the history for the specified date range and based off of that analysis it synthesizes a report.
If it notices any new architecture changes that are inconsistent with the document, it offers to make those deletions or additions so that we can continue feeding the architecture.md document to other agents without worrying that it is becoming outdated.
Using the architecture.md document I can ask agents to generate study guides for different areas of the codebase and then create quizzes to test my knowledge.
This is the kind of stuff that previously you would have needed to develop a pretty good relationship with a senior on your team, and even then you'd be very hard pressed to find someone with the patience to create study guides and quizzes.
These exercises and skills all come together to create a circular feedback loop where each day I learn more about the code which makes me better at critiquing the code that my agents are generating which in turn allows my agents to generate better code. I feel like I get the benefits of sitting in daily architecture meetings without using anyone's time but my own and that's been a huge win for me.