Limited Domain Understanding and Service Limits
AI coding agents often struggle with designing scalable systems due to the vast number of choices and the lack of enterprise‑specific context. Large enterprise codebases and monorepos can be too extensive for agents to learn from effectively. Additionally, popular coding agents face service limits that hinder their performance in large‑scale environments. For instance, indexing features may fail or degrade in quality for repositories with more than 2,500 files or due to memory constraints. Files larger than 500 KB are often excluded from indexing, which can impact established products with older, larger code files.
For complex tasks involving extensive file contexts or refactoring, developers must provide relevant files and explicitly define the refactoring procedure and surrounding build/command sequences to validate implementations without introducing regressions.
Lack of Hardware Context and Usage
AI agents often lack awareness of OS machine, command‑line, and environment installations (such as conda/venv). This can lead to frustrating experiences, such as attempting to execute Linux commands on PowerShell, resulting in “unrecognized command” errors. Furthermore, agents may exhibit inconsistent “wait tolerance” when reading command outputs, prematurely declaring an inability to read results before a command has finished, especially on slower machines.
These practical details manifest as real points of friction, necessitating constant human vigilance to monitor the agent’s activity in real‑time. Otherwise, the agent might ignore initial tool‑call information and either stop prematurely or proceed with a half‑baked solution requiring undoing changes, re‑triggering prompts, and wasting tokens.
Hallucinations Over Repeated Actions
A longstanding challenge with AI coding agents is hallucinations—incorrect or incomplete pieces of information within a larger set of changes. While these may seem trivial to fix, the problem becomes more significant when incorrect behavior is repeated within a single thread. Developers may need to start a new thread and re‑provide all context or intervene manually to unblock the agent.
For example, during a Python function code setup, an agent incorrectly flagged a file containing special characters as unsafe, halting the entire generation process. Despite multiple attempts to restart or continue the modification, the issue recurred. The only successful workaround involved instructing the agent to ignore the file and manually add the desired configuration.
Lack of Enterprise‑Grade Coding Practices
Coding agents often default to less secure authentication methods, such as key‑based authentication, rather than modern identity‑based solutions. This can introduce significant vulnerabilities and increase maintenance overhead.
Additionally, agents may not consistently use the latest SDK methods, instead generating more verbose and harder‑to‑maintain implementations. For instance, agents have outputted code using older SDK versions for read/write operations, rather than the cleaner and more maintainable newer versions.
Even for smaller tasks, agents may produce repetitive code without anticipating the developer’s upcoming needs. This can lead to technical debt and harder‑to‑manage codebases.
Confirmation Bias Alignment
Confirmation bias is a significant concern, as AI models often affirm user premises even when the user expresses doubt. This tendency can lead to reduced output quality, especially for objective/technical tasks like coding.
Constant Need to Babysit
Despite the promise of autonomous coding, the reality is that AI agents in enterprise development often require constant human oversight. Instances like attempting to execute Linux commands on PowerShell or false‑positive safety flags highlight critical gaps. Developers cannot step away but must constantly monitor the agent’s reasoning process to avoid wasting time with subpar responses.
The worst‑case scenario is a developer accepting multi‑file code updates riddled with bugs, then spending excessive time debugging. This can lead to the sunk‑cost fallacy of hoping the code will work after a few fixes, especially in complex codebases with connections to multiple services.
Conclusion
While AI coding agents have revolutionized prototyping and automated boilerplate coding, the real challenge lies in knowing what to ship, how to secure it, and where to scale it. Smart teams are learning to filter the hype, use agents strategically, and rely on engineering judgment. As GitHub CEO Thomas Dohmke noted, the most advanced developers have moved from writing code to architecting and verifying the implementation work carried out by AI agents. In the agentic era, success belongs to those who can engineer systems that last.
