Trae AI: A Guide With Practical Examples

Trae AI has claimed the top spot on the SWE-bench Verified leaderboard as of July 2025. This benchmark tests AI coding tools with 500 real GitHub issues, selected by experienced Python developers. Trae AI is the only AI-powered coding IDE that participated in this benchmark and won.

Benchmarks are useful, but they don’t always reflect coding work. Solving GitHub issues is just one part of what developers do. A lot of your time goes into building new features, understanding existing codebases, and working with your team on projects.

My focus in this tutorial is on practical examples rather than theory. I’ll explain step by step how to set up Trae AI and test it on various examples that can help you decide whether the tool is a good fit for you.

What Is Trae AI?

Trae AI calls itself “the real AI engineer” — a bold claim they likely adopted after topping the SWE-bench Verified leaderboard. At first glance, it looks like any other AI-powered IDE with standard features you’d expect:

• A coding agent called the Builder
• Sidebar and inline chat for controlling the Builder and asking about your codebase
• Access to premium models like Claude 4 Sonnet, Gemini 2.5 Pro, Grok 4, and Kimi K2
• Built-in terminal access, Model Context Protocol (MCP) support, and web search capabilities
• Tab completion and standard IDE functionality

But dig deeper and you’ll find features that set Trae apart from the competition:

• SOLO mode provides end-to-end software engineering from planning to project completion
• SOLO Builder, a specialized version customized for web development tasks
• One-click deployment of web apps to Vercel
• Built-in browser for previewing web applications
• Voice input for giving commands to the AI
• Custom AI agents through MCP, letting you create specialized assistants for different tasks

Like Cursor, Trae is actually a VS Code fork, though it’s closed-source. You’ll notice this immediately since it lets you import settings, extensions, and keyboard shortcuts from Cursor or VS Code. However, they’ve cleaned up the UI to make it more compact and visually appealing.

The tool positions itself as a collaborative partner rather than just another code completion tool. You can communicate with it using natural language commands like @Agent or #Context and delegate complex coding tasks while maintaining control over the process.

Before we look at these features in action, we need to discuss Trae AI’s pricing model, because that’s where the real differences between it and other AI IDEs become clear.

A Note on Trae AI Pricing

Trae AI currently costs $10 per month, with the first month discounted to $3. This is surprisingly low compared to direct competitors like Cursor or Windsurf, which charge $15–20 monthly, while open-source alternatives like Cline can cost hundreds per month due to usage-based pricing.

What makes this pricing even more interesting is the request-based model. You get 600 fast requests per month and unlimited slow requests for premium models. However, this approach has a fundamental problem that we’ve seen before.

Cursor followed this exact pricing model just months ago. In this model, each prompt counts as one or more requests against your monthly limit, regardless of its complexity or token usage.

For example, a prompt doing an operation across your entire codebase counts the same as a small inline edit, despite the first costing 10–20x more in actual API costs. Cursor realized this model wouldn’t scale, even at $20 monthly, and switched to credit-based pricing where users get $20 of credits at API pricing plus surcharges.

This change caused massive backlash in the Cursor community. Users started to burn through their monthly credits in days. The same economic reality that forced Cursor’s hand will likely affect Trae AI as its user base grows.

Signs of strain are already appearing. SOLO mode, Trae’s defining feature, remains in beta with limited access even for paying users. Their website shows that all access rounds are closed, with codes potentially available through a waitlist. This makes sense because SOLO mode acts like a real software engineer — planning, documenting, and deploying — consuming far more tokens than regular coding assistance.

While this pricing model may be short-lived, it presents an opportunity to access Claude 4 Sonnet and other premium models for $3 in your first month. Companies often operate at a loss initially to build trust and a user base, especially with investor backing.

How to Install And Setup Trae AI?

Trae AI setup experience is very smooth:

1. Download the installer for your platform
2. Run the installer
3. Import your settings from either Cursor or VS Code
4. Optionally, add Trae to the terminal under the trae command
5. Open a folder as a project or clone a repository from GitHub

For this tutorial, we are going to build a tic-tac-toe terminal application to test the Builder’s capabilities. Sadly, I don’t have access to the SOLO mode yet, so we will focus on the Builder’s features and only provide an overview of the SOLO mode at the end of the tutorial.

Let’s finally dive in!

Using Trae’s Builder

To test Trae’s capabilities, create a new project directory and open it with Trae. Choose Claude 4 Sonnet since Trae is optimized for that model — it’s the same model that helped them top the SWE-bench leaderboard.

