There's a rare kind of honesty in the AI world where someone from inside the machine actually asks what's broken. Thibault Sottiaux, engineering lead for OpenAI's Codex agentic coding system, did exactly that last week. He posted on X asking developers to name the capabilities that still feel surprisingly out of reach despite years of progress. More than 1,200 developers answered. The replies paint a clear picture of where the current generation of AI coding tools genuinely struggles.
And it's useful. Not to dunk on the tools (which are genuinely impressive in the right contexts) but because understanding the gaps is the only way to build around them properly.
The context wall
The single biggest complaint: context management. When a project hits the context window limit, Codex responds by telling users to "start a new chat or clear the archive" rather than handling the transition itself. For anyone working on a moderately complex codebase, this is a significant friction point. You're mid-flow, the model loses the thread, and you're back to re-establishing context manually. The whole promise of an agentic coding tool is that it carries the work forward. When it can't, the burden shifts straight back to you.
This isn't unique to Codex. Context window management is one of the harder open problems in applied LLM work right now. The models are getting better at reasoning over long inputs, but handling the handoff gracefully when that limit is reached (without breaking your flow) is still mostly unsolved in production tools.
Visual reasoning that doesn't quite see
Game developers flagged a different pattern: shallow visual comprehension. Codex can see a screenshot, but developers say it reads visual information at surface level. The model might look at a UI, see some panels, and conclude things are working without actually understanding spatial relationships, layout logic, or what's visually happening on screen.
If your product has a meaningful visual layer (anything beyond basic UI wiring), don't assume the model reasons about it the way a developer would. It sees. It doesn't necessarily understand.
Documentation that leaks internals
A more specific issue, but worth knowing: some developers found that Codex writes its own internal instructions and reasoning into generated readme files and frontend widgets. Instead of clean, professional output, the model's inner monologue ends up in artefacts you'd actually ship. If you're not carefully reviewing everything the model produces, you might not catch it until it's in a pull request or already live.
Structural limits
On the architecture side, Codex projects are currently limited to a single folder. That rules out anything with a more complex repository structure: monorepos, microservices, multi-package setups. For a lot of modern product development, that's a real constraint and not a theoretical one.
Why this matters beyond the tool
Among 142 analysed replies from the thread, 76% were negative. That's not a complaint about AI being overhyped in general. It's specific, technical, actionable feedback about where the experience breaks down in practice. And it comes from the kinds of developers actually building with these tools, not from critics on the sidelines.
The honest take: AI coding assistants work well when the task is scoped, context is bounded, you're working in a single directory, and you have someone reviewing the output. When the task grows in scope, spans multiple repositories, requires visual reasoning, or runs long enough to hit context limits, the seams show. Knowing that going in is genuinely useful.
Where this lands for your team
If you're evaluating AI coding tools for your development workflow, the question isn't whether to use them. It's how to build the right scaffolding around the gaps. That means thinking about how context gets managed across a long session, where review sits in your pipeline, how your repository structure maps to tool constraints, and what happens when the model hits its limits mid-task.
This is exactly the kind of problem we work through with clients at Dakik. RAG pipelines that surface the right context at the right time, agent setups that work across complex repository structures without losing the thread, review layers between model output and your codebase. If AI coding tools are already in your development process but hitting exactly these friction points, that's engineering we can help with. And if you're thinking about trust in AI-generated code more broadly, we recently wrote about how Leanstral 1.5 has made formal code verification 75x cheaper and what that shift means for teams shipping AI-assisted code at scale.
The gaps are knowable. Building around them is the job.