Command Code Desktop Agent App (Fully Tested): It just costs $1 & Codex is not worth it ANYMORE!

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: Command Code Desktop Agent App (Fully Tested): It just costs $1 & Codex is not worth it ANYMORE! · Channel: AICodeKing · 10:55 · Watch on YouTube

Topics: AI agents, Software engineering with AI, AI developer tools, Markets and economy, AI models

Summary

The video reviews Command Code’s desktop coding-agent app as a potentially affordable alternative to higher-priced coding subscriptions, while clarifying that OpenAI and Claude also offer cheaper plans. The presenter tests DeepSeek V4 Flash on a dashboard task, refining the plan before building and independently checking the resulting behavior and 11 passing tests. The app includes project and diff review, a browser with visual element selection, and documented design workflows, though the demo encountered a local Node setup issue and required some steering. The presenter explains the Go and Goat plan pricing and limits, and recommends evaluating real usage rather than assuming the low starting price will suit every workload.

Key points

Command Code’s desktop app is available for macOS, Windows, and supported Linux systems, with the agent runtime included.
The interface brings projects, chat, files, changes, browser, plan, and terminal into one workspace.
The presenter used DeepSeek V4 Flash with max effort to add case-insensitive search, status filters, and an empty state to a task list.
The presenter revised the initial plan so clearing search would preserve the selected status, while Clear filters would reset everything.
The agent recovered from a test-command issue by retrying Node using an absolute path and corrected a missing all-statuses option.
All 11 tests passed, and the presenter manually checked search, combined filters, clearing behavior, and the narrow preview layout.
Design mode can pass a selected browser element’s context into chat; documentation also describes design checkup, design smell, and design deslop workflows.
The Go plan starts at $1 per month plus a processing fee and includes $10 in monthly credits; Goat is $10 per month plus a processing fee, with usage allowances and limits.
The presenter advises checking model-specific allowances and measuring usage across representative tasks before deciding whether the plans meet your needs.
The video presents Command Code as a possible budget alternative or companion tool, not a universal replacement for Codex or Claude.

Chapters

Start	Chapter	Summary
00:02	Introducing the desktop app and setting up a project	The presenter introduces Command Code as a lower-cost coding-agent option and explains the desktop installation, workspace, and model selection.
02:06	Planning and building the dashboard feature	The presenter asks the agent to plan search and status filters, refines its proposal, then builds and tests the feature while discussing tool-call repair.
05:42	Visual design tools and reviewing changes	The video demonstrates selecting interface elements in the browser, describes documented design commands, and shows how to inspect diffs and taste files.
07:45	Pricing, usage limits, and final assessment	The presenter outlines Go and Goat pricing and limits, recommends tracking actual usage, and weighs the app as a budget alternative rather than an automatic replacement.

Quotes

I just want a good coding agent without another massive monthly bill. — 00:02

You get a proper place to review the approach before it becomes code. — 03:09

After the implementation, all 11 tests passed. — 04:41

So, plan around your actual usage. — 08:47

But, I do think Command Code has a strong case as a budget alternative. — 09:50

Concepts and entities

Command Code, DeepSeek V4 Flash, GLM-5.2, Kimmy, Quinn, Codex, Claude Max 20X, tool call repair system, Taste, Go plan, goat

Full transcript (original language)

00:02 [music] >> Hi, welcome to another video. So, if you’ve been looking at the $200 plans from OpenAI and Claude and thinking, “I just want a good coding agent without another massive monthly bill.” Command Code now has a desktop app, and this is a pretty interesting option. I’ve covered Command Code on the channel before, including their $1 Go Plan and the 10 Go Plan. But, having that agent inside a proper visual workspace makes the whole thing much easier to show and much easier to get started with. You can work on your project, inspect

00:33 the code, and see what you’re building. And you can choose from models like DeepSeek, GLM, Kimmy, and Quinn while keeping the monthly starting cost extremely low. So, I opened the app and gave DeepSeek V4 Flash a small dashboard feature to build. It finished with 11 passing tests, and I checked the search and filtering myself inside its browser. There were a few rough edges along the way, which I’ll show you, too. Let’s walk through that workflow and talk about where this could make sense as an alternative to those expensive subscriptions. So, let’s get right into it. First, a quick clarification on the comparison. The $200 options I’m talking about are

