Trae SOLO: NEW SOLO Mode in TRAE is ACTUALLY AMAZING!

Key Concepts

• AI Native IDE: An Integrated Development Environment built from the ground up with AI integration.
• Workflow Bottleneck: The issue in traditional AI coding tools where a developer must wait for one complex task to complete before initiating another, breaking their flow.
• Trey Solo: A feature within the Trey IDE that acts as a responsive coding agent capable of multitasking.
• Solo Builder Mode: A mode in Trey Solo designed for starting projects from scratch, transforming an idea into a shippable product.
• Solo Coder Mode: A mode in Trey Solo for performing deep, complex tasks within an existing codebase, emphasizing precision.
• Responsive Coding Agent: An AI agent that plans, executes, and verifies its work, and can multitask.
• Parallel Task Execution: The ability of Trey Solo to run multiple AI tasks simultaneously.
• Temporary Git Branches: Trey's internal mechanism for managing parallel tasks, treating each as a separate developer working on a distinct ticket.
• Integrations Tab: A feature in Trey providing built-in support for services like Superbase, Vercel, and Netlify.
• Custom Agents: User-defined AI agents with specific instructions and personas for tasks like code cleanup.
• Workflow Orchestration: The ability to manage and coordinate multiple AI agents and tasks efficiently.

Trey: An AI Native IDE with Solo Mode

This video introduces Trey, an AI-native IDE designed to address the workflow bottlenecks commonly encountered with existing AI coding tools. Unlike extensions layered onto existing IDEs, Trey is built from the ground up for deep AI integration throughout the development lifecycle. The primary focus is on Trey's new feature, Trey Solo, described as a "responsive coding agent."

The Problem: Workflow Bottlenecks in AI Coding

The presenter highlights a significant issue with current AI coding tools: the workflow bottleneck. When requesting complex tasks, such as refactoring a backend service, developers are forced to wait for the AI to complete the entire process. This passive waiting period breaks the developer's "flow state" and limits their ability to initiate other tasks, as the AI might become confused or overwrite ongoing work. The developer becomes a "spectator" in their own IDE, constrained by the AI's processing speed.

Trey Solo: A Solution for Parallel Development

Trey Solo aims to solve this problem by acting as a sophisticated AI agent that can multitask. It's not just about generating code; it plans, executes, and verifies its own work.

Key characteristics of Trey Solo:

• AI Native: Built from the ground up for AI integration.
• Responsive Coding Agent: Plans, executes, and checks its work.
• Multitasking Capability: Can handle multiple tasks concurrently.
• Generous Free Tier: Allows users to try all features without upfront payment.

Getting Started with Trey

1. Download and Installation: Users can download the Trey IDE from the official website. The installation process is described as "super simple."
2. Familiar Interface: Upon installation, Trey closely resembles VS Code, supporting existing extensions, key bindings, and themes, making it easy for VS Code or Cursor users to transition.
3. Main Interface: The IDE features a standard project file explorer on the left and a new "Solo Agent Panel."

Solo Builder vs. Solo Coder Modes

The Solo Agent Panel offers two distinct modes:

• Solo Builder: Intended for starting projects from scratch. It's designed to take an idea (e.g., "build me a Flappy Bird clone") and rapidly develop it into a shippable product.
• Solo Coder: Designed for deep, complex tasks within an existing codebase. It is described as more careful and precise than the builder.

Case Study: Adding a Watchlist Feature to a Movie Tracker App

The presenter demonstrates Solo Coder mode using a benchmark project: a React Native Expo app called "Movie Tracker." The current app displays movies from an API.

The Task: Add a watchlist feature. This involves:

• Adding a heart icon to each movie card.
• Saving liked movies to local storage (async storage) upon clicking the heart.
• Creating a separate tab to view saved movies.

The Prompt: "add a watch list feature, put a heart icon on each movie card, use React context to manage the state, and when clicked, save it to async storage. Also, create a new screen to view the watch list."

Trey Solo's Process:

1. Thinking Phase: Instead of immediately generating code, Trey Solo analyzes the entire codebase, including package.json for libraries and the navigation structure.
2. Plan Generation: It creates a detailed plan presented as a checklist in the chat window:
   • Create watchListContext.tsx for state management.
   • Update movieCard.tsx to include the toggle button.
   • Create watchListScreen.tsx.
   • Update appNavigator to include the new route.
3. Plan Approval: The user can review and modify the plan before execution. The presenter approves the plan.
4. Execution: Trey begins implementing the plan.

Multitasking in Action: Adding a Dark Mode Theme

While the watchlist feature is being implemented, the presenter has another idea: a dark cinema mode with gold accents.

Initiating a New Task:

• A "+" button at the top of the agent panel allows for a new task.
• Clicking this opens a fresh context, with the previous task (watchlist) continuing in the background.

The Second Prompt: "update the entire app to have a dark mode theme. Use a dark gray background, white text, and gold accents for the headers and active tabs."

Parallel Execution:

• Trey Solo now runs two tasks in parallel: one for the watchlist logic and another for the UI styling.
• Under the Hood: Trey manages this by creating temporary Git branches for each task, treating them like separate junior developers working on different tickets.
• The presenter can switch between task tabs to monitor progress.

Merging and Reviewing Changes

Once both tasks are completed:

1. Change Presentation: Trey presents the changes.
2. Conflict Resolution: If conflicts arise, Trey would prompt the user to resolve them. However, it's often smart enough to merge automatically.
3. Preview/Run: The user can preview changes in the IDE or run the app in a simulator.

Observed Results:

• The app now has a dark theme with gold accents.
• The heart icon is present on movie cards.
• Clicking the heart icon saves the movie.
• The new "watch list" tab correctly displays the saved movie ("Inception").

The presenter emphasizes the impressive feat of merging a UI overhaul and a complex logic update without breaking the app.

Integrated Services and Custom Agents

Integrations Tab:

• Trey offers built-in support for services like Superbase, Vercel, and Netlify.
• Example: Migrating the watchlist from local storage to a Superbase table. Instead of manual setup (copying API keys, creating .env files), the user can connect to Superbase directly within Trey and instruct the agent to migrate the data. The agent leverages project details and API keys for seamless interaction.

Custom Agents:

• Users can create their own AI agents with specific instructions and personas.
• Example: "The Cleaner" Agent:
  • Prompt: "You are a code quality expert. Your job is to scan files for console logs, unused imports, and any any types in Typescript. You should fix them immediately without asking."
  • Usage: After completing a feature, the user can select the "Cleaner" agent to automatically tidy up the code before pushing to GitHub.
• Sub-Agent Invocation: The main agent (e.g., Solo Coder) can be instructed to invoke a custom sub-agent (like "Cleaner") automatically after completing its primary task.

Conclusion and Recommendation

The presenter concludes that using Trey Solo feels more like managing a team of developers than prompting a chatbot. The parallel task execution is identified as the "killer feature," enabling developers to maintain a flow state by immediately starting new tasks while others are in progress. This significantly streamlines the workflow.

The presenter highly recommends trying Trey, especially given its free download option, to see if it fits individual development workflows. The overall experience is described as "pretty cool."