Tencent CloudBase

The Core Problem in CloudBase Full-Stack Development

When building applications with Tencent CloudBase, developers frequently encounter a critical challenge: making correct technical decisions and integrations across a complex technology stack and multiple backend services. Specific scenarios include:

• Routing Confusion: Unsure of which documentation to consult or which API set to use when faced with web authentication, WeChat mini-programs, relational databases, cloud functions, CloudRun, and AI model calls.
• Incorrect Integration Sequence: For example, attempting to write frontend authentication UI code before configuring the necessary backend authentication providers, causing workflow disruptions.
• Toolchain Ambiguity: Unclear whether to prioritize MCP tools, the tcb CLI, or other SDKs within a given session, and how they relate to each other in terms of dependencies and fallback strategies.
• Violation of Implicit Rules: Such as incorrectly using the hosting update endpoint for a project's first deployment instead of the dedicated application creation workflow.

How This Skill Works: A Structured Guide with Enforced Rules

This skill (@tencent-adm/cloudbase) is not a collection of simple code snippets but a highly structured development decision framework. It addresses the above issues through these core mechanisms:

1. Scenario-Based Routing Table: It provides a detailed table mapping common development needs (e.g., "Web Login", "Cloud Functions", "AI Model Call") to specific child skill documents (e.g., auth-web-cloudbase, cloud-functions, ai-model-web) that must be read first. This forces developers to acquire the correct context before coding.

2. Mandatory Workflow and Pre-requisites: It defines non-skippable stages. For instance, Stage 2a must precede frontend code (typically involving backend resource preparation), and certain steps are mandatory. This ensures development follows a secure and correct sequence.

3. Global Rules and Engineering Constitution: It establishes foundational rules that override convenience, such as:

   • Always specify EnvId explicitly, prohibiting reliance on implicit or CLI-selected environment states.
   • Prepare backend resources before writing frontend code. Prioritize using MCP tools for auth providers, tables, storage domains, and security rules.
   • Prohibit the use of any to bypass type errors.
   • Self-verify before claiming completion, using both static checks (tsc, lint) and runtime verification (agent-browser for user-visible flows).

4. Clear Toolchain Fallback Strategies: It specifies how to proceed using the tcb CLI and local reference files when preferred tools (like MCP) are unavailable, preventing development stalls.

Applicable Boundaries and Key Caveats

While the skill provides comprehensive guidance, developers must be aware of its scope and several key points:

• Focused on the CloudBase Ecosystem: Its routing and rules are tightly coupled with Tencent CloudBase services (e.g., cloud functions, CloudRun, relational databases, document databases) and integration patterns (e.g., WeChat mini-programs, Web SDK, OpenAPI).

• Special Case for Frontend Deployment: For the first deployment of a Web frontend project, you must use manageApps(action="createApp", ...). Subsequent updates can use manageHosting. This is a common pitfall.

• Prerequisite Checks for AI Model Calls: Before invoking large model APIs, you must run DescribeEnvPostpayPackage (to check Token Credits packages) and DescribeActivityInfo (to check WeChat Mini Program Growth Plan eligibility). Omitting this will likely cause call failures.

• Strict Technology Stack Differentiation: You must carefully distinguish the CloudBase PostgreSQL path (using app.rdb(), queryPgDatabase) from the traditional NoSQL/MySQL paths. Confusing these leads to fundamental errors in permission models and SDK usage.