01:04 ChatGPT Pro’s higher tier, which includes Codex, and Claude Max 20X. Both companies also have cheaper plans, including $20 options. So, you don’t need to spend $200 just to use their coding tools. But, if you’re considering that upgrade mainly to get more coding done, I think it’s worth looking at how much of your work a cheaper setup could handle first. Now, to install Command Code, go to their desktop page. They have downloads for macOS, Windows, and Linux. On a Mac, download the DMG, open it, and move the app into applications. On Windows, follow the setup installer.

01:35 And on supported Linux systems, use the package for your distribution. The agent runtime is included, so you don’t need to separately install their CLI before using the desktop app. That’s a nice improvement for anyone who wasn’t interested in setting up another terminal tool. I’m using the installed app here, already signed in. To add the demo, I opened the add project menu, selected open folder, and chose a small disposable project. That’s the flow in the build I’m using. The layout is pretty straightforward. Your projects and chats live on the left, the conversation is in the middle, and the

02:06 workbench sits on the right. Open a view gives you files, changes, browser, and plan. Terminal opens as a drawer underneath the chat, so you can keep your server running while reviewing the page. For this walk-through, let’s use a small dashboard project and add search and filtering to a list of tasks. Something practical that gives us a bit of interface work and a bit of application logic. First, open the model picker in the composer. The models are grouped by provider, and there are search and favorite controls. For this test, I used DeepSeek v4 flash with max effort. Its picker also showed default

02:37 and high, so you can adjust that from the interface. Now, switch into plan mode and give it the request. I’ll say, “Inspect this project and plan how to add search and status filters to the task list. Reuse the existing components and styling. Search should ignore capitalization, and it should work together with the status filter. Include an empty state when nothing matches, and explain how you’ll test it.” This is the kind of prompt I like, because it gives the agent a clear finish line. A search box that looks good but doesn’t work with the filter would still be an incomplete feature. The agent read the project and opened its proposal in the plan panel. There

03:09 are buttons for accept and build, keep refining, and build without asking. And this is where I actually used keep refining. The first plan had the substring comparison written in the wrong direction, and one paragraph was unclear about clearing filters. I wanted clearing the search to preserve the selected status, and only the clear filters button to reset everything. So, I sent that feedback through the review panel. It revised the plan, opened version two, and highlighted what changed. That’s pretty cool. You get a proper place to review the approach before it becomes code. Then I

03:39 chose accept and build. That returned the chat to ask for approval, and I approved the changes to the demo files as it worked. The activity feed showed the edits and commands, so I could follow what was happening. Now, while that’s running, let’s talk about why the agent around the model matters. A coding model has to do more than write a convincing answer. It needs to request the right files, make usable edits, understand command output, and keep working when something goes wrong. Command code has published details about its tool call repair system. Their approach is to validate the arguments a model sends to a tool and repair certain malformed calls when

04:11 validation fails. Valid calls are left alone. That might sound like a boring implementation detail, but think about what happens when an agent has the right idea and formats a tool request incorrectly. Recovering from that can keep a useful task moving. This is one reason I’m interested in these smaller coding tools. There’s room to make affordable models more useful through the software around them. I’d still judge the combination on a real project, but the engineering approach makes sense. Okay, now let’s look at what actually happened during

04:41 the build. The first test command couldn’t find node in the agent’s shell. It looked for an installed version and retried with an absolute path. So, having a desktop app doesn’t remove every local environment issue, but it did recover from this one. It also noticed that it had forgotten the all statuses option and corrected that itself. After the implementation, all 11 tests passed. I checked those independently as well. Now, the agent didn’t have its browser automation tool installed, so I did the interactive checks in the app’s browser panel myself. I started the local server in its

05:12 terminal drawer and opened the local address. Typing draft in capitals returned just draft onboarding guide. Combining that with in progress gave me the empty state. Clearing the search kept the status selected and brought back the two in progress tasks. Then, clear filters restored all six. The controls also stack neatly in the narrow preview panel. So, for this small task, the result worked. It needed a little steering, but we ended up with working behavior, tests, and a diff I could review in the same app. That’s quite good to see. Now, here’s the part of the desktop app that I think is

