>CC, Product Manager at TRAE

Continued from Part I

Step 3: Use mock flows to show the dynamic experience

Once the demo structure was ready, I realized a static demo could not explain the full user experience. Some features are not just interfaces. They are workflows. For example, I wanted to show my teammates one product idea: Users should be able to manage automated tasks through conversation. They can create, edit, and check tasks without leaving the chat flow.

Written out, that idea sounds abstract. A screenshot does not make it much clearer. What people need to see is the sequence: A user sends a message -> TRAE SOLO replies. -> A task card appears inside the conversation. -> The task is created or updated in real time.

But making the whole thing actually work would require server APIs, model calls, and state management logic. This was only a frontend demo. Building the full backend stack was not the point. So we used a mock flow to “play” the experience.

3.1 Turn the conversation into a playable animation

I told TRAE SOLO to add a Demo Mode button above the chat area. When clicked, the conversation would play automatically:

The user text box appears:

• "Remind me to write in my journal every day."
• After a one-second pause, the TRAE SOLO text box appears: "Sure. What time should I remind you?"
• The user text box appears: "10 PM."
• Then TRAE SOLO replies, and a task card slides in below: "Task created. It will run every day at 22:00."

The user does not need to type or click anything. The dialogue and cards are all prewritten. In that sense, it works like clicking through slides. But visually, it feels like a real conversation flow. After a few seconds of playback, people immediately understand what the dynamic experience is supposed to feel like.

3.2 Build three switchable demo scenarios

I asked TRAE SOLO to create three demo scenarios and place them as switchable tabs above the chat area. That way, I could choose which scenario to show depending on the discussion.

Scenario 1: Create a task through multi-turn conversation

The user might say, “Remind me to write in my journal.”

TRAE SOLO asks for the time, then generates a task card.

Scenario 2: Check run history through conversation

The user might ask, “How have my recent tasks been running?”

TRAE SOLO returns a structured list of recent execution records.

Scenario 3: Edit an existing task through conversation

The user might say, “Change competitor tracking to 8 AM every day.”

TRAE SOLO confirms the change and updates the card.

Each scenario played automatically in a few seconds. Compared with static screenshots or written explanations, this made the idea of conversational automation much easier to understand. After watching the three flows, my teammates could feel how the feature was meant to work.

https://preview.redd.it/btii0vsqav4h1.png?width=1280&format=png&auto=webp&s=a89a3a4494b301ebe08388c69e912ce84c8f3946

3.3 Deploy the demo online with TRAE SOLO

Once the demo was ready, one final step remained: deployment. To share it with my lead, manager, or teammates, I needed a link they could open directly. A local-only demo was not enough. So I told TRAE SOLO: "Deploy the current project to Cloudflare Pages and give me a shareable link."

TRAE SOLO handled the steps:

• Build the project
• Fix compile errors
• Deploy with Wrangler

A few minutes later, I had a live link I could send to anyone. The workflow started from one homepage screenshot and ended with a clickable demo that others could open, review, and discuss. The whole process stayed inside the TRAE SOLO conversation.

That is the key change: a PM no longer has to wait for an idea to become visible. The idea can become clickable while the thinking is still in progress.

Step 4: Use TRAE SOLO to find blind spots

A demo is not the finish line. Product work is the process of making use cases precise. The main path is usually easy to explain: for example, how a user creates an automated task. The harder part is everything around it: side paths, edge cases, failure states, and the questions engineers will ask during review. In the past, this work depended on mental walkthroughs, peer reviews, and getting challenged in product review meetings.

Now that the demo existed and TRAE SOLO had already read the project code, I could ask it to review the demo from both the product logic and the code. I used TRAE SOLO in two ways.

4.1 Audit use case coverage

The main flow was clear. The edge cases were not.

For example:

• What happens if an automated task fails? How does the user find out? What can they do next?
• What if a local folder linked to a task gets deleted before the next run? How should the system report the issue and guide the user?
• If a user deletes a task from the configuration list, what happens to its previous run history? Should it be kept, archived, or deleted with the task?

They are not the main storyline, but they are real product cases. Because TRAE SOLO already had the full demo code, it could review the logic more systematically. I asked TRAE SOLO to scan the code from a product perspective and list two things:

• use cases the current demo already covered
• use cases that should be covered but were missing

The result: the demo covered about 70–75% of the expected cases. TRAE SOLO identified three missing cases on key paths:

• how to display a task that is currently running
• what happens after a task fails
• how created task data should be persisted

It also surfaced more than 10 smaller edge cases.

https://preview.redd.it/xf1724t3bv4h1.png?width=8000&format=png&auto=webp&s=ca38aa89640ac52fa763f472143494917a69100b

4.2 Build an entity-property matrix

How should information hierarchy be presented? This step leaned more toward product thinking. In this feature, each automated task became a product object with many properties: trigger time, last run time, next run time, current status, cloud or local execution, linked device, and total run count. Roughly counted, there were about 16 properties in total.

The same entity also appears in many product contexts:

• task cards inside the conversation flow
• task cards in the configuration list
• the task detail page
• run history list items
• conversation replay

There were roughly 10 contexts. So the product question became:

• Should every property appear in every context?
• Which fields must be shown?
• Which can be hidden?
• Which should be omitted at the surface level but appear in deeper views?

A simple product principle helped: the deeper the user goes, the more information the interface should reveal. I gave TRAE SOLO that principle and asked it to map the 16 properties against the 10 product contexts. The output was a 16 × 10 matrix. Each cell was marked as:

• shown
• hidden
• should be shown but missing

This immediately exposed a few inconsistencies. For example, the list card showed total run count, but the detail page did not. That broke the principle: deeper views should carry more information, not less.

Step 5: Use TRAE SOLO to write the PRD

Once the demo was complete, the final step was to turn it into a PRD for engineering review. Here is the workflow I used:

• First, I configured Lark CLI for TRAE SOLO, so it could call the Lark API and create documents directly.
• Then I packaged my previous PRD writing rules into a PRD Writer Skill, so the output would match my usual structure and writing style.
• Finally, I asked TRAE SOLO to generate the PRD based on three inputs:
  • the PRD Writer Skill
  • the current conversation context
  • the demo code in the project

TRAE SOLO then wrote the PRD directly into a Lark document. The final output included:

• 9 user stories
• 10 corner cases
• coverage across the management panel, creation modal, task templates, task detail page, run history, and conversation replay

Working backward from code into a PRD has one clear advantage: the code is where the details live. Every interaction path, condition branch, and state change is already there.

When a PRD is written from scratch, corner cases are easy to miss. When TRAE SOLO works from the demo and code, it can turn interaction paths and state logic back into product requirements.

Conclusion: What the workflow produced

No designer was involved. No frontend engineer was involved. From scenario research to online deployment, the whole workflow was completed by a non-coding product manager through conversation with TRAE SOLO.

https://preview.redd.it/l2x3taadbv4h1.png?width=1280&format=png&auto=webp&s=60e249b5f8f028b482d6bda1cf66fdfa6874d03d

Final thoughts

Looking back, the biggest shift was not just the time TRAE SOLO saved. The bigger shift was the realization that: "Ideas are always blurrier in your head than you think."

Many product decisions, edge cases, and interaction problems only appear after you can click through a real demo. In the past, I tried to think through the solution first, write the document, and wait for someone else to implement it. Now, I ask TRAE SOLO to help me build the idea first. Then I use the demo to calibrate the product direction. Oftentimes, the moment I see the working version, I realize: this part needs a different approach.

So before writing the PRD, build the demo with TRAE SOLO.

That has become my default workflow for new features. If you are a PM, try this on your next feature: start with the demo, review the artifact, then write the PRD from something you can actually click.

>Author: CC, Product Manager at TRAE

Hi! This is CC, Product Manager at TRAE. It's nice to share with the community here with my experience of designing product features with TRAE SOLO. I will use the "Automation" feature in TRAE as an example. Let me know your thoughts!

A demo does not have to come after the PRD.

For a product manager, it can be a way to think the product through. After several years as a PM, one thing has always bothered me: ideas move fast in my head, but it takes too long to turn them into something other people can see, click, and react to.

In a traditional product workflow, this usually starts with a document -

