Testing AI coding agents by making them build their own rivals

The self-replication experiment

A developer recently conducted an experiment to see if popular AI coding agents could build their own rivals. The project was inspired by the fact that the Claude Code team previously shared that Claude wrote approximately 90% of the tool's own code. This gave the author confidence that the AI could handle the task of creating a lightweight alternative.

The goal was not to create a perfect replica of each existing tool. Instead, the author wanted a functional coding agent capable of inspecting projects, reading and modifying files, executing commands, running tests, and fixing errors autonomously. To ensure a fair test, the author provided all three agents with the exact same prompt outlining these core requirements.

The author specifically instructed the agents not to build simple wrappers around existing coding agents or rely on a coding-agent SDK to do the heavy lifting. This forced the AI models to make their own technical decisions regarding programming languages, application structures, and the libraries they would install. The experiment aimed to see how different models would approach the same architectural challenge.

Technical paths taken

The results showed distinct technical choices among the three agents. Claude Code and Codex both chose Python as their primary language. Claude Code utilized the official Anthropic SDK to communicate with models, while Codex used Python's standard library to connect directly to OpenAI's API without any runtime dependencies.

Antigravity took a different path by choosing Node.js and also building its initial version without external dependencies. It was notably more ambitious in its interface design, creating two distinct ways to use the agent. It offered a terminal interface and a browser-based workbench that included a project file explorer and a live conversation feed.

The browser-based workbench for Antigravity included specific features like approval prompts and a panel for reviewing changes. It also provided the user with the ability to revert individual files or undo an entire session of changes. In contrast, the terminal versions for Claude Code and Codex remained strictly command-line based, focusing on different ways of interacting with the file system.

Integrating ChatGPT Pro

After the agents built their initial replacements, the author wanted to power them using a single subscription. The goal was to use an existing ChatGPT Pro account to avoid paying for separate API credits for each tool. The author gave both Codex and Antigravity a follow-up prompt to integrate OpenAI's Sign in with ChatGPT functionality.

Both agents successfully added the integration, though they handled the process differently. Codex spent a significant amount of time testing the authentication flow and managing potential errors during the build. Antigravity required some troubleshooting after the initial sign-in because it had selected an unsupported model, but it was eventually functional.

Once the authentication was settled, the author could test the agents using the same models under the hood. Because the underlying models were the same, the author did not focus on the quality of the generated code. Instead, the evaluation focused on how each agent handled the workflow of creating files, running commands, and recovering from errors.

Comparing user experience

The author ranked XDACode, the Claude Code replacement, as the best overall experience. It struck a balance by keeping the terminal clean while still providing enough information for the user to follow along. It used subtle indicators like "planning..." and displayed file changes in a neat summary box rather than printing every line of code.

XDAGravity took second place, praised for its use of color to distinguish between responses and progress updates. The author appreciated the inclusion of slash commands for switching models and reviewing changes. However, the author noted that the repeated "TASK SUCCEEDED" messages felt unnecessary for simple tasks, even if the interface was easy to navigate.

XDACodex was the least successful in terms of user experience, despite taking the longest time to build. It printed lengthy code diffs directly into the conversation, which cluttered the terminal and made it harder to read. It also displayed unverified warnings for simple greetings, making the tool feel rougher around the edges compared to the other two replacements.

Lessons from the build

The experiment revealed an interesting irony regarding the speed of development. Claude Code was the quickest to finish building its replacement, followed by Antigravity. Codex took the longest of the three to complete its version, yet it produced the result the author liked the least.

This suggests that the time an AI spends on a task does not always correlate with the quality of the final user experience. While Codex spent more time testing authentication and handling errors, the resulting interface was less intuitive for the user. The author found that the most effective tools were those that prioritized clear communication over raw data output.

Ultimately, the experiment shows that while AI can successfully replicate its own functionality, the nuances of user interface design remain a human priority. The differences in how the agents displayed information—whether through a visual workbench, a clean terminal summary, or a cluttered diff—were the deciding factors in the test. The author concluded that XDACode was the most comfortable tool to use for daily tasks.

Summary of results

The author's testing of these three self-built agents provided a clear hierarchy of usability. XDACode won for its clean terminal output and helpful status indicators. XDAGravity followed closely with its ambitious multi-platform interface. XDACodex came in last due to its cluttered output and unnecessary warnings.

These results highlight the importance of