Skip to content
Home » News » Trae AI for Programming on Windows

Trae AI for Programming on Windows

Trae AI

1. What Is Trae AI and Why Does It Matter?

Trae AI (often branded simply as Trae or “Trae IDE”) is an AI-native integrated development environment (IDE) and plugin ecosystem created under ByteDance’s “Trae” product line. It combines a VS Code–style editor with agentic AI tools that can understand repositories, write code, fix bugs, run commands and even plan multi-step projects. (traeide.com)

The Trae ecosystem currently includes three main components: (Skywork)

  • Trae IDE – a standalone AI-first code editor (VS Code fork) with:
    • Builder mode for project-level tasks
    • Side and inline chat
    • Multimodal input (images + text)
    • Auto-completion and project indexing
  • Trae Plugin – an AI assistant extension for VS Code and JetBrains IDEs that adds code completion, chat, bug fixing and test generation directly into your existing editor.
  • Trae Agent – an open-source command-line tool designed for complex, multi-step software engineering workflows.

Trae’s positioning is aggressive: it markets itself as “the real AI engineer” and has topped the SWE-bench Verified benchmark for solving real GitHub issues, which puts it in the same conversation as Cursor, Windsurf and Codex-based tools for serious software engineering tasks. (DataCamp)

For developers on Windows, Trae AI offers:

  • An AI-native IDE that can import your VS Code/Cursor configuration.
  • A plugin that brings Trae’s AI directly into VS Code/JetBrains.
  • Agentic modes (Builder, SOLO) that go well beyond autocomplete and simple chat.

2. Installing Trae AI on Windows

On Windows you can adopt Trae in two ways:

  1. Trae IDE installer (full AI IDE)
  2. Trae Plugin inside VS Code or a JetBrains IDE

Both can be used in parallel.

2.1. System prerequisites (Windows)

Trae does not require exotic hardware, but in practice you will want:

  • OS: Windows 10 or Windows 11 (64-bit)
  • RAM: 8 GB minimum (16 GB recommended for large repositories)
  • Disk: Several GB of free space for Trae, extensions, and workspace indexes
  • Network: Reliable internet connection (all AI features are cloud-based)

Trae’s official documentation and third-party guides describe a standard desktop installation experience: download an installer for your platform (Windows, macOS, or Linux), run it, and then import settings from VS Code or Cursor. (traeide.com)

2.2. Installing Trae IDE on Windows

Step 1 – Download the installer

  1. Go to Trae’s official website (trae.ai) and open the download page. (traeide.com)
  2. Select the Windows installer and download the .exe.

Step 2 – Run the installer

  1. Double-click the downloaded .exe.
  2. Follow the standard Windows setup wizard:
    • Accept the licence terms.
    • Choose an installation directory.
    • Optionally allow Trae to add a Start Menu shortcut and desktop icon.

Step 3 – First launch and initial setup

When you launch Trae for the first time, you are guided through an onboarding flow: (traeide.com)

  1. Click “Get Started” on the welcome screen.
  2. Select theme and language:
    • Themes: Dark, Light, DeepBlue
    • Interface languages: English or Simplified Chinese (you can change these later in Settings).
  3. Import settings from VS Code or Cursor:
    • Choose Import from VSCode or Import from Cursor.
    • Trae migrates editor preferences, keybindings and extensions where possible.

This import step is important for Windows developers already invested in VS Code—Trae behaves like a more agentic VS Code fork, so preserving muscle memory reduces friction. (traeide.com)

Step 4 – Sign in to Trae

To enable AI features, you must log in: (traeide.com)

  • Sign in using Google, GitHub, or an email-based Trae account.
  • Once authenticated, you are redirected to the main Trae IDE interface.

Step 5 – Open or create a project

From the home screen you can: (traeide.com)

  • Open an existing folder on your Windows filesystem.
  • Clone a Git repository (e.g. from GitHub).
  • Or start a new project using Builder mode to scaffold the initial codebase.

At this point, Trae IDE is fully installed and ready for AI-assisted development.

2.3. Installing the Trae Plugin in VS Code (Windows)

If you prefer to stay in VS Code, you can use the Trae Plugin as an extension: (Skywork)

  1. Open VS Code on Windows.
  2. Press Ctrl + Shift + X to open the Extensions view.
  3. Search for “TRAE AI” or “Trae Plugin” (you may still see references to its former name MarsCode).
  4. Click Install, then reload VS Code when prompted.
  5. Sign in to Trae when the plugin requests authentication.

