AI CLI Battles

The terminal stopped being a place of precise commands. We talk to it in plain English now, and it talks back. That shift has been brewing since the early days of GPT-3.5¹.

Back in early 2023, light years in AI time, everyone was marvelling at ChatGPT. A handful of developers asked a more ambitious question: what if we could delegate entire tasks to AI agents through the command line? AutoGPT² emerged as the proof of concept, a scrappy tool that showed autonomous agents could execute real development workflows.

The idea was simple: give an agent a goal, let it break down the task, execute commands, iterate until done. AutoGPT stayed a proof of concept. The models weren't there, the tooling was rough, and the developer experience was painful.

Now the major vendors have caught up with refined versions of the same concept. The question isn't whether AI CLI tools change how we work - it's which approach defines the next decade of software engineering.

The Testing Ground

I spent a focused day testing these tools on two real projects: reviving an 8-year-old Laravel appointment booking system from university and addressing GitHub issues in TranscribeMe, a Python CLI wrapper for AssemblyAI and OpenAI Whisper APIs.

The Laravel project became my primary testing ground - getting dev containers configured with Docker, updating dependencies, and modernising the codebase. TranscribeMe provided smaller, discrete tasks perfect for evaluating each tool's handling of existing codebases with active issues.

Tool Breakdown

Claude Code

Claude Code³ is the most polished experience. OAuth setup just works, and the IDE integration is deep. Extensions work across VS Code, JetBrains, and Neovim, with API access to active editor tabs providing genuine context awareness.

The tool excels in several key areas:

• Codebase Intelligence: Claude Code maps and explains entire codebases in a few seconds, using agentic search to understand project structure and dependencies without manual context selection. This "soft-cache" approach-essentially generating markdown documentation that explains your codebase-has become a defining pattern across AI CLI tools.

• IDE Integration: Claude Code doesn't force you out of your editor. Extensions for VS Code, JetBrains, and Neovim feed it the rich context IDE APIs expose.

• Model Flexibility: Support for Anthropic's full model suite, plus integration with Amazon Bedrock and Google Cloud Vertex AI, makes it enterprise-ready without vendor lock-in concerns.

• Thinking Modes: Claude Code includes specific phrases that trigger extended thinking modes-"think" provides 4,000 tokens of thinking budget, while "ultrathink" allocates up to 31,999 tokens for complex reasoning⁴.

The downside? Cost and accessibility. API costs for a medium-sized PR typically range from $10-15⁵, making it a significant investment for frequent use.

OpenAI's Codex CLI

OpenAI's Codex CLI⁶ is a straightforward implementation limited to OpenAI models. Environment variable configuration keeps setup minimal, though less elegant than OAuth flows. Conversation resumption works reliably, but model limitations become apparent quickly compared to Claude's reasoning capabilities.

Key differentiators include:

• Open Source Philosophy: Unlike Claude Code's closed-source approach, Codex CLI allows community contributions and customisation. This could prove crucial for adoption in enterprise environments where transparency and auditability matter.

• Model Integration: Support for any model available through the Responses API, with o4-mini as default but configurable to gpt-4.1 or other models.

• Sandbox Execution: Codex runs model-generated commands in a sandbox, allowing developers to review and approve changes before execution.

Early comparisons suggest performance differences. One developer noted that "Claude Code did great and wrote pretty decent docs, while Codex didn't do well - it hallucinated a bunch of stuff that wasn't in the code and completely misrepresented the architecture"⁷.

Amazon Q Developer CLI

Amazon's entry into this space reflects their cloud-first, enterprise-focused philosophy. The tool integrates deeply with AWS services but suffers from what I'd call "enterprise bloat"-requiring a desktop application for configuration and complex OAuth flows through IAM Identity Centre.

Ultimately, I do have my own bias towards self-hosting and homelabbing, but I do see value in enterprises like Amazon throwing money at this space to provide a more enterprise-grade experience.

Contextual Codebase Understanding

Across all these tools, one pattern emerges consistently: the /init command or equivalent functionality that helps the AI understand your codebase. This represents a fundamental shift in how we think about development environments.

The process is surprisingly straightforward:

1. The AI agent scans your project structure
2. It greps through code to understand patterns and dependencies
3. It generates a comprehensive markdown document explaining the codebase
4. This documentation becomes the foundation for all subsequent interactions

The clever part is that this "soft-cache" is portable. You can use Claude Code to generate initial codebase documentation, then reuse that same understanding with OpenAI's Codex CLI or other tools. The pattern isn't proprietary - it's just how agents need to contextualise large codebases.

The IDE Integrations

The boundary between CLI-based AI tools and IDE-embedded assistants is increasingly blurred. Tools like Windsurf, Cursor, and GitHub Copilot all offer "agent modes" that essentially perform the same codebase analysis and command execution as their CLI counterparts.

Claude Code supports both Amazon Bedrock and Google Vertex AI, making it enterprise ready without egress to external vendors. Meanwhile, IDE-based solutions offer tighter integration with development workflows but less flexibility in execution environments.

