Pair your devices. Sync your tasks.
With SOLO Mobile, you can connect your phone to desktop and web, choose where the work runs, and keep every task visible across screens.
Start on mobile. Let desktop do the heavy lifting.
Efficiency is about doing more at once. The latest SOLO Mobile update focuses on parallelism and remote execution.
You can now send tasks from the SOLO Mobile app directly to your devices or the Cloud. This allows you to maintain multiple active workflows across various environments—all controlled from a single interface.
Key Capabilities:
Maximize your hardware. Minimize your downtime.
>"Voice in. Work moving."
The biggest barrier to productivity isn't a lack of ideas—it's the friction of capturing them. Today, we're thrilled to introduce voice-input task creation in TRAE SOLO designed to keep your momentum at 100%.
Whether you're commuting, grabbing coffee, or mid-brainstorm, you can now move work forward without ever opening a keyboard.
Voice with SOLO Mobile today! Download here 👉 https://www.trae.ai/download
We are thrilled to announce a collaboration with PICOXR to introduce an AI-native XR development workflow. Say goodbye to workflow friction and hello to faster iteration!
What is TRAE Editor for Unity?
It’s a specialized integration built to bring TRAE’s AI coding capabilities directly into the Unity environment. We’re closing the gap between your IDE and your Game Engine.
The Highlights:
From idea → XR prototype, we’re making the loop tighter and smoother.
👉 Check out the full reveal here: https://developer.picoxr.com/document/unity-swan/trae-editor-for-unity/
Task does not wait for the moment you sit down at your desk. An idea hits while you're on the move. A task needs to be dispatched before the next meeting. A deliverable needs a quick review.
Today, TRAE SOLO Mobile goes live, alongside TRAE SOLO Desktop for Windows, and a fully open TRAE SOLO (Desktop, Web and Mobile) experience that no longer requires an invite code.
Starting now, the TRAE SOLO product suite is available to everyone, and the membership tiers (Free, Lite, Pro, Pro+, and Ultra) include different usage across the TRAE product suite.
>Think Anytime, Ship Everywhere!
TRAE SOLO Mobile brings the TRAE experience to your pocket. So you can keep work moving and coding flowing wherever you are. Think anytime, and ship everywhere.
TRAE SOLO Mobile supports Code Mode + MTC Mode to match different moments in your day.
Switch modes in seconds to stay efficient from planning to execution.
TRAE SOLO Mobile is designed for true multi-device continuity. Once you're paired, your work stays aligned everywhere, so you can start on one screen and finish on another without friction.
TRAE SOLO Mobile turns your phone into a lightweight dispatch console, so you can trigger real work on more powerful devices anytime, without losing control.
Great ideas don't wait for "work time." TRAE SOLO Mobile helps you capture, structure, and execute the moment inspiration strikes whether you're typing, talking, or thinking through something complex.
Privacy Mode is built for users who want clearer control over how their data is used, especially when working with sensitive prompts, code snippets, and AI outputs.
When Privacy Mode is enabled, TRAE SOLO will not use your chat interactions (including related code snippets and AI-generated outputs) for analytics, product improvement, or model training.
More details: https://docs.trae.ai/solo/privacy-mode
Developers, Data Analysts, Product Managers, Operations, Legal, Finance...
Picture a typical workday on the move: an urgent request arrives between meetings, a half-formed idea shows up during a commute, or a report needs to be ready before you get back to your desk.
TRAE SOLO Mobile fits into these moments by letting professionals start work instantly from chat or voice, then dispatch the heavy lifting to paired desktop and cloud endpoints, delivering real outputs back into their existing workflows.
Developers constantly need to keep work moving across devices, but the real heavy lifting like repo access, tooling, builds, deeper changes typically have to happen on Desktop (or a cloud endpoint), not on a phone.
TRAE SOLO Mobile bridges that gap by letting you remotely dispatch tasks from mobile and have them run on paired Desktop and Cloud.
You can trigger execution with the right project context, monitor progress in real time, and receive results back as concrete artifacts (e.g., code changes, test notes, docs) saved where your development workflow already lives.
Data analysts spend a significant amount of time doing hands-on, detail-heavy work like cleaning and transforming messy datasets, writing SQL, and assembling outputs into a report.
In practice, that workflow is usually tied to desktop tools, fixed environments, and specialized functions.
TRAE SOLO Mobile streamlines the process by letting analysts dispatch data tasks remotely to Desktop/Cloud, where SOLO can handle the heavy lifting and produce outputs that are ready to share, including narrative insights and visualization-ready materials.
It also supports parallel execution, so multiple analytical workstreams can run at the same time instead of waiting on a strict step-by-step sequence.
And because dispatch isn't location-dependent, analysts can request reports, work against authorized datasets, and keep deliverables moving even when they're away from the office computer.
PM work is often split between fast-moving conversations and the structured artifacts teams need to execute including PRDs, prototypes, plans, and clearly scoped tasks.
TRAE SOLO Mobile makes brainstorming a first-class workflow: you can talk through product ideas with SOLO in a natural, conversational way, then have SOLO summarize the discussion into a structured execution plan that's ready to share and iterate.
Beyond ideation, PMs also constantly plug in inputs (call takeaways, meeting notes, feedback threads, user research, survey results, and internal docs) from everywhere.
TRAE SOLO Mobile streamlines this by keeping all endpoints in sync: you can capture or create tasks on mobile, have them appear on Web/Desktop instantly, and dispatch follow-up work to the right paired device.
The result is a more unified workflow where scattered inputs turn into an actionable product development plan without manual copy‑pasting or reformatting across tools.
Ops teams need fast coordination and consistent outputs such as status updates, incident notes, and follow up actions, often while switching between many threads.
TRAE SOLO Mobile lets you dispatch tasks that reference authorized ops folders such as SOPs and templates, produce standardized artifacts, and save results back into the right operational directories for smoother tracking and handoff.
Ops also spend a lot of time away from a laptop for client meetings, community events, and onsite activities.
TRAE SOLO Mobile keeps work moving from anywhere by letting you initiate and monitor tasks on mobile while execution runs on paired desktop and cloud endpoints, with results delivered back into your existing workflow.
Legal teams often need to turn large volumes of sensitive materials into clear outputs such as key terms, obligations, risks, and next steps.
TRAE SOLO Mobile summarizes content, extracts structured checklists, and drafts internal notes using approved templates.
It can also help search and organize past cases and legal terms across massive document sets, so the manual review burden is reduced. When you need it fast, you can trigger the workflow from anywhere with a single voice command.
Finance teams need both accurate numbers and a credible story, often under tight timelines.
TRAE SOLO Mobile can help generate draft ready outputs such as variance commentary and executive summaries, grounded in authorized templates and prior materials.
It can also support more technical work by helping build complex valuation models and checking models for issues, so you can validate assumptions and catch potential bugs earlier.
Starting today, TRAE SOLO Desktop (macOS and Windows), Web, and Mobile are available to everyone.
If this sounded like your day, a message between meetings, a sudden request on the move, a task you do not want to wait until you are back at your desk to start, you can try it in a minute.
Download TRAE SOLO Desktop and TRAE SOLO Mobile and sign up for free.
Send your first task from mobile and let Desktop and Cloud handle the heavy lifting while you keep moving. When you want more usage and higher capacity, choose a plan that fits your workload.
Thanks for the wait! TRAE SOLO is now on Windows as well. Starting today, the full TRAE SOLO experience across Desktop, Web, and Mobile is available to everyone.
From brainstorm to build, wherever ideas happen.
Download here: https://www.trae.ai/?utm_source=onlinecommunity&utm_medium=reddit&utm_campaign=solo_mob_launch
Hey everyone,
We‘re excited to announce that TRAE SOLO Mobile is officially live on the App Store and Google Play!
We built SOLO Mobile for those "lightbulb moments" that happen when you're away from your desk. It’s not just a companion app—it’s a mobile dispatch console designed to keep your information flowing across all your endpoints.
Information flows, all endpoints in sync. We’d love for you to try it out and let us know what you think! We’ll be hanging out in the comments to answer any questions.
Get started here: https://www.trae.ai/?utm_source=onlinecommunity&utm_medium=reddit&utm_campaign=solo_mob_launch or download directly from the App Store and Google Play.
The TRAE SOLO skill marketplace offers a variety of skills for different use cases, covering data analysis, UI design, development tools, and more. You can directly install the required skills from the marketplace.
Here are 4 must-have skills for daily development. What's your go-to Skill for development?
| Author | GitHub |
|---|---|
| Overview | "git-commit" is a code commit assistant tool built upon the Conventional Commits specification. It can analyze code changes, automatically complete file grouping and staging, and generate structured commit messages. This skill incorporates strict Git security protocols and best practices to ensure that commit history is standardized and secure. |
| Use cases | Generate standardized commit messages Split and stage changes logically Securely execute the Git commit process When committing code, AI uses this skill to automatically analyze code differences (diff) in the staging area or working directory, identify the type of change (such as feat, fix, docs) and the scope, and generate commit messages compliant with the Conventional Commits specification. Commit descriptions must use present-tense imperative sentences and be no longer than 72 characters. When there are multiple changes in the workspace, this skill supports staging specific files by file path, wildcard, or interactive approach (git add -p), ensuring that each commit contains only one change. At the same time, this skill strictly follows security guidelines and will not add confidential files such as .env, credentials, or private keys to the commit list. When running git commit, this skill allows you to modify or overwrite the automatically generated type, scope, and description. It also strictly follows Git security protocols: Does not modify Git configuration. Does not execute destructive commands (such as --force or hard reset). By default, does not skip code check hooks (--no-verify). If hook validation fails, AI must fix the issues and recommit, rather than using git commit --amend to overwrite commit history. |
In the following example, the AI used the "git-commit" skill and sequentially executed the git status, git diff, git add, and git commit commands to quickly complete a commit.
| Author | Vercel |
|---|---|
| Overview | "react-best-practices" is a code quality review and performance optimization tool for React and Next.js projects, especially for TSX/JSX files. Its built-in rules are based on Vercel official best practices (8 categories, 64 rules, prioritized), covering component structure, Hooks conventions, a11y, TypeScript, and both server-side and client-side performance optimization. This skill is automatically triggered when writing, modifying, or refactoring components, then it performs code checks and provides optimization suggestions. |
| Use cases | Diagnose and address core performance bottlenecks Review UI architecture and port tech stack Optimize component rendering and state management For data requests and page loading, this skill focuses on addressing the following two CRITICAL-level issues: When traditional CSS-in-JS solutions (such as styled-components or u/emotion) or large component libraries (such as u/mui/material or u/chakra-ui/react) are detected, this skill will prompt you to port to modern tech stacks such as shadcn/ui + Tailwind CSS to improve server-side rendering performance and build efficiency. During component development and refactoring, this skill reviews code and provides optimization suggestions: Request waterfall: Use Promise.all and Suspense streaming rendering to optimize asynchronous dependencies in API routes. Bundle size: Avoid introducing redundant barrel files, use next/dynamic to dynamically load components, and defer the loading of third-party scripts to improve perceived page load speed. Server/client collaboration: Standardize the data serialization and caching mechanism of React Server Components (such as React.cache()), and optimize SWR request deduplication on the client side. Re-render control: Standardize the use of hooks, prioritize derived state, and avoid excessive use of useEffect; combine useTransition with caching strategies to reduce unnecessary re-renders. |
In the following case, the AI used the "react-best-practices" skill to optimize a TypeScript project. The results are as follows:
Agent's output with this skill used:
Detailed Examples:
Promise.all and added an active flag to prevent state updates if the component unmounts or dependencies change before the fetch completes.
useDeferredValue to keep the search input responsive instead of blocking the main thread, and hoisted the .toLowerCase() call out of the filter loop.
length && to length > 0 && to prevent React from rendering a 0 to the DOM when the array is empty.| Author | Anthropics |
|---|---|
| Overview | "webapp-testing" is a local web application testing toolkit based on Playwright. It supports frontend functionality verification, UI debugging, page screenshots, and browser console log collection, following a workflow of detection before execution. This skill provides examples and auxiliary scripts, covering static HTML automated testing, element location, log capture capabilities, and enables unified management of server lifecycles in multi-service structures. |
| Use cases | Verify frontend functionalities Debug and analyze UI behaviors Test multi-service applications Test static pages When developing web applications locally (such as React, Vue, Svelte), you can describe your testing requirements in natural language (for example, "test the login flow"), and AI will use this skill to automatically generate Playwright scripts, simulate user operations on web applications, and return the results. When you discover unexpected rendering or interaction logic of an element on the page, you can send instructions to AI (for example: "capture a full screenshot of the homepage" or "inspect the DOM structure of the button"), and AI will execute the corresponding script in this skill, capture the entire screen or retrieve the HTML content, and return its observations to help you locate the issue. To test front-end features in a decoupled front-end and back-end architecture where back-end API services must run concurrently, simply provide the project structure and startup commands to AI. AI will use the with_server.py script from this skill to start all required services simultaneously, then run the test scripts to ensure tests are executed in a complete environment. To validate the content or structure of a pure static HTML page that does not depend on a server, simply provide the file path and testing requirements to AI. AI will write a script and open the file in the browser using the file:// protocol, then perform automated validation. |
In the following case, the AI tested a website's login functionality. It used the "webapp-testing" skill and Playwright to write an automated test script (test_login.py), performing end-to-end testing of the login flow and outputting the results. During the process, the AI also identified and resolved instability in the login flow by removing history-dependent navigation and replacing derived authentication state with an explicit, reactive store property.
| Author | Vercel |
|---|---|
| Overview | "composition-patterns" is a code review and refactoring tool focused on React component composition patterns and architectural design. Its core objective is to address the problem of props bloat caused by accumulating logic during component iteration. By leveraging compound components, lifting state, and modern React APIs (including React 19), it helps build a highly flexible and maintainable component system. |
| Use cases | Refactor bloated components Design reusable component libraries Design flexible APIs Review component architecture and standardize state Adapt to React 19 API When a component contains too many branches, or when it is filled with numerous boolean props (such as isPrimary and hasIcon) and multiple layers of if-else statements, this skill can be used to refactor it. This skill assists in breaking down a complex component into multiple fine-grained subcomponents, replacing parameter expansion with composition, thereby reducing component complexity. When implementing general-purpose components such as Tabs, Modal, and Select, this skill uses compound components to design the API: state is managed internally (typically via Provider and Context), while control over structure is given to the user, allowing components to be freely composed rather than enforcing fixed usage patterns. To accommodate uncertain requirements and reserve sufficient internal extensibility for components, this skill can be used. It prioritizes using children to compose nodes, rather than introducing complex renderProps or numerous configuration options from the outset. This reduces internal component complexity and makes it easier to handle future changes. You can use this skill as a component design review tool for your team, evaluating the robustness of component architecture during code reviews. This skill enforces state decoupling, ensures state management is encapsulated within the Provider, and defines a standardized Context interface to guarantee clear and maintainable state flow in complex component trees. This skill can be used when refactoring components to accommodate new features in React 19. For example, it helps you remove redundant forwardRef wrappers and use the more flexible use() hook instead of the traditional useContext(), making component code align with the latest React. |
In the following case, the AI used the "composition-patterns" skill to optimize a TypeScript project. The results are as follows:
Agent's output with this skill used:
Code optimizations:
SmartCardProvider. This decouples state management from the UI, allowing sub-components (or even custom external components) to access and mutate the card's state via context without prop drilling.
hasImage, hasIcon) is replaced by explicit compound components. Consumers now explicitly compose what they want to render using children.
use(): Sub-components now cleanly access the parent provider's state using React 19's use() hook, grabbing exactly the pieces of state they need (e.g., the SelectIndicator controlling its own checkbox).