The plugin then adds:

  • AI chat panel
  • Inline suggestions
  • Commands such as “Generate tests”, “Explain code”, “Fix bug”, etc.

For JetBrains IDEs (IntelliJ, PyCharm, etc.), the process is similar via Settings → Plugins and searching for TRAE AI (formerly MarsCode). (Skywork)

3. Trae’s Core Tools and How They Work

Trae AI combines several tools to support the full development lifecycle: from writing and correcting code to building, testing and deploying projects.

3.1. Auto-completion and Cue

At its foundation, Trae provides native AI code completion, similar to Copilot or Cursor: (traeide.com)

  • While you type, Trae predicts the next tokens and shows inline suggestions.
  • Press Tab to accept a full suggestion or Ctrl + → to accept it word by word.
  • You can also use comment-based completion:
    • Write a descriptive comment (e.g. // validate email with regex) and press Enter.
    • Trae generates the corresponding function or boilerplate code.

Trae groups its more advanced completion behaviour under the name Cue, which offers: (DataCamp)

  • Multi-line completions
  • Predictive edits based on your last change
  • “Jump to edits” – moving you sequentially through locations that need adjustment after a change

In practice, this means Trae can:

  • Expand a one-line function stub into a fully formed implementation.
  • Suggest follow-up changes (e.g. updating related functions or tests).
  • Help maintain consistency across a file while you iterate.

3.2. Side Chat: Repository-aware Q&A

The Side Chat panel is Trae’s main conversational interface. It behaves as a repository-aware AI assistant with access to your workspace: (traeide.com)

  • You open Side Chat (e.g. via a keyboard shortcut) and can:
    • Ask general programming questions.
    • Request explanations of a file or subsystem.
    • Ask Trae to locate where a bug originates.
    • Request new code snippets or refactors.

Trae’s Context system allows you to feed the assistant precise information: (traeide.com)

  • From editor selections (code you highlight and “Add to Chat”).
  • From terminal output (e.g. stack traces, compiler errors).
  • With # tags:
    • #Code – specific functions or classes
    • #File – entire files
    • #Folder – folder-level context
    • #Workspace – the entire repository (once indexed)

This context routing is central to how Trae corrects code effectively. For example, you can:

  1. Run your tests and capture a failing stack trace from the terminal.
  2. Add the failing test and relevant file via #File or #Code.
  3. Ask Side Chat: “Why is this failing, and how should I fix it while keeping style consistent?”

Trae then analyses the error, your code, and any rules you have configured, proposing targeted fixes.

3.3. Inline Chat: Fixing and Refactoring Code in Place

Inline Chat is embedded directly inside the editor and is optimized for editing existing code. (traeide.com)

Typical workflow:

  1. Select a block of code in the editor.
  2. Press the inline chat shortcut.
  3. Describe what you need:
    • “Explain this function in detail.”
    • “Refactor for readability and performance.”
    • “Convert this loop to a list comprehension.”
    • “Fix this off-by-one error and add edge case handling.”

Trae responds with a diff view:

  • Proposed changes are shown inline.
  • You can accept or reject all changes at once (e.g. Accept / Reject).
  • Or accept/reject individual hunks (e.g. keyboard shortcuts like Ctrl + Y / Ctrl + N).

This mechanism is crucial for:

  • Code correction – bug fixes remain visible and reviewable.
  • Stylistic alignment – you can enforce project standards by accepting only the portions you agree with.
  • Safe experimentation – you can ask Trae to attempt large refactors and selectively apply them.

3.4. Builder Mode: Agentic Project Development

Trae Builder is where Trae moves from “assistant” to agent. In Builder mode, Trae can: (traeide.com)

  • Read your project files.
  • Break a high-level task into steps.
  • Create and modify files.
  • Run commands in the integrated terminal.
  • Analyse outputs and adapt subsequent steps.

From the documentation and independent testing: (traeide.com)

  • You open Side Chat and switch to Builder mode.
  • You issue a high-level request, such as: “Set up a REST API in Python using FastAPI with JWT authentication and unit tests.”
  • Builder then:
    • Creates a project structure.
    • Adds configuration files (e.g. pyproject.toml, requirements.txt, or poetry files).
    • Writes application modules, routers, and models.
    • Writes tests.
    • Runs installation and test commands in the terminal.
    • Reports any errors and attempts to fix them.

This is the main mechanism behind Trae’s “develop a project from scratch” capability highlighted by both official docs and third-party reviews. (traeide.com)

3.5. SOLO Mode: Autonomous “AI Engineer”

SOLO mode extends Builder into a more autonomous “AI engineer” that can own an entire software project from specification to deployment. (DataCamp)

Key abilities include:

  • Project planning and architecture.
  • Step-wise implementation.
  • Ongoing documentation generation.
  • Testing and debugging loops.
  • One-click deployment for web apps (e.g. to Vercel).
  • Voice input as an alternative interaction mode.

At the time of the latest reports, SOLO mode is still beta-only with limited access even for paying users, but it shows where Trae is heading: fully agentic programming where the AI handles most of the routine engineering work and the human acts as reviewer and product owner. (DataCamp)

3.6. Multimodal Input

Trae supports multimodal input in its chat interfaces: (traeide.com)

  • You can attach images, such as:
    • Error screenshots from Windows terminals or GUIs.
    • UI mockups.
    • Architecture diagrams.
  • The AI can interpret these images and incorporate them into its reasoning when generating or correcting code.

This is particularly useful when:

  • A Windows build fails with a GUI error dialogue instead of a textual log.
  • A designer provides a UI screenshot and you want Trae to generate the corresponding front-end code.

3.7. AI Settings, Code Indexing and Rule Files

Trae provides detailed AI configuration: (traeide.com)

  • AI chat language – Auto, English, Chinese.
  • Code index management – building a full workspace index for #Folder and #Workspace queries:
    • Automatically for projects with ≤ 5,000 files.
    • Manually triggered for larger repositories.

Trae also allows fine-grained control of AI context via:

  • A .trae directory to control indexing and ignore files. (DataCamp)
  • Rule files such as:
    • architecture.md
    • development.md
    • design_philosophy.md
  • These rule files shape how the AI behaves and respond when referenced (e.g. #architecture).

For long-running projects on Windows, these mechanisms help ensure the AI keeps following consistent project conventions as it corrects, generates and builds code.

3.8. Extensions, MCP and Source Control

Trae IDE includes its own extension store and supports .vsix bundles from the VS Code Marketplace: (traeide.com)

  • You can install extensions either:
    • Directly from the Trae store, or
    • By downloading a .vsix from the VS Code Marketplace and dropping it into the Trae extension panel.
  • You can disable or uninstall extensions from the same interface.

For external tools and APIs, Trae supports the Model Context Protocol (MCP) and exposes a marketplace of MCP servers: (DataCamp)

  • This lets Builder or custom agents talk to databases, REST APIs, or internal tools.
  • A special “Builder with MCP” mode ensures MCP-enabled tools are only loaded when needed to control token usage.

Source control is integrated similarly to VS Code, with Git operations available inside the IDE; Trae can also generate or review commits as part of its agentic workflows. (traeide.com)

4. Correcting, Creating and Building Code with Trae: End-to-End Flow

To illustrate how Trae works on Windows in practice, consider a typical cycle: fix a bug, add a feature, run the build.

4.1. Fixing a Bug

  1. Reproduce the bug in Trae’s integrated terminal.
  2. Capture context:
    • Select the error stack trace in the terminal and click “Add to Chat”. (traeide.com)
    • Add the relevant code file with #File or highlight the function and add it as context.
  3. Explain and fix:
    • In Side Chat: “Explain the cause of this bug and propose a minimal fix following our existing coding style.”
  4. Review changes:
    • Trae either:
      • Proposes a patch via Inline Chat (diff view) for you to accept/reject line by line, (traeide.com)
      • Or modifies multiple files via Builder, listing each changed file.
  5. Re-run tests from the terminal or ask Builder to run them.
  6. Iterate if tests still fail; Trae can inspect the new output and refine its fix.

Because Trae can see both the code and the terminal output, it is particularly strong at debugging build failures or runtime exceptions.

4.2. Creating New Functionality

For a new feature (e.g. adding an API endpoint or a chess engine evaluation module):

  1. Describe the feature in Builder mode:
    • “Add an endpoint /games/{id} that returns a JSON summary of the game, including moves and evaluation, using our existing controller pattern.”
  2. Let Builder work:
    • It reads the project structure, finds relevant controllers, serializers and routes, and proposes how to integrate the new feature. (traeide.com)
  3. Inspect the generated code:
    • Trae creates or edits files and shows you the changes.
  4. Refine via Inline Chat:
    • On each file, you can ask for further optimization, improved comments, or stricter type hints.

If you only need a small utility function, you may use comment-based completion or the Trae Plugin comment-driven flow in VS Code/JetBrains, where a natural-language comment generates a complete function or method body. (traeide.com)

4.3. Building and Testing

On Windows, builds are typically run through the integrated terminal, but Builder can orchestrate build commands as part of its workflow: (traeide.com)

  • For example, in a C++ project:
    • Builder runs cmake --build . or ninja as appropriate.
    • It reads the compiler output and suggests corrections if build errors occur.
  • In a Python or Node.js project:
    • Builder can run pytest, npm test, or npm run build and adjust code based on failures.

In SOLO mode, this can extend into full CI-style pipelines: plan → implement → test → deploy. (DataCamp)

5. Trae vs Codex: A Technical Comparison

“Codex” today refers both to:

  • The original OpenAI Codex model (now superseded by GP-t 3.5/4/5 for coding tasks) (Wikipedia)
  • The newer GPT-5 Codex and Codex coding agent, integrated into GitHub Copilot and available as a CLI/VS Code extension in the broader Copilot ecosystem. (Visual Studio Code)

For clarity, this section compares Trae AI (Trae IDE + Trae Plugin) with the modern Codex ecosystem as experienced via GitHub Copilot and the Codex coding agent.

5.1. Integration Model

  • Trae AI
    • Trae IDE is a VS Code fork with deep AI integration: all features (Builder, chat, multimodal, MCP) are built into the editor itself. (DataCamp)
    • Trae Plugin integrates similar capabilities into existing IDEs (VS Code, JetBrains). (Skywork)
  • Codex (via GitHub Copilot & Codex agent)
    • GitHub Copilot is implemented as extensions for VS Code, Visual Studio, JetBrains and other environments. (GitHub)
    • The new Codex agent is likewise delivered as a CLI tool and as a VS Code extension, integrated into the unified agent experience Microsoft is building across Copilot tools. (Visual Studio Code)

Implication:
Trae IDE offers a single, cohesive AI-native environment, while Codex emphasizes broad editor coverage and tight integration with GitHub workflows.

5.2. Model Access and Multimodality

  • Trae AI
    • Provides access to multiple foundation models, including Claude 4 Sonnet, Gemini 2.5 Pro, Grok 4, and Kimi K2, selected within the IDE. (DataCamp)
    • Multimodal inputs (text + images) are supported directly in chat, and rule files plus MCP integration give models a rich context. (traeide.com)
  • Codex / GitHub Copilot
    • Uses OpenAI models (now including GPT-5 variants and GPT-5 Codex), plus other vendors (Gemini, Claude) depending on configuration. (GitHub Docs)
    • Copilot supports multimodal inputs (code + natural language + images), particularly in “smart mode”, and can automatically route between models for speed vs depth.

Implication:
Trae’s multi-vendor model access is explicit inside the IDE, while Copilot relies on Microsoft’s orchestration and GitHub’s settings. Both ecosystems are multimodal, but Codex is more deeply embedded in Microsoft’s broader AI stack.

5.3. Feature Set for Programming

Code generation & completion

  • Both Trae and Codex provide:
    • Inline completions.
    • Comment-driven function generation.
    • Multi-line completions at cursor position. (traeide.com)

Code correction and refactoring

  • Trae:
    • Inline Chat with diff view and selective accept/reject per hunk. (traeide.com)
    • Builder mode that can revise multiple files and re-run commands. (traeide.com)
    • Plugin features like one-click bug fix and refactoring. (Skywork)
  • Codex/Copilot:
    • Inline editing and refactoring commands (e.g. “fix this” or “refactor”) integrated into the editor.
    • With GPT-5 Codex, agent mode can autonomously execute editor commands, run tests and modify code bases in a more autonomous manner. (Visual Studio Code)

Testing and documentation

  • Trae:
    • Trae Plugin offers automated unit test generation (e.g. for a selected function/class). (Skywork)
    • Builder can create README files and structured documentation as part of its multi-step workflow. (DataCamp)
  • Codex:
    • GitHub Copilot can generate tests and documentation from prompts; the Codex agent takes this further by proposing test suites and integrating with CI workflows via GitHub. (Wikipedia)

Agentic workflows

  • Trae:
    • Builder and SOLO mode focus on end-to-end software engineering from within the IDE, including deployment to platforms like Vercel. (traeide.com)
  • Codex:
    • Codex agent and GitHub Copilot agent mode target similar agentic capabilities, but heavily integrated with GitHub repos, pull requests and CI/CD, often from within VS Code and the GitHub UI. (Wikipedia)

5.4. Pricing and Licensing

  • Trae AI
    • Trae IDE uses a subscription model (e.g. around $10/month with an introductory discount in some periods) with a quota of “fast requests” and unlimited “slow requests” to premium models. (DataCamp)
    • Trae Plugin is, as of late 2025, free to use, which makes it extremely attractive for students and hobbyists. (Skywork)
  • Codex / GitHub Copilot
    • GitHub Copilot is a paid subscription product with individual, business and enterprise tiers; pricing is structured per user per month. (GitHub)
    • Codex agent features are bundled into Copilot Pro+ or higher tiers.

Implication:
For developers who want an AI coding assistant on Windows with minimal cost, the Trae Plugin currently offers very good value. For organisations already invested in GitHub and Microsoft 365, Codex via Copilot may still be the natural choice despite subscription fees.

5.5. Privacy and Governance

  • Trae:
    • Being part of the ByteDance ecosystem, Trae has raised privacy concerns, particularly around cloud-based processing and the possibility of using user code and interactions for model training. (El Futuro Inteligente)
    • There is no self-hosted enterprise edition at the time of writing; sensitive code bases may therefore be unsuitable.
  • Codex/Copilot:
    • GitHub Copilot provides enterprise-grade compliance, with options like data-exclusion, private model endpoints and Microsoft’s standard security posture. (GitHub)

Implication:
For open-source or non-sensitive projects, Trae’s privacy trade-offs are often acceptable. For regulated industries or highly confidential code, Codex via GitHub Copilot or self-hosted alternatives may be more appropriate.

5.6. Target Users

  • Trae AI is particularly attractive for:
    • Individual developers on Windows seeking an AI-native IDE.
    • Users switching from Cursor/Windsurf looking for similar or stronger agentic workflows at lower cost. (DataCamp)
    • Developers who want to mix and match frontier models (Claude, Gemini, etc.) directly from within the editor.
  • Codex (Copilot) is particularly attractive for:
    • Teams deeply integrated with GitHub, Azure, or Microsoft 365.
    • Enterprises needing compliance, detailed governance and centralised model policy.
    • Developers who prefer to keep their existing editor stack and simply add AI as another extension.

6. Objective Conclusion: When Does Trae AI Make Sense?

From a technical and operational perspective, Trae AI and Codex serve overlapping but distinct roles in AI-assisted programming:

  • Trae AI on Windows offers:
    • A cohesive AI-native IDE (Trae IDE) that feels like a supercharged VS Code fork.
    • A free, capable plugin for VS Code/JetBrains that delivers intelligent completion, bug fixing, refactoring and test generation.
    • Strong agentic workflows via Builder and SOLO, with MCP integration, rule files, and rich workspace indexing.
    • Multi-model access (Claude, Gemini, Grok, etc.) and multimodal input.
  • Codex (via GitHub Copilot and Codex agent) offers:
    • Wide editor support and deep integration with GitHub repositories, pull requests and CI/CD.
    • Enterprise-grade privacy and governance, strongly aligned with Microsoft’s cloud ecosystem.
    • Mature, continuously updated model routing, including GPT-5 Codex and other frontier models.

If you are an individual developer or a small team on Windows looking for an AI tool that can:

  • Write new code from natural language,
  • Correct and refactor existing code with clear diffs,
  • Orchestrate builds and tests through an agentic Builder,

then Trae AI (especially Trae IDE + Trae Plugin) is a highly capable option with a relatively low cost of entry.

If you are working in a corporate, compliance-driven environment or your workflow is tightly anchored to GitHub and Microsoft tooling, Codex via GitHub Copilot remains, in practice, the safer institutional choice.

In objective terms, Trae’s strengths lie in its AI-first design and strong agent modes, whereas Codex’s strengths lie in ecosystem integration, governance, and maturity at scale. For many Windows developers, the practical path will be to experiment with both—using Trae IDE as a sandbox for agentic workflows and Codex/Copilot where organisational policies require it—and to adopt the combination that best aligns with their technical needs, privacy constraints and budget.

Jorge Ruiz

Jorge Ruiz

Filólogo y amante de la antropología social africana

SÍGUEME
Tags:

Leave a Reply

Your email address will not be published. Required fields are marked *