Gemini CLI vs. Cloud Code: A Head-to-Head Showdown for AI-Powered Development

Hello everyone. I have a very exciting article planned out for today. We're going to be running PRPs in parallel in both Gemini CLI and Cloud Code in separate work trees, really testing out what Gemini is capable of in PRPs here. I haven't run a lot of PRPs with Gemini, so it's going to be a live experiment to see what it can do. Many readers have been asking about PRPs in general and how to run them in tools like Cursor or other IDEs. This article will demonstrate that it is possible, but I'm also here to highlight the differences and the power of Cloud Code. My prediction is that Cloud Code might perform better than Gemini CLI, but it's going to be interesting to see.

First of all, I just want to say thank you to everyone who has been following this publication. The incredible feedback I've been receiving for my articles and the PRP framework has been amazing. I've had over 15+ people messaging me with some amazing projects they have built using PRP. They've been building custom UIs and automation scripts for generating PRPs, and I'm just amazed to see how many of you have embraced the framework and are building some really cool stuff with it.

The Starting Point: A Scaffolded Astro Project

Let's go over the starting point. The project has been scaffolded as an Astro component library. All components are built in Astro or pure, clean TypeScript, with no hydration, React, or similar frameworks involved. Everything is built using .astro files.

A theme switcher for dark and light modes is already implemented. Colors, typography, and icons are pre-configured. This provides a solid foundation for the AI agents. We have some pre-built button components with neat class effects, which were built quickly using a couple of PRPs. We'll use this as a base for all other components.

Pro Tip: When starting with PRPs, it's highly recommended to begin with a scaffolded project rather than a completely empty one. You'll get much better results.

The Master Plan

The plan is to build a premium, award-winning Astro theme with a rich set of components that mirror the existing button component, inspired by top themes on the Astro build themes marketplace, where paid themes can be quite expensive. The idea is to create a reusable theme for our Astro-based front-end projects. If successful, this will become the foundational theme for my company's website.

Core Requirements

• A minimum of two pages: a components page showcasing all component variants and a home page.
• Build all necessary atoms, molecules, and organisms for a premium theme.
• The home page should showcase the components in a neat, well-designed layout.

Defining the 'Why': Impact and Target Audience

Before starting, it's crucial to define the strategy, brand personality, accessibility standards, and target audience. Our target audience includes SaaS founders, agency developers, and full-stack developers who may not specialize in front-end development.

We have set up two separate work trees, one for Cloud Code and one for Gemini. The component structure is organized into atoms, molecules, and organisms folders. Currently, only an extensive button component exists. It will be interesting to see how both AI agents handle this existing structure.

Tooling Setup: Gemini vs. Cloud Code

A key difference is that Gemini CLI doesn't support slash commands in the same way Cloud Code does. * Cloud Code: Slash commands are defined and used directly. * Gemini CLI: The commands are placed in a template and run as prompts, passing the plan file path directly.

This shows how easily PRPs can be integrated into various development tools. While you could paste the plan content directly, using the file path is more efficient.

Kicking Off the Experiment

We have both tools ready to go. We're running Gemini in 'yolo' mode and Cloud Code with 'danger script' permissions to avoid babysitting them. We've also provided each agent with a markdown file containing Astro best practices.

Getting Gemini started was a bit messy; I had to explicitly tell it to execute the instructions in the file. Cloud Code was much simpler to kick off with a prp create command. With both setups ready, I kicked them off simultaneously and started a timer.

An Early Stumble from Gemini

Gemini initially asked if it should create a PRP for just a single component (navigation). I instructed it to generate the PRP for the entire plan. It issued another warning, recommending an iterative approach. After insisting on the full plan, it finally complied and began its work. Meanwhile, Cloud Code was already processing the instructions without any complaints.

Gemini's Plan: A Quick Turnaround

Gemini finished its plan in about 5-7 minutes. Its suggestion to work iteratively is valid; for maximum reliability, a component-by-component approach is often better. However, that wasn't the goal of this test.

Let's analyze the plan Gemini generated. It seems to have done a pretty good job understanding the task. It correctly identified the need for adherence to existing codebase conventions and referenced the existing button component, which is perfect. However, it missed a guide I provided on how to register new components.

Note on PRPs: A generated PRP is never perfect. You must review and edit it to match your exact requirements. For this test, I'm letting it run as-is to compare its raw output against Cloud Code's.

A slight concern is that the plan doesn't seem to fully respect the existing project structure. The task section, however, is the most critical part, and the tasks themselves look very promising. It correctly planned to mirror the existing structure for new components, and the instructions to follow the pattern from the button component are exactly what's needed. I'm genuinely impressed with what Gemini has produced here.

The repetitive nature of the tasks makes them highly reproducible. This means you could easily adopt Gemini's suggestion: create one PRP per component. You could then execute all eight tasks in parallel across eight work trees for maximum efficiency. This method is incredibly effective for repetitive tasks.

