Commanding AI to Publish an App from Your Phone: 3 Practical Collaboration Tips

Completing an entire app's development and release from a mobile device once sounded like a fantasy, but Bilibili creator "Chao Chun" ran the whole process end-to-end using a single phone to command an AI Agent (Grokbot). The app itself isn't complex — what's truly valuable are the three reusable techniques he developed while collaborating with AI: requirement alignment, solution discussion, and release automation. These lessons are relevant to anyone who wants to use Agents to build products.

Tip 1: Use Visual Alignment Instead of Back-and-Forth Text

Requirement alignment is the most easily derailed part of AI collaboration. The creator breaks it into two layers: aligning with the user and aligning with the AI.

Aligning with the user: When a user poses a vague request like "Can a motion experiment test be developed?", direct text communication often makes things more confusing the longer you talk. The creator's approach is to have the Agent generate a concept-explanation video based on the chat log, complete with voiceover and dynamic visuals, then send it to the user for confirmation. According to his demo in the video, AI's ability to generate videos explaining concepts is already accurate enough — dynamic visuals plus voice narration eliminate misunderstandings better than plain text.

Aligning with the AI: Once requirements are clear, don't immediately ask the AI to write code. The creator's experience is to first have the Agent generate UI product mockups, visually confirming layout and missing pages at the sketch stage, iterating until a mid-fidelity design is reached before moving into development. This step blocks a large amount of rework before coding begins.

If the Agent you're using lacks image-generation capability (e.g., DeepSeek^Ad and Kimi can read images but can't generate them), the creator offers two alternatives: first, connect an image-generation API through a relay/proxy to make it callable as a skill; second, have the AI express interface structure using ASCII character art, which can also achieve preliminary alignment.

AI Agent refers to an AI system that can autonomously perceive its environment, reason and plan, and invoke tools to execute tasks. Unlike chatbots that can only converse, an Agent can operate a browser, read and write files, and call APIs, thereby independently completing complex multi-step tasks. Grokbot in this article is an Agent that can accept natural-language instructions and execute a development workflow. Understanding an Agent's tool-calling capability helps grasp why the creator emphasizes "giving the Agent handy tools" — an Agent's effectiveness depends heavily on the toolset and interfaces it can access.

UI product mockups and mid-fidelity designs: UI product mockups refer to interface visuals used to confirm layout, color scheme, and interaction logic before coding; mid-fidelity designs (medium-fidelity mockups) sit between low-fidelity wireframes and high-fidelity visuals — they already include the main page structure and key controls but aren't yet refined to pixel-level styling. In AI collaboration, producing a mid-fidelity draft first quickly validates the information architecture, avoiding large-scale rework from structural problems after jumping straight into coding.

Tip 2: Don't Discuss Solutions in Isolation

The creator stresses that the biggest taboo in the solution-discussion phase is a single-thread one-on-one conversation. His approach is to bring in a second large model as an "outsider" to join the discussion and fill information gaps.

In Grokbot, he uses a "group chat" approach so two Bots complement each other. According to the video, when Bot1 was about to jump straight into UI design, Bot2 proactively raised suggestions such as screen readability in outdoor sunlight scenarios, and Bot1 then continued working with reference to Bot2's proposals. This kind of cross-review exposes blind spots that a single model easily overlooks.

Regular Agent users can also use a side chat or open a new conversation to have another model read the discussion log and offer opinions.

Once the solution is set, the creator's second suggestion is not to reinvent the wheel. AI writes code fast, but there's no need to build the foundation from scratch. He has the AI first reference existing projects or benchmark solutions in open-source repositories, modifying based on a mature directory architecture and ready-made skills. In actual development, he has the AI first delete unneeded built-in features from the template, such as the login flow, and then write the business code — saving a lot of configuration work.

MCP (Model Context Protocol) is an open protocol proposed by Anthropic to standardize how large models connect to external tools and data sources. Through MCP, an Agent can safely call resources such as the file system, databases, and browsers without writing separate integration code for each tool. The article's suggestion to prioritize ready-made MCP or CLI tools is precisely about using this ecosystem to lower the barrier to Agent use, letting the Agent operate various backend systems in a "plug-and-play" manner.

Tip 3: Hand the Dirty Work to the Agent — and Give It Handier Tools

After app development is complete, filling out backend store listing materials (store images, promotional text, various forms) is typical tedious work. The creator's core mindset: never do by hand what can be handed to the Agent.

Make full use of the Agent's browser capability: After logging in to the account for the Agent, let it open the browser itself to read pages and fill in content. This approach is slower and consumes more tokens, because the Agent needs to read each page element and then analyze where to write. But the creator thinks this isn't worth worrying about — waiting time can be spent eating or writing other code, with efficiency losses offset by parallel processing.

Prioritize ready-made MCP or CLI tools: Taking Apple's App Store backend as an example, the creator used a command-line tool called asccli, which covers almost all backend operations — uploading beta builds, app release review, backend info filling, certificate signing, screenshot management, and more. He stresses again "don't reinvent the wheel" — the difficulties you encounter almost certainly have existing solutions in the open-source world.

asccli is a command-line tool for Apple App Store Connect that can script operations such as beta build uploads, review submissions, backend metadata filling, certificate and signing management, and screenshot uploads. Compared with having the Agent operate page by page through a browser, CLI tools execute faster, are more stable, and consume fewer tokens. It embodies the "tools first" principle: encapsulate repetitive backend operations as commands, and the Agent only needs to invoke the command with parameters, greatly improving release efficiency.

The Common Logic Behind the Three Tips

Looking back at these three tips, the underlying logic is consistent: treat the Agent as a collaborator who needs clear instructions and handy tools, not a wishing well.

• In the requirements phase, use videos and images to establish shared visual understanding and reduce "I thought you understood" deviations;
• In the discussion phase, bring in a second model for cross-validation and use open-source solutions to raise the starting point;
• In the execution phase, hand repetitive labor to the Agent's browser and CLI tools, with humans only handling login and decisions.

According to the creator's summary, first establish the mindset of "hand all the dirty work to AI," then equip the Agent with more efficient MCP or CLI tools, and collaboration efficiency will improve noticeably. This workflow doesn't depend on a specific application scenario and offers useful lessons for indie developers and product teams alike.

One-line Summary

A Bilibili creator commanded an AI Agent from a phone to develop and publish an app, distilling three reusable techniques: requirement alignment, solution discussion, and release automation.

Paragraph Summary

The article shares Bilibili creator "Chao Chun"'s experience using a single phone to command an AI Agent (Grokbot) through the entire app development and release process, distilling three reusable techniques: first, in the requirement-alignment phase, have AI generate concept videos and UI sketches to visually confirm goals with both users and AI, avoiding text-communication deviations; second, in solution discussion, bring in a second large model to cross-review from an outsider's perspective and use group chats so two Bots fill each other's information gaps, while prioritizing open-source solutions to avoid reinventing the wheel; third, in the release phase, fully leverage the Agent's browser capability to auto-fill backend forms and find ready-made MCP or CLI tools (like asccli) to replace manual operations. The common logic is to treat the Agent as a collaborator needing clear instructions and handy tools, not a wishing well.