I've been writing code a long time. The modern method of using coding agents (pi, opencode, etc.) has so much promise and can be made to do a fair bit of work. But these systems break down as the projects get more complex, larger, or even just more mature.

My primary frustrations stem from 3 main points:

• My own skill/knowledge (or lack of).
• My local coding environment (Ollama, local LLMs whenever possible, cheap free cloud LLMs, etc.).
• Agent focus and capabilities.

I want to discuss the last point and my frustrations here.

Session Based

Coding agents tend to be session based. Token limits are the primary reason behind this. It also is a simple method to provide some organization to what can otherwise be a very complex conversation. The end result though is we need to stay very focused on one particular topic or problem domain. Straying from that topic leads to unnecessary token usage, and confuses responses. For example if your focus is how best to structure your data models, talking about color themes for design purposes briefly (or something else off topic) can then influence the rest of the responses even if the main data model structure conversation does not return to graphic design considerations.

One Project

Want to really confuse your coding agent, try working with two projects simultaneously within one session. Back everything up though - it is very likely to become corrupted. The issue here is the agents assume your current working folder is your primary workspace/project (in most cases). Asking the agent to modify files in other folders or projects can easily lead the agent to get confused about which folder or project it should place new content in. So again we are back to being very focused on a single topic - our current folder/project. We need to exit the agent and start a new instance in a different folder or project to shift focus to that project.

Natural Language pretense.

Try talking to a person the same way you interact with the agents. My wife has strongly informed me this is a bad approach. The problem being that our person to person conversations rely on past memories and a shared context the words may not explicitly define. And we shift topics rapidly and constantly. We just can't talk to agents like that at this time. Doing so shows the limits of technology.

Imperfect Understandings

Words and phrases often have different meanings. Or the current folder may not be where the work needs to happen. The LLMs sometimes misunderstand our requests and undertake actions that lead to errors.

Using a Plan Mode helps. This is where you can have the LLM discuss what it wants to do and how to do it before any changes are made. Plan mode helps with ensuring your intents are understood and gives us a chance to see the misunderstandings early before code is written. However this understanding issue still creeps into the execution/build phase periodically. Asking the agent to undo a misunderstood direction takes time and great care in how you word the instructions. This is frustrating in that it detracts from the main focus/goal.

Code quality.

There is a trade off in play here.

• Does the generated code accomplish the desired results
• Is the code written in a way that considers security, best practices, in-house coding standards, etc.
• Was the solution implemented the way you would do it? Is it close enough to not matter?
• Is the work definition something you have sufficient expertise in to make these judgements? Or do you need learn more before judging this code.

Getting this trade off balance right can be tricky. Going "YOLO" can be risky. Inspecting everything can be slower than just writing the code yourself. The right answer is somewhere in the middle, and changes for every function definition.

Getting past the frustrations

I see a few ways to get past the frustrations:

• Patience. Stay Calm and Carry On. Accept that frustrations happen and deal with the issues as they come up. This seems to be the designed for solution in the industry thus far.
• Fix the issues. Contribute to the agents to work on parts that lead to the frustrations. Improve the technology. If you have the time and know how that is.
• Use a different agent and/or LLM. Some agents are better at some tasks than others. Some agents respond better to specific workflows.
• Create your own system that solves the issue. This is more effort up front but might pay off in the long run.

Note: I'm aware of the tools like Hermes Agent, OpenClaw, etc. My experience still shows the same frustrations though, even if they are more capable tools.

Based on these options I'm choosing the last option. This builds on my existing research projects and helps improve my overall understandings.

Next time I will talk about how I'm building a system that can address these frustrations:

• continuous discussion without sessions
• awareness of previous topics and AI Coding sessions
• multi-project capability from the start
• a personal "valet" to work with you

The foundational elements are in place. Next I need to develop the "product" to make it useful. More on this in my next post though.