The Validation Loop

It's critical to ensure the validation steps won't cause the process to hang. Since I don't have a unit test setup, I'm removing that step to avoid unnecessary failures. I'll do the same for the Cloud Code plan if it includes one.

The Philosophy of Just-in-Time Context

While Gemini finished its plan quickly, Cloud Code was still deep in research. However, more research doesn't always guarantee better execution. The trickiest part of the PRP framework is providing just-in-time context. You must avoid flooding the context window with unnecessary information, providing only what's needed for the current task.

A longer PRP isn't necessarily a better one. The quality of task splitting is far more important than the length of the plan. A concern here is that building a single component is still a large task. Ideally, PRPs should define self-contained tasks that don't interact, allowing for parallel execution.

Cloud Code's Plan: Slow and Steady

Cloud Code's plan took nearly 30 minutes to generate but included a confidence score, which Gemini's did not. The purpose seems better captured by Cloud Code, as it stripped out unnecessary introductory text. Interestingly, it seems to have missed some requirements, like the footer, and only lists six new components.

A fascinating feature: Cloud Code created its own documentation on how to use Astro patterns and CSS glassmorphism. This is a great time-saver, as it automates a manual research step. Unlike Gemini, Cloud Code's plan includes numerous external URL references for context. Strangely, it also ignored the pre-made guide file.

It broke the work down into 12 tasks, compared to Gemini's eight. The quality and quantity of validation gates are crucial for success. The beauty of this system is that the AI will retry a task upon failure until it succeeds. This retry mechanism is the core of its agentic behavior.

Kicking Off the Execution Phase

Crucial Step: Before execution, you must clear the context window. The PRP itself contains all the necessary context for the execution agent. Running execute in the same session would overfeed the agent, likely leading to hallucinations. The correct procedure is to exit and start a new session. Now, we can kick off the execution for both agents.

Mid-Execution Update: An Interesting Observation

After about 30 minutes, Cloud Code is nearing its context window limit and will begin compacting soon. It's currently in the error-fixing and validation stage. What's truly interesting is that Gemini is still running. In a single, uninterrupted prompt, it has consumed over 60% of its one million token context window. It appears Gemini did more 'doing' and less 'researching' upfront, diving straight into coding. Cloud Code's approach involved more extensive, parallelized research upfront before moving to implementation.

The Results Are In: Gemini's Output

Let's examine what Gemini created in about 30 minutes. The buttons were pre-existing. It generated some neat-looking cards and pricing plans. Unfortunately, it removed the theme toggle, so we can't view the dark mode. The contrast isn't great, with elements blending into the background. While visually pleasant, the accessibility is poor. It also failed to register all the new components on the components showcase page.

This is a good reminder that a PRP rarely yields a perfect result on the first pass; follow-up is usually required.

A very strange and disappointing behavior was that Gemini altered the core project setup. It removed the predefined colors and typography files. It also renamed and removed several directories, completely disregarding the initial structure it was supposed to mirror.

After some follow-up prompts to fix the issues, the result looks neat, and the colors are pleasant. However, there are some odd glass effects, and the elements could stand out more. Ultimately, the result is nowhere near as comprehensive as Cloud Code's. It's a basic implementation. I am, however, super impressed that the agent is still running, trying to fix issues on its own.

The Results Are In: Cloud Code's Output

Cloud Code produced a significantly more feature-rich result. The theme switcher works, and the background effect is quite cool. It would have been better if it had integrated the theme toggle into the navigation bar, but the contrast issues are minor and could be fixed with a simple follow-up prompt.

The design is super neat, and it even correctly linked to my GitHub. The pricing page is well-designed, despite a minor misalignment and a 'Most Popular' badge not rendering correctly. But overall, the aesthetic is beautiful. The components have much better visual separation than the Gemini version. The contact form is nice, though again, the colors could be improved.

Component Showcase Analysis

It correctly left the existing setup untouched, following instructions perfectly. It created badges in all specified sizes. While the card showcase is minimal, the pricing page demonstrates their use effectively. It generated numerous options for surface effects, navigation, and hero sections. The variety of navigation options means we can easily swap them out to improve the main page.

I'm very impressed. The output is extensive. It's amazing what was created in a single, un-edited PRP run. In a real-world scenario, we would have refined the PRP first, which would have yielded even better results.

Final Thoughts: Agentic Behavior and a Clear Winner

A key goal was to see if Gemini could be as agentic as Cloud Code. In some ways, yes. It ran for a long time and attempted to self-correct. It's also important to remember this was running on the Flash model, not the Pro model, due to hitting rate limits. I'm excited to retry this experiment on the Pro model.

But for this round, there is a pretty clear winner. I'm incredibly impressed with what Cloud Code created. The Cloud Code homepage looks great in both light and dark modes. This is the exact style I envision for my company's website, and I will definitely be using this as a starting point.