- First, the PM writes a feature description and sends it to design. The designer catches most of the intent, turns it into screens, and then another round of feedback begins.

- Then the PM aligns with frontend engineers on timing and interaction details for an interactive prototype. Even a simple demo has to pass through too many layers of “let me explain what I mean.”

- If a new idea appears halfway through, even moving one button can trigger another round of explanation, alignment, and revision.

By the time the idea becomes something visible, two weeks may already be gone. This time, I changed the order. Instead of writing the PRD first, I used TRAE SOLO to build the demo first.

Once I had the demo in front of me, the workflow naturally broke into five stages:

https://preview.redd.it/y6h9uga8wu4h1.png?width=1280&format=png&auto=webp&s=097621e905fd1d59b887d248a76aca688ad29ab7

The new workflow became: understand what users need, turn the idea into something concrete, use a mock demo to show the dynamic flow, ask TRAE SOLO to pressure-test blind spots, then work backward from the demo and code into a PRD.

Every step happened through conversation with AI, but the product decisions stayed with me. In the rest of this article, I'll walk through how I used TRAE SOLO to build a demo and turn it into a structured PRD. The entire process was done in TRAE SOLO Code Mode.

Step 1: Start with user scenarios, not assumptions

The fastest way to build the wrong feature is to start with your own assumptions.

So I did not begin by drawing screens. I started with the question a PM should ask first: What will users actually use scheduled automation for?

I wanted to understand three things:

• What are the most common use cases for automated tasks?
• Which scenarios are developer-related, and which are not?
• How often do users naturally expect these tasks to run?

So I asked TRAE SOLO:

>We want AI to help users handle repetitive work on a schedule, without requiring them to start a new conversation every time.
Please research common scheduled automation scenarios across Reddit, Hacker News, GitHub, Twitter/X, and other relevant sources. Separate developer and non-developer use cases, identify common execution frequencies, and include source links.

TRAE SOLO searched across multiple communities and sources, then grouped the use cases into two categories.

For non-developer workflows, the most common scenarios included:

• daily news summaries
• stock price monitoring
• meeting preparation
• email summaries

For developer workflows, the strongest scenarios were:

• PR review
• security scans
• CI status checks
• release notes summaries

The frequency pattern was even more useful.

"Every morning" was the strongest trigger, accounting for more than 60% of the observed cases. "Weekly at a fixed time" came next. "Every N minutes" appeared most often in monitoring scenarios. That directly shaped the demo.

It told me which templates to include, which default trigger time to show, and how to order the frequency options in the task creation form. The demo did not need a long list of templates just to look complete. It needed the right templates, because real user scenarios pointed to them.

In a traditional workflow, this kind of research would usually take one or two days: browsing communities, checking competitors, collecting examples, and turning everything into a usable structure.

Here, one conversation produced the first structured version. That was the real value of this step.

Before designing the page, TRAE SOLO helped me build scenario awareness:

• Which tasks should run every day?
• Which ones belong to a weekly rhythm?
• Which ones are closer to monitoring?
• Which ones are just reminders?

Those answers shaped every product decision that came after.

Step 2: Build the structure with TRAE SOLO

First, recreate the product shell. One thing should be clear: the demo did not appear just because I dropped a screenshot into TRAE SOLO.

Automation was a new feature inside TRAE SOLO. As the PM, I only had one screenshot of the existing product homepage: a conversation interface, a sidebar on the left, and a chat area on the right.

That was it.

I first sent the homepage screenshot to TRAE SOLO and asked it to recreate the page as closely as possible.

TRAE SOLO rebuilt the layout, sidebar, and chat box. But at that point, it was only a shell. It looked like our product, but it had nothing related to Automation yet.

https://preview.redd.it/i15qt2ec3v4h1.png?width=1280&format=png&auto=webp&s=72ed5de84b842f364df6feb8e912ab6c1703db6b

The real work started after that.

To move from an empty shell to a working demo, I kept building through conversation. Here are three representative rounds.

2.1 First, define the three core panels

Before building anything, I mapped out the minimum structure this feature needed.

An automation feature needs at least three parts:

- Task list
Users need to see what they have scheduled. This is the foundation of the feature.