I started with this prompt to build a terminal-based tic-tac-toe game:

I want to build a 4x4 tic-tac-toe game in Python with a clean terminal interface.
The game should support two players taking turns, detect wins in rows, columns,
and diagonals, and handle draws. It should have colored elements, not just black and white, but the color system must be minimalistic.

The result was a 99% success. The Builder created a fully-functioning terminal game that looked aesthetically correct. What surprised me most was that it got the tic-tac-toe grid right on the first try. When I tested this same prompt with other IDEs during my reviews, only Cursor managed to do it properly.

The chat interface itself feels clean and well-organized. Each event — whether it’s generating code, running commands, or creating files — appears as a distinct element, making it easy to follow the Builder’s process.

The Builder automatically generated both the Python script and an accompanying README file, then ran terminal commands to test everything. It even picked up my shell configurations (Oh My Zsh) without any setup. The whole experience felt smooth and natural.

Testing Web Access

In the early days of AI IDEs, switching context from your IDE to ChatGPT or Chrome to search for project-related information was frustrating. Fortunately, web access directly in the chat UI is now practically a requirement for all IDEs. Trae is no exception.

Let’s test it with a search related to our tic-tac-toe project:

Search the internet for innovative ways other people have built tic-tac-toe games.

I want more comprehensive features

The results were what you’d expect — a detailed research summary with suggestions on what to implement. However, one thing to note is the browsing speed. It’s a bit slower than other operations, but this isn’t a big deal since web search is something you do occasionally rather than constantly.

Controlling Context

Trae offers the standard context control features you’d expect. You can add files or folders by mentioning them with #, and pasting URLs works too—Trae will pull in page contents as context when writing code.

This feature is practically a must for AI engineers who constantly work with technologies like LangChain or OpenAI Python SDK, which are often several versions newer than the LLM's training knowledge. Rather than breaking your workflow to copy documentation, you can simply mention updated docs URLs directly in your prompt.

What sets Trae apart is its ability to reference specific classes or functions in your currently open file. This beats manually selecting code, especially when dealing with large Python classes that span hundreds of lines.

For managing what the AI sees, Trae lets you exclude files and folders from indexing. Since AI IDEs create workspace indexes for codebase Q&A, you can control what gets included by creating a .ignore file inside the .trae folder. This works alongside your .gitignore, so anything in either file stays out of the Builder's awareness.

Where Trae really stands out is with rule files. These markdown documents let you set workspace and user-level guidelines that shape how the AI behaves. In AI-assisted development, rule files are practically required. Consider creating these in your .trae/rules directory:

• architecture.md for project structure and architectural decisions
• development.md for coding standards and practices
• orchestration.md to guide feature implementation and documentation usage
• design_philosophy.md for web project design principles

Once set up, you can invoke any rule during chat using the #rulename syntax.

Tab Completion

Tab completion has been part of IDEs for a long time. Cursor changed this code developer experience by introducing its own internal model to make intelligent completions across your entire file. Trae AI offers similar features and groups them under a single name called Cue.

Cue includes several completion types:

• Auto-completion understands existing code and suggests continuation at your cursor position
• Multi-line edits can write several lines of related code at once
• Predictive edits suggest your next change based on your last edit
• Jump to edits finds the next place you should make a change that was affected by your previous edit

I love the jump to edit feature in Cursor, which works seamlessly. I can just tab-tab-tab through my edits when I take control of the script. Trae’s jump-to-edit feature is much slower than Cursor’s version.

During testing, I often had to place the cursor on the line where I wanted to make the next edit to trigger the “Tab: jump here” suggestion. This defeats the whole purpose of the jump-to-edit feature. Other Cue features are slower as well.

It works, but since Trae is new, Cue needs some love to match established competitors.

Builder With MCP Access

Another must-have feature for AI-powered IDEs is support for Model Context Protocol (MCP). MCPs act as bridges between your AI assistant and external tools, databases, or APIs. Without them, your coding agent stays isolated from the real-world systems you build with.

Trae AI’s support for MCPs is polished and user-friendly. The platform includes a dedicated marketplace UI for official MCP servers that lets you install them with one click.

Having a marketplace also solves the discovery problem. You can browse available MCPs instead of hunting through documentation or GitHub repositories to find what you need.

Once you add one or more servers — or add a custom one through settings, which is also straightforward — you can switch from the regular Builder to the “Builder with MCP” agent. While having a separate agent might seem odd at first, it’s actually smart design.

