The 13 Cloud Code Tips Used Daily by the Tool’s Creator

In the realm of AI-assisted programming, Cloud Code has established itself as a revolutionary tool. But an intriguing question arises: how does the tool’s creator, Boris, actually use it in his day-to-day work? If anyone knows the limits and maximum capabilities of a piece of software, it is its principal developer. Boris, the architect behind Cloud Code, recently shared 13 essential tips, revealing a workflow of extremely high productivity and security that transcends the basic usage of the tool.

Boris’s tips are not just tricks; they are software engineering strategies that allow for managing complexity, ensuring quality, and automating repetitive tasks, elevating Cloud Code usage to a professional level. Let’s delve into the tactics the creator himself employs to extract the maximum potential from his invention.

Section 1: Managing Environments and Scale

Tip 1: Running Multiple Local Instances in Parallel

Boris’s first tip sets the tone for a highly parallel and efficient working environment. He reveals that he runs up to five local Cloud Code instances simultaneously. This is not common practice for the casual developer but is crucial for those dealing with large codebases or multifaceted tasks.

Why run five instances?

Separation of Concerns: Each instance can be dedicated to a specific task. One might focus on integration testing, another on developing a new backend feature, and a third on refactoring legacy code.
Non-Conflicting Tasks: In modular codebases, it is possible to work on different areas that will not cause immediate conflicts, allowing Cloud Code to work in parallel without interruption.
Visual Organization: Boris numbers each terminal (1, 2, 3, 4, 5) to maintain clarity about which process is underway in each session.

Furthermore, he activates system notifications to know exactly when each development or testing process is completed, minimizing waiting time and maximizing focus.

Tip 2: Hybrid Ecosystem: Local and Cloud Simultaneously

Boris’s strategy goes beyond the local environment. He not only runs five local instances but also uses five to ten instances on the web platform (cloud.ai) of Cloud Code. This means he can be managing up to 15 AI-assisted development sessions at the same time.

This hybrid approach allows for “teleporting” Cloud Code sessions, ensuring that work can be started on his desktop, monitored in the cloud, and, in some cases, even managed through the iOS application.

The ability to initiate tasks from his phone, for example, is a testament to the flexibility of the Cloud Code ecosystem, allowing work to continue even when he is away from the computer. This ubiquity is essential for maintaining high speed in complex projects.

Section 2: Maximizing AI Performance

Tip 3: The Power of Opus 4.5 with Thinking Mode

When it comes to language models, Boris has a strong preference: he uses Opus 4.5 for absolutely everything, always activated in thinking mode.

Although the Sonnet model might be faster and smaller, Boris argues that Opus 4.5 is the best code model he has ever used. The secret lies in the quality and objectivity of the results. The thinking mode forces the AI to detail its reasoning steps before generating the final code. This results in:

More Accurate Results: The generated code is less prone to hallucinations or conceptual errors.
Better Tool Usage: Opus is superior at integrating and utilizing the tools available within the Cloud Code environment.
Effective Speed: Even though it is slower in initial generation, the reduced need for manual revisions and corrections ultimately makes Opus faster.

Section 3: Collaboration and Centralized Documentation

Tip 4: Sharing the Cloud.md File Across the Repository

The cloud.md file acts as Cloud Code’s persistent memory. Boris’s team adopts a unique collaboration strategy: they maintain a single, centralized cloud.md at the root of the repository, rather than multiple files scattered across folders.

This file is versioned via Git and allows the entire team to contribute to the AI’s memory. If anyone notices that Cloud Code acted incorrectly or made a specific mistake, that information is added to cloud.md. The benefit is twofold:

The AI learns what should not be repeated.
A centralized repository of AI behavior knowledge and corrections is created for the entire team.

While other teams might maintain their own specific cloud.md files, the approach of a single general file for the main repository simplifies maintenance and ensures crucial knowledge is universally shared.

Tip 5: Automating Documentation During Code Review

Maintaining the AI’s memory (cloud.md) is facilitated by automation. During code reviews, Boris and his team use the Cloud Code GitHub action.

When making a comment in a pull request, they simply tag @Cloud to initiate a task. This automated task adds the necessary changes to the cloud.md file.

This technique eliminates the friction of asking the PR author to manually update the AI documentation. Cloud Code itself takes charge of committing the change to the documentation, ensuring the memory is updated immediately without overburdening the developer.

Section 4: Strategic Workflow Execution

Tip 6: The Planning Cycle (Shift Tab Twice)

For most coding sessions, Boris starts in planning mode (activated with Shift + Tab twice). He emphasizes that a good plan is the key to “one-shot” success.

The process is iterative: he plans, reviews the plan, and repeats until the plan is perfectly aligned with the objective. Only when the plan is flawless does he switch to autoaccept edits mode. With solid planning, Cloud Code is capable of generating the complete and correct code in a single go, saving time on review and debugging. This mirrors the principle of Spec-Driven Development, where the specification (the plan) is more important than raw execution.

Tip 7: Creating Shortcuts with Custom Slash Commands