- Run history
Automated tasks run in the background. Users do not actively trigger every run, so they need a way to trace what happened when something goes wrong. Any serious automation product needs this.

- Templates
New users may not know what to automate yet. Without templates, the product feels like an empty box. A few ready-to-use examples help users get started.

I gave these three ideas directly to TRAE SOLO. I also gave TRAE SOLO a few high-level directions: "Make the run history feel like a timeline, grouped by date. Make the templates a grid so they are easy to browse. I did not define every UI detail upfront."

After the first round, TRAE SOLO generated the initial version of the page.

https://preview.redd.it/fdquu7vk3v4h1.png?width=1280&format=png&auto=webp&s=49938dd6307cd8fc271a0fc0bbf7c0355e4a9e85

2.2 Then fix the problems that only appear once you can see the product

Once the structure was built, I started noticing problems I had not thought through before.

• The run history could become overwhelming if every record appeared in one flat list. It needed filters, such as Today, This week, and This month, so users would not be buried in information as soon as they opened the page.
• Failed runs deserved more attention than successful ones. If a task ran successfully, users usually do not need to do anything. But if it failed, they need to know quickly. So the Failed status needed to stand out in the filter options.
• Cloud tasks and local tasks should not be mixed together without context, either. Local tasks depend heavily on whether the user’s computer stays awake. The list needed a clear shortcut, plus guidance to keep the computer awake. Otherwise, a local automation could be configured correctly and still never run.

Every time I found a problem, I told TRAE SOLO what needed to change.

That became the core loop: see it, think it through, change it, review it again.

2.3 Generate three clickable interaction options and compare them side by side

The task list was the most important part of the demo. Automated tasks have a specific pattern: one setup can generate many repeated runs over time.

The same task may run every day and create a new record each time. Structurally, the content is highly repetitive. If we displayed those records like regular tasks, the list would quickly be flooded by dozens or hundreds of similar items.

So the list needed grouping.

But how should it be grouped? For example:

• Should cloud and local tasks be separated?
• Should they live under different tabs?
• Should each automation collapse into one row, with details one level deeper?

This is the kind of product decision that used to rely on imagination, static prototypes, and long meeting-room debates. Now, I could ask TRAE SOLO to generate three clickable interaction options in one round and switch between them directly. Each option was interactive, not a screenshot or a written description.

Two of the options looked like this:

https://preview.redd.it/2qnbrhrt3v4h1.png?width=1023&format=png&auto=webp&s=8ea1a379b7e8266c3113d8b029a5b4510ba259c5

Then I could click through each version and evaluate it in context:

• Which one matches the user’s mental model best?
• Which one requires the least change to the existing product structure?
• Which one gives us the best ROI for the least product and engineering change?

After clicking through all three, the decision became much clearer. This was the biggest shift in this step: comparison moved from guessing to clicking. For PMs, a large part of the decision cost used to come from guessing. Which interaction would feel better? How would users move through the page?

With TRAE SOLO, the options became clickable early enough for the trade-off to feel concrete.

2.4 Keep iterating through 60+ rounds

The full demo took more than four rounds of conversation. In total, I went through 60+ rounds with TRAE SOLO. In a traditional workflow, that amount of change would mean 60 rounds of communication, scheduling, implementation, and review.

Inside TRAE SOLO, it was just 60+ messages. The pattern stayed the same:

1. You do not need to know every detail at the beginning. A clear direction is enough to start.
2. TRAE SOLO builds the first version. Once you see the artifact, new product questions appear.
3. You tell TRAE SOLO what to change. It updates the demo. You review, rethink, and refine again.
4. The demo grew through that loop: see it, think it through, change it, review it again.

https://preview.redd.it/l7c9kpgpphzg1.png?width=1280&format=png&auto=webp&s=8eefbd1193a1f68086978b3c5aa0b40d696c5eaa

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.

1. Dual Modes, Built for Work & Coding

TRAE SOLO Mobile supports Code Mode + MTC Mode to match different moments in your day.

• Code Mode: Built for full-stack developers and software engineers. Designed for app building and complex tasks, so you can stay hands-on when you need to dive deep.
• MTC Mode: Built for all workforce professionals: product manager, data analyst, UI/UX designer, financial practitioner, legal and consultant for creations, operations, review, approvals, and decision-making, without the "full IDE" overhead.