Your MCP list will grow over time. Each prompt you send includes information about available MCPs and their tools, consuming tokens whether you use them or not. Intentionally switching to Builder with MCP keeps costs down for Trae. When they eventually move to usage-based pricing, this design will save money for users, too.

One warning: marketplace listings for MCP servers sometimes use outdated setup instructions, which can cause installation errors. When you switch to Builder with MCP, check the status indicators next to each server and make sure they show green before starting your work. If it is red, then, you must debug the problem yourself.

Creating Custom Agents

A highly desirable feature in current open-source IDEs like Cline or Roo Code is the ability to create custom agents with access to different tools, MCP servers, and completely different behavior through different system prompts. Despite being closed-source, Trae AI offers this exact same feature as well.

Custom agents solve a real problem in AI-assisted development. The default Builder works well for general coding tasks, but specialized work often needs focused behavior. Instead of repeatedly explaining your requirements in every conversation, you can create agents tailored for specific workflows.

For example, you might create a “Documentation Agent” that always writes comprehensive docstrings, includes type hints, and follows your team’s documentation standards. Or a “Code Review Agent” that focuses on security vulnerabilities, performance issues, and coding standards rather than implementing new features.

Once you have your custom agent, you can start using it by choosing it from the dropdown available at the top of the chat input field or by using the @agent-name syntax.

SOLO Mode in Trae AI

SOLO mode represents Trae’s most ambitious feature — a fully autonomous software engineering experience that handles everything from initial planning to final deployment. You describe what you want, and SOLO mode plans the architecture, writes the code, handles testing, and deploys your project without constant supervision.

SOLO mode goes well beyond standard coding assistance. It breaks down complex projects into manageable tasks, writes documentation, and makes architectural decisions like an experienced developer would. The SOLO Builder variant focuses specifically on web development workflows, offering specialized tools for frontend projects, including built-in browser previews and one-click Vercel deployments.

Key capabilities include:

• Complete project development from concept to deployment
• Automatic project planning and task breakdown
• Real-time documentation generation
• Built-in testing and debugging workflows
• One-click deployment to cloud platforms
• Voice input support for natural interaction

SOLO mode remains in beta with extremely limited access, as we mentioned earlier. Even paying Pro users need special invitation codes to try it, and all access rounds appear closed with only potential waitlist availability.

Trae AI vs. Cursor

After using Trae for a while and reading through their documentation, it becomes clear that beating Cursor is their primary target.

Trae’s advantages are hard to ignore. At $10 monthly compared to Cursor’s $20, the price difference matters for many developers. Trae also packs in features that Cursor lacks — custom agents, OpenRouter integration for additional models, and, subjectively, a more polished interface. The visual design feels more modern and less cluttered than Cursor’s current setup.

But Cursor holds several cards that Trae doesn’t:

• First-mover advantage brought them a massive user base that’s already invested in their ecosystem
• Background agents that work without the IDE open
• Mobile and Slack integrations for remote coding
• Deeper partnerships with companies like Anthropic that provide access to optimized model versions
• ChatGPT-style memory feature that remembers context across sessions — something Trae currently lacks

The real test will be execution. If Trae can polish features like Cue (their tab completion system), expand SOLO mode access, and build stronger marketing presence, they could capture frustrated Cursor users, especially those unhappy with recent pricing changes.

However, switching IDEs requires significant effort, and Cursor’s established ecosystem creates natural barriers to migration. The competition benefits developers either way — both tools will need to innovate faster to stay relevant.

Conclusion

Trae AI delivers on its promise of being a capable coding companion with a clean interface and competitive features. While benchmark results look impressive, the real test comes down to daily development workflows where the tool performs well enough to justify consideration as a Cursor alternative.

The bigger question isn’t whether Trae AI works — it does — but whether it can maintain its current advantages long enough to build market share. The pricing model will likely change, SOLO mode access remains limited, and some features need refinement. For developers willing to try something new, especially at the current $3 introductory price, Trae AI offers a solid experience that could become your primary IDE with a few updates.

If you’re in the process of researching AI coding assistants, you might also find these blogs helpful:

• Cline vs Cursor: A Comparison With Examples
• Cursor vs Windsurf: A Comparison With Examples
• Cline AI: A Guide With Nine Practical Examples
• Cursor AI: A Guide With 10 Practical Examples
• Windsurf AI Agentic Code Editor: Features, Setup, and Use Cases