For repetitive tasks he performs dozens of times a day, Boris creates personalized slash commands. These commands are saved in .cloud/commands and are versioned, allowing the entire team to use them.

A notable example is the /commit push pr command. What makes this command fast and efficient is the use of inline bash to pre-compute information like git status. This pre-computation ensures the command runs quickly, avoiding long cycles of interaction with the AI model. This transforms complex Git tasks into single-command operations, saving valuable time.

Tip 8: Complex Automation with Subagents

Beyond simple commands, Boris regularly uses subagents – specialized modular entities for specific tasks. He mentions two examples:

Code Simplifier: Simplifies and refactors the code after Cloud Code has finished the initial work, ensuring the final result is clean and concise.
Verify App: Contains detailed instructions for Cloud Code to test the application end-to-end, guaranteeing functionality.

Subagents function as an automation layer for the most common workflows, allowing the developer to invoke specialists for specific tasks without having to rewrite detailed instructions repeatedly. They are essential for maintaining consistency and quality at scale.

Section 5: Quality Assurance and Security

Tip 9: Post-Use Hook for Consistent Formatting

Although Cloud Code usually generates well-formatted code, there is always a small margin (the “last 10%”) where inconsistencies can occur. To ensure the code arriving at Continuous Integration (CI) is impeccable, the team uses a post-use hook.

This hook runs automatically after a coding task is completed by Cloud Code, ensuring that all formatting rules are deterministically applied. This prevents formatting errors that could break the CI pipeline later on.

It is an extra layer of protection that ensures the AI’s work integrates seamlessly with the team’s code standards.

Tip 10: Avoiding “YOLO Mode” and Configuring Permissions

Many users, due to laziness or haste, use the dangerously skip permissions option, the famous “YOLO mode” (You Only Live Once), which grants all permissions to Cloud Code. Boris strongly advises against this practice.

Instead, he uses the /permissions command to pre-allow common commands used routinely. Most of these permissions are configured and shared with the team through the cloud-settings.json file in the repository.

Advantages of Permission Configuration:

Increased Security: Restricts what the AI can do, limiting the potential for destructive commands.
Reduced Hallucinations: By limiting the scope of action, you reduce the chance of the AI attempting operations outside its domain, resulting in fewer hallucinations and more focused responses.
Persistence: Configurations are persisted in the repository, facilitating the onboarding of new team members.

Section 6: Advanced Integration and Long-Duration Tasks

Tip 11: Integration with External Tools (Slack, Sentry, BigQuery)

Boris’s Cloud Code does not live in isolation; it is an integration agent. It has access to all the tools he uses daily, from communication platforms (Slack) to monitoring systems (Sentry) and data analysis (BigQuery).

This allows Cloud Code to perform complex, context-aware tasks, such as:

Searching and posting to Slack (via the MCP server).
Running complex queries on BigQuery to answer analytical questions.
Grabbing error logs directly from Sentry.

This direct integration is invaluable for production debugging workflows. If a bug occurs, Cloud Code can immediately access Sentry data, correlate it with the codebase, and suggest a fix, all within the development environment.

Tip 12: Managing Long Running Tasks

For tasks that take a very long time (such as massive refactors or extensive testing), Boris uses strategies to avoid session blockages:

Verification with Background Agent: He prompts Cloud Code to verify the work with a background agent, which reports when the task is complete.
Deterministic Agent Hook: He uses agent hooks to ensure the task continues deterministically and predictably.
Plugins and Sandbox Mode: He uses plugins like Half-Wigan (though niche), often in sandbox mode, and with pre-configured permissions (don't ask or danger skip permissions only in the sandbox). Sandbox mode isolates the task, allowing Cloud Code to “cook” without being blocked by permission prompts, ensuring the process is uninterrupted.

Section 7: The Golden Rule for Excellent Results

Tip 13: Feedback Loops – Enable Cloud Code to Verify Its Own Work

Boris states that this is probably the most important tip for achieving excellent results. You must give Cloud Code a way to verify its own work. This creates feedback loops that improve the quality of the final result by two to three times.

Instead of accepting the code outright, the developer instructs Cloud Code to test it. Cloud Code is capable of running Bash commands, executing test suites, and even interacting with the UI through the Cloud Chrome extension, opening the browser and simulating the user experience until the functionality “looks and feels good.”

Verification can be as simple as running a unit test command or as complex as testing a full user flow in a phone simulator. The time investment in creating these solid feedback instructions is what guarantees the robustness and quality of the AI-generated code.

Conclusion: Adopting the Creator’s Workflow

Boris’s 13 tips demonstrate that Cloud Code is much more than an autocomplete tool; it is a software engineering assistant that, when configured correctly, can operate at scale, ensure security, and automate complex development cycles.

By adopting the use of multiple instances, rigorous planning (Tip 6), automation via slash commands and subagents, and, crucially, incorporating feedback loops (Tip 13), developers can transform their productivity. The key is to treat Cloud Code not just as a code generator, but as a teammate who needs shared memory (cloud.md) and clear instructions to verify the quality of its own work. Implementing these strategies is the path to mastering AI-assisted development at the highest level.