Switch modes in seconds to stay efficient from planning to execution.

https://preview.redd.it/iv758wfyphzg1.png?width=1280&format=png&auto=webp&s=89bb85c5674b5fc76001898c5721bdab4751573b

2. Information Flows, All Endpoints in Sync

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.

• Seamless pairing, always in sync: Pair once, and your mobile can connect with multiple desktop and web endpoints. After pairing, all your connected devices stay synchronized. Context, task status, and updates remain consistent across endpoints.
• Real-time task visibility across Web & Desktop: Tasks created on mobile instantly appear on Web (Cloud) and Desktop (Local), making it easy to hand off execution, monitor progress, and collaborate without manual syncing or duplicate work.
• Background execution: Your tasks keep running in the background even when you switch apps or step away. When execution finishes, TRAE SOLO notifies you with push alerts, so you can jump back in right when results are ready.

https://preview.redd.it/vrktclb0qhzg1.png?width=1280&format=png&auto=webp&s=4ee1267a458216347d0be56fbccc9b68fda2a434

3. Mobile Dispatch, Desktop in Action

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.

• Remote folder access, context-aware execution: TRAE SOLO Mobile can securely connect to your desktop and web and work directly within authorized folders by browsing files, referencing project context, and executing tasks based on what's inside.
• Artifacts saved where work lives: You can then create and save artifacts back into the same directories (e.g., drafts, summaries, reports, code files), so outputs land exactly where your workflow already lives while desktop-side folder permissions ensure access stays strictly within the folders you approve.
• Parallel task execution: Dispatch multiple tasks at once across your paired endpoints. Run in parallel, track progress in real time, and keep moving without waiting for one task to finish before starting the next.

https://preview.redd.it/pdrcp7j2qhzg1.png?width=1280&format=png&auto=webp&s=c9ac98cd56a90091a9970ce3b83cfcc95988be1a

4. Ideas Never Rest, Brainstorm Anytime

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.

• Brainstorm anytime: Turn on Brainstorm Mode whenever inspiration hits. TRAE SOLO Mobile helps you explore and clarify your thinking in real time, then summarizes the brainstorm and turns it into a structured, step-by-step execution plan.
• Voice input, zero friction: Send TRAE SOLO Mobile a voice message on the go. It captures your idea instantly and converts it into actionable instructions, so work can start with minimal effort.
• Complex ideas, broken down in flow: For bigger problems, SOLO debriefs your intent into clear to-dos and handles them in sequence, keeping everything connected from concept to completion.

https://preview.redd.it/lhdcvie4qhzg1.png?width=1280&format=png&auto=webp&s=95f3ec3d5ea286a8ca5129fd35003c2c5c2f53ff

5. Privacy Mode, Data in Control

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

https://preview.redd.it/gaftkdn6qhzg1.png?width=1280&format=png&auto=webp&s=5093988f36c046a1f4f2303084c20640316c8658

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

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.

https://preview.redd.it/xle1of5jyhzg1.png?width=1280&format=png&auto=webp&s=ad69803fef280e32f71afcc32dca2117069f5ccf

Data Analysts

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.

https://preview.redd.it/ph88c0ikyhzg1.png?width=1280&format=png&auto=webp&s=96f80e9fb9e9f6e2ed3c2ca980fb87cff827b533

Product Managers

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.

https://preview.redd.it/ti9vm39pyhzg1.png?width=1280&format=png&auto=webp&s=4a73db649666c95da72068985c596daf14534822

Operations

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.

https://preview.redd.it/z1kffmmqyhzg1.png?width=1280&format=png&auto=webp&s=027d9694d4ea58ff7e4f99d4fb2eda6c30ad6152

Legal

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.

https://preview.redd.it/x5q109yryhzg1.png?width=1280&format=png&auto=webp&s=c630a833a06884e86e6ebeaacf01163dcfcdaa4e

Finance

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.

https://preview.redd.it/ekq13jftyhzg1.png?width=1280&format=png&auto=webp&s=c16f705b082c92396ae8a162497c75b8a82384bc

Getting Started

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.