05:42 especially cool. Open the local development page in browser, then turn on design mode. You can select an element in the preview and send that element’s context into the chat. I selected the search field and the app attached the element context to the chat composer. So, you can point at the control you mean and then ask for something specific, like making its active state clearer. Being able to point at the exact part of the interface is useful. You don’t have to explain which of three similar containers you’re talking about or start hunting for a component name before giving feedback. There’s also a separate design command workflow in their documentation. I

06:13 haven’t run that part in this demo, but {slash} design checkup asks for a broader assessment of the interface. Command Code’s design workflow can generate reports you can review. You can also use {slash} design smell for a report on repetitive or generic design choices, then {slash} design deslop when you actually want it to make changes. I’d give that a narrow scope. For example, improve the task list’s spacing and hierarchy while keeping the existing colors, navigation, and functionality. That gives you a useful second pass without turning a small dashboard

06:43 improvement into a complete redesign. And having both the visual selection workflow and a design review command gives you a couple of ways to work, depending on how specific your feedback is. Now, another reason to look at Command Code is taste. The idea is that it learns from the code you accept, reject, and edit, then uses those signals to build up preferences for your projects. So, the team is trying to reduce how often you have to repeat the same instructions. Say you keep asking the agent to reuse your existing components or you prefer a particular way of organizing tests.

07:13 Seeing preferences get recorded is encouraging. Finding out whether they improve the next task takes more use. Before wrapping up, open changes and inspect the files. In this build, I saw inline and side-by-side diff options and a commit menu. The review included the taste files as well as the feature changes. So, look through the whole list. I left this demo uncommitted. Okay, now let’s come to the pricing because this is where the setup gets really interesting. The Go plan starts at $1 a month plus a processing fee and includes $10 in monthly credits. That

07:45 makes it a very accessible way to try the agent with the supported budget models. Then there’s goat at $10 a month plus the processing fee, advertised with up to $70 of usage through its model allowances. Personally, that’s the tier I’d investigate if I like the app and wanted to use it more regularly. The important detail is that those allowances draw from one shared plan. You don’t get a separate full budget to spend on every model. For example, the current goat table lists $70 of usage for GLM 5.2 and $60 for DeepSeek v4 flash. Some other models have smaller

08:17 allowances. So, check the table for the models you actually want to use because the headline number won’t describe every combination. There are also limits within the month. Goat has a three credit limit per 5 hours and six per week. Goat has 14 per 5 hours and 35 per week with the model allowances determining how much usage those credits buy. Extra credits are available at model cost and those purchased top-ups roll over and don’t expire. The included monthly budget refreshes each billing cycle. So, plan around your actual usage.

08:47 Those big request estimates on the website are estimates of model requests and one coding task can involve many requests. My account already had credits available. So, this demo doesn’t measure how much work fits inside the $1 plan. I would check the usage page in studio after a few representative tasks. Try a small fix, a feature like this one, and something more involved. Look at the spend and how much manual correction each task needed. If the 10/10 plan handles your workload, the base subscription difference against a $200 plan is $190 a month before fees

09:20 and any extra usage. For a student or someone working on side projects, that is a pretty meaningful difference and you still have the option to change models. You could start routine work with DeepSeek flash, then try GLM or Kimmy on a task that needs another attempt. Just check the allowance for that choice before assuming it’ll cost the same. Now, would I say everyone should cancel Codex or Claude and switch immediately? No. If you depend on a particular model and it consistently gets your hardest work done, that can easily justify a more expensive subscription and a low monthly price

09:50 doesn’t automatically tell you how reliable the agent will be on your codebase. But, I do think Command Code has a strong case as a budget alternative. The starting price makes it easy to try. The model choice gives you flexibility and the desktop workflow makes it much more approachable. For me, the interesting possibility is using a cheap agent for a large chunk of everyday development and deciding how much premium access I actually need after that. You might find it covers your personal projects. You might use it alongside another tool. On this small test, it got the feature working, recovered from a setup issue, and gave me a useful review

10:20 workflow. That makes it a much more interesting budget option to me, even with the alpha issues. I’ll leave the desktop download, documentation, and pricing links in the description so you can check it out. Overall, it’s pretty cool. Anyway, let me know your thoughts in the comments. If you like [music] this video, consider donating through the Super Thanks option or becoming a member by clicking the join button. Also, [music] give this video a thumbs up and subscribe to my channel. I’ll see you in the next one. Until then, bye.

10:55 >> [music]