CLI vs IDE comes down to how you work. CLI tools give you control and transparency. IDE integrations give you visual feedback without leaving the editor.

MCP

The Model Control Protocol (MCP)⁸ represents a crucial development in this space. All these CLI tools can use MCP to a degree, opening opportunities to search with engines like Perplexity, query databases like PostgreSQL, or interact with task management platforms like Jira or Linear.

This standardisation effort means that AI agents aren't limited to basic file operations and command execution. They can integrate with the full ecosystem of development tools, from version control to project management to deployment pipelines.

Say I want to query technical documentation on the internet, I can simply add the fetch MCP to my relevant CLI tool. From there I can ask the same question and I'll get a tool call to the MCP server to fetch the relevant documentation.

Promises vs Reality

The marketing materials paint an impressive picture, but real-world usage reveals important nuances. One developer spent a week with Claude Code on Clojure projects, investing $134.79 and 12 hours, ultimately concluding that "Cursor is a much better workflow for me" and that "AI without oversight is still not there to deliver maintainable apps"⁹.

This highlights a crucial reality: these tools excel at the "first 90%" of development tasks but struggle with the "second 90%"-the refinement, debugging, and maintenance that transforms prototypes into production-ready applications.

Tools hallucinate predictably when pushed beyond their boundaries. AWS Q Developer provided the clearest example when I requested it read external documentation for project configuration. Without MCP web request capabilities, it fabricated responses based on existing files rather than admitting limitation.

Another developer noted the importance of defensive coding practices: "Building in the practice to run the linter constantly has kept a lot of bugs away... Add in a good formatter and everything is beautiful. The real magic is to add these tasks to a pre-commit hook"¹⁰.

My biggest "aha" moment was Windsurf. I dragged an image into the chat, it used Puppeteer to open the image and scrape the relevant details, then turned that into a prompt to generate code. Not sure a CLI can do that today, but that's the kind of tooling that changes the game.

Trust But Verify

One persistent challenge across all AI CLI tools is the hallucination problem. Even sophisticated models can misread documentation, miss crucial context, or suggest solutions based on outdated information. The key is ensuring relevant tools are enabled to allow web requests for technical documentation and confirming whether the AI actually read linked content.

This creates an interesting paradox: the more autonomous we make these tools, the more critical human oversight becomes. The most successful implementations seem to involve active collaboration rather than passive delegation, which these tools encourage you to do.

The Developer Experience

We're witnessing what I call the "developer experience arms race." Each tool borrows ideas from competitors in a tit-for-tat evolution of features. The determining factors will ultimately be:

1. LLM Performance: The quality of the underlying reasoning models
2. Tool Ergonomics: How well the interface fits existing developer workflows
3. Transparency: Whether developers can trust and verify the AI's actions
4. Cost Structure: Sustainable pricing for frequent use

Companies like Cursor, Cognition, Vercel, Replit, and Canva have rigorously tested Claude's capabilities, reporting significant improvements in tool execution, production-ready code generation, and debugging efficiency¹¹.

Looking Forward: Beyond the Hype Cycle

As someone who's watched developer tools evolve for over a decade, I see striking parallels to the early days of containerisation. Docker¹² seemed magical initially-a universal solution to deployment complexity. But the real value emerged through the ecosystem that developed around it: orchestration platforms, service meshes, and cloud-native architectures.

AI CLI tools are following a similar trajectory. The initial wow factor of natural language programming is giving way to more nuanced understanding of where these tools excel and where human expertise remains irreplaceable.

The most successful teams will likely adopt a hybrid approach:

• Use AI CLI tools for rapid prototyping and routine tasks
• Maintain human oversight for architectural decisions and complex debugging
• Put testing and validation workflows in place to catch AI-generated errors
• Develop team practices around prompt engineering and AI tool management

The Paradox of Choice

Developers are spoiled for choice with AI development tools. The question isn't whether to adopt them - it's which combination fits your context.

Consider your development environment:

• For rapid prototyping: Claude Code's comprehensive codebase understanding shines
• For cost-conscious teams: OpenAI's Codex CLI offers open-source flexibility
• For enterprise environments: Amazon Q Developer provides AWS integration at the cost of transparency
• For IDE-centric workflows: Cursor, Windsurf, or GitHub Copilot might be more natural fits

The key insight is that this isn't a zero-sum game. The underlying patterns-codebase contextualisation, natural language interfaces, and agentic task delegation-are becoming table stakes across the industry.

Bottom Line

These tools deliver genuine productivity improvements for appropriate use cases. Reviving legacy codebases, addressing discrete issues, and bootstrapping new projects all benefit from AI assistance. The technology works.

But the value isn't replacing expertise, it's amplifying it. The engineers who do well are the ones who collaborate with agents while keeping the critical thinking and architectural judgement that makes software good.

The terminal went from precise commands to collaborative problem-solving. If you haven't yet, take one real issue from your backlog and hand it to a CLI agent this week. Watch where it shines and where it faceplants. That gap tells you more than any benchmark.