5.1. AI Assistants¶
AI-powered assistants are rapidly becoming indispensable for developers - providing suggestions and automated features that help in writing code more efficiently and accurately. As popularity for these features continues to increase, so does the demand for development environments that can provide such functionality. AI code assist functionality is available with CCStudio™ IDE using functionality bundled with the IDE, as well as numerous third-party AI code assist extensions available on Open VSX. CCStudio IDE also offers MCP (Model Context Protocol) servers that enable AI assistants to interact directly with the CCStudio IDE project and debug servers, allowing for more integrated and context-aware development workflows.
Caution
AI assistants are designed to assist developers by providing suggestions and automating certain tasks. However, they are not perfect and may occasionally provide incorrect or suboptimal suggestions. It is important for developers to critically evaluate the suggestions provided by AI assistants and use their own judgment when deciding whether to accept or modify those suggestions.
5.2. How the AI Integration Works¶
The integration is built on open standards so that you can use the agent and model you prefer, and so that the integration keeps working as the AI landscape changes. CCStudio IDE does not include or require a specific model. You bring your own agent, and CCStudio IDE provides what that agent needs to be effective on TI devices.
The integration has four parts:
Part |
What it is |
What it gives the agent |
|---|---|---|
AI agent |
A coding agent such as Claude Code or Codex, running as an extension. |
The conversation, reasoning and planning. |
MCP servers |
Programs, started by CCStudio IDE, that expose CCStudio IDE functionality as tools using the Model Context Protocol (MCP). |
The ability to act: build, configure, debug and communicate with the target. |
Guidance files |
A central guide ( |
The knowledge to act correctly: workflows, rules, pin assignments, device specifics. |
Skills |
Packaged, multi-step workflows for common TI tasks. |
Reliable procedures for tasks such as migrating a project or measuring code coverage. |
5.2.1. What happens when you enable the integration¶
When you configure an AI assistant, CCStudio IDE performs the following steps for you:
Installs the agent. The extension for the agent you selected is installed if it is not already present.
Registers the MCP servers. The agent's configuration is updated so that it can start and use the CCStudio IDE MCP servers.
Configures the agent. The agent's instruction file (for example
CLAUDE.mdorAGENTS.md) is updated to direct the agent to read the CCStudio IDE central guide before it starts any TI-related task.Makes skills available. TI-provided skills are made available to the agent.
Sets up access to your model. You supply the model provider settings and credentials (see AI Assistant Configurator).
Steps 1 to 5 are performed by the AI Assistant Configurator (Help > Get Started with AI).
5.2.2. Your choice of agent and model¶
Industry-standard agents. Claude Code and Codex are supported out of the box. Other agents that support MCP can use the CCStudio IDE MCP servers with manual configuration (see Using other AI Assistants).
Your model provider. Use your own subscription or API key, or a provider approved by your organization.
Data stays under your control. The MCP servers run on your machine and communicate with your agent locally. Organizations that must keep data inside their network can use a locally hosted or on-premises model (see Data Privacy and Information Handling).
5.2.3. Why tool access matters¶
Done correctly the first time with SysConfig. Hand-writing device configuration code is error-prone and often takes several failed attempts. Through the SysConfig MCP server, the agent can see exactly what can be configured, the valid values for each setting, and any errors or conflicts as soon as it makes a change. It corrects problems immediately, and the result is a validated configuration rather than a guess.
Verifying its own work with debug access. With access to the debugger, an agent can load the program on a board, run it, stop at breakpoints, and inspect variables, registers and memory. Instead of guessing why something fails and iterating blindly, it can find the root cause from the program's actual runtime state and verify that its fix works.
Good information. Documentation and examples are the ground truth for an agent. CCStudio IDE points the agent to SDK documentation and examples, and to TI-authored board and SDK guidance, so that it produces correct results faster and with less back-and-forth.
5.3. CCStudio IDE MCP Servers¶
CCStudio IDE provides four MCP servers. Each server exposes a set of tools that the agent can call. You normally do not call these tools yourself: you describe what you want in the chat, and the agent chooses which tools to use.
Server |
Name in agent |
Purpose |
|---|---|---|
Project |
|
Import, inspect, configure and build projects |
Debug |
|
Run and debug programs on a target |
SysConfig |
|
Read, change, validate and save device configuration |
Serial |
|
Communicate with the target over a serial (UART) port |
Note
The MCP servers are active only while CCStudio IDE is running and a workspace configured for AI is open. They are stopped when CCStudio IDE is closed or when the integration is disabled.
5.3.1. Project server (ccs-project)¶
Lets the agent work with CCStudio IDE projects the same way you do in the IDE, so that builds use the project's real settings and toolchain.
Capabilities
List projects in the workspace and read their properties (device, build configuration, toolchain, SDK references).
Import example projects from SDKs (
.projectspecfiles) and existing projects, copy and rename projects.Build a project and return compiler and linker output, including structured errors.
Read and change compiler and linker options (for example optimization level, include paths and defines).
Report the SDKs, compilers and tools that are installed, and the versions a project uses.
Change the SysConfig version used by a project.
Example prompts
"Import the
emptyexample for my LP-MSPM0G3507 and build it.""Build the project and fix any errors."
"Turn on
-O2for the Release configuration."
Note
The agent is instructed to build only through this server and not to edit project metadata files (such as .project, .cproject or .ccsproject) directly. This keeps the project in a consistent state.
5.3.2. Debug server (ccs-debug)¶
Gives the agent control of a debug session on real hardware.
Capabilities
Detect connected boards and debug probes; start, list and end debug sessions.
Load programs and symbols; reset, run, pause and step (into, over, out).
Set, list and clear breakpoints.
Inspect call stacks and local variables; evaluate expressions and registers.
Read and write target memory.
Read the console (CIO), debug output and GEL output views.
Use the profile clock to count cycles and other events.
Example prompts
"Debug the project, break at
main, and tell me the value ofcounterafter ten iterations.""The LED never blinks. Find out why."
"Rebuild, reload and run the updated program."
Note
Only one CCStudio IDE debug session can be active at a time. If more than one board is connected, the agent can use the ti-ccstudio-use-specific-board skill to pin the project to one debug probe.
5.3.3. SysConfig server (ccs-sysconfig)¶
Lets the agent configure a device through SysConfig without editing .syscfg files by hand.
Capabilities
Open a
.syscfgfile and list available modules.Add and remove module instances; read and change configuration values.
Report errors and warnings as configuration changes are made.
Manage connections between module instances and inspect clock-tree configuration.
Save the configuration and review the generated source files.
Migrate a configuration to a different device, package or variant.
Inspect example
.syscfgfiles from an SDK for guidance.
Example prompts
"Add a UART at 115200 baud on the backchannel pins."
"Why does my SysConfig file report an error?"
"Migrate this configuration to a different device in the same family."
Caution
Hand-edited .syscfg files can build successfully and still behave incorrectly on the hardware. The agent is instructed to use only this server to read and change .syscfg files.
5.3.4. Serial server (ccs-serial)¶
Lets the agent exchange data with the target over a UART, for example to read application output or to send commands to a command-line interface on the device.
Capabilities
List serial ports and connect to TI devices (including the XDS110 backchannel UART).
Read and write serial data, and wait for a text pattern (for example a boot message or a test result).
Save serial output to log files for later searching.
Example prompts
"Run the program and show me what it prints on the serial port."
"Send
helpto the device's CLI and summarize the commands."
Note
The serial settings must match the UART configuration in the project. By default the server uses 115200 baud, 8 data bits, no parity, which suits most TI SDK examples.
5.3.5. Using the MCP servers with other agents¶
The MCP servers use the standard MCP protocol. If you use an agent other than Claude Code or Codex, see Using other AI Assistants for the command line used to start each server.
5.4. Skills¶
A skill is a packaged set of instructions that teaches an agent how to carry out a specific, repeatable task. Where the MCP servers give the agent individual abilities, skills give it a proven procedure that combines them: which questions to ask, which steps to run in what order, what to check along the way, and when to stop and ask you.
CCStudio IDE includes the following skills.
Skill |
Use it to |
Section |
|---|---|---|
|
Migrate an embedded firmware project from another vendor's microcontroller to a TI device. Step 1 of the migration workflow. |
|
|
Verify the migrated project on real hardware. Step 2 of the migration workflow. |
|
|
Produce a code coverage report for a project built with a TI Clang compiler. |
|
|
Check whether BoosterPack™ plug-in modules can be used with a LaunchPad™ development kit. |
|
|
Lock a project to one debug probe when several boards are connected. |
The agent selects a skill automatically when your request matches the skill's description, or you can request one by name.
Tip
Skills work best when your request includes the key inputs, such as a project path or a part number. If an input is missing, the skill asks for it.
5.4.1. Migrating a Project to a TI Device¶
Moving an existing firmware project to a new microcontroller is a large task. The peripherals are different, the driver APIs are different, and the pin assignments, clocks, interrupts and memory map all have to be redone. The migration workflow breaks this into two skills that you run in order:
ti-ccstudio-migrate-to-tianalyzes your project, writes a migration plan for your approval, then creates a new CCStudio IDE project for the TI device, configures it, ports the code and builds it.ti-ccstudio-test-migrationthen helps you verify the result on a real board. It is described in the next section.
The result of the migration skill is a project that builds. It is a starting point that you review and test, not a finished product. The test-migration skill exists because a successful build says nothing about whether the ported code behaves correctly on hardware.
5.4.1.1. You own the migration¶
The migration skill is an assistant. It does the repetitive work and proposes a result, but you own the process and the outcome. The skill reminds you of this in three places: in a notice shown when it starts, in the plan approval step, and in a banner at the top of the generated migration-report.md.
The notice shown when the skill starts says, in summary:
Migration Assistant - The assistant helps you migrate this project to a TI device. It is used as part of an AI-assisted process. TI does not access, collect, or store any input or output of this process. Your prompts, data, and results stay in your own environment and with whatever AI model you choose to use. You retain full ownership of your code. Any libraries or components remain subject to their original licenses. The tool is provided as is, and results will not always be correct or complete. It is up to you to review and confirm that any output is accurate, complete, secure, and right for your needs before you use or rely on it.
In practice, this means:
You make the decisions. The skill asks you to choose the board, package and variant, and to approve the plan before anything is created. You can change the plan, or stop, at that point.
You review the result. A project that builds is not a correct project. Review the ported code and the migration report.
You verify the details the skill cannot. Confirm pin assignments against the target board schematic. Verify clock and baud-rate calculations. Treat the SDK documentation as the authoritative reference for API usage.
You test on hardware. Test the ported code on a board. The test-migration skill helps with this (see Testing a Migrated Project on Hardware), but you still decide when the result is good enough.
You are responsible for licenses. Libraries and components remain under their original licenses. The skill detects licenses from file headers, which is not a legal review, so check the license notes in the report before you distribute the result.
Caution
AI-generated code can be wrong in ways that are not obvious and that still compile. Do not use a migrated project in a product until you have reviewed it and tested it on hardware.
5.4.1.2. Before you start¶
Install the TI SDK for the target device. The skill locates the installed SDK. If the SDK is not installed, the skill installs it as part of project creation.
Have the source project in a folder on your computer. The skill only reads it. It never modifies, moves or deletes anything in the source folder.
Know your target part number, for example
MSPM0G3507. If you use a TI LaunchPad, the skill can also select the board.Open an empty workspace folder for the migration. The skill saves its plan next to where it runs and creates the new project there.
5.4.1.3. How the migration works¶
The skill is an orchestrator. It does not do the work in one long conversation. Instead it runs a series of specialized sub-agents one after another, each starting with a clean context and a narrow job. This keeps each step focused and avoids the quality loss that happens when one agent holds a very large amount of code, documentation and history at once. The state that carries from step to step lives in two files in your workspace, not in the agent's memory.
Phase |
What happens |
Result |
|---|---|---|
|
The skill shows a notice and asks for any missing inputs: the source project path and the target part number. |
Inputs |
|
Finds the installed SDK for the part, and asks you to choose when there is more than one option: which device variant, which LaunchPad (or a bare device or custom board), and which package. |
SDK, board, package |
|
Inspects the source project: the family and part, build system, peripherals and pins in use, middleware, memory use, source licenses, and which files to copy. It reads files by pattern and does not need a complete understanding of every file. |
Source summary |
|
Compares the source against the TI device and SDK using TI's migration guides. Writes |
|
|
Runs the plan step by step (see below). |
New project, |
|
Marks the project as built but not yet tested on hardware, and points you to the report and the test skill. |
Report |
5.4.1.3.1. The plan and your approval¶
The planner produces migration-plan.md in the workspace folder and prints its assessment. The assessment is a set of flags to help you decide, not a pass or fail gate. It covers:
How the source peripherals map to the TI device's peripherals, and anything that has no direct equivalent.
Whether the program fits in the target's flash and RAM.
Behavioral differences that matter, such as different interrupt, low-power, or timing behavior.
Pin compatibility between the source and the chosen TI package, with a pin translation table.
Source files that carry a license that requires special handling (see Licenses).
Known risk areas, listed as named items.
The plan also lists the work in order: one step to create the project, then for each area (a peripheral group such as GPIO, UART, SPI or the core/clock setup) a configure step followed by a port step, and a final build step. You can see exactly what will happen before it does.
You are then asked to choose one of:
Yes, proceed. Create the TI project and start porting.
Tweak the plan. Describe what to change, for example drop an area, choose a different package or device, or reorder steps. The plan is regenerated and presented again. You can also edit
migration-plan.mddirectly, for example to rename the new project. Nothing is created until you proceed.Abort. Stop and keep the plan for later.
5.4.1.3.2. Executing the plan¶
For each step in the plan, a sub-agent does the following.
Create the project. Imports a suitable SDK example project into the workspace as the foundation. For most migrations, this is the minimal ("empty") example for the board. When the application's behavior must be reproduced rather than edited (see Edit mode and regenerate mode), the closest functional example is used instead. The agent then copies your source files into the new project, and creates
migration-report.mdinside it.Configure each area. Configures the TI device for that peripheral group.
For projects configured with SysConfig, the agent uses the SysConfig MCP server to add and set up the modules (for example a UART at the baud rate your source used), checks for errors, and saves the
.syscfgfile so that the configuration source files are generated.For projects that use devicetree and Kconfig (Zephyr), the agent edits the devicetree overlay and
prj.conffiles instead.
Port each area. Updates your source code for that area to use the TI SDK APIs, using the configuration generated in the previous step and TI's peripheral-by-peripheral migration guides.
Build and fix. After all areas are ported, one agent builds the project and works through compile and link errors until it builds, applying fixes and rebuilding as needed. Real migrations often need several rounds of fixes, which is normal.
Each step is recorded as it completes. At the end of each area and each build, the agent summarizes what it did.
5.4.1.3.2.1. Edit mode and regenerate mode¶
Where the source and target are similar in shape (for example, one bare-metal driver model to another), the skill edits your code in place, replacing the vendor-specific calls with TI equivalents. Where they are structured differently (for example, a project built on one RTOS and its devicetree-bound drivers moving to another RTOS), line-by-line editing is not possible. In that case the skill regenerates each area by adapting a TI SDK example to reproduce the behavior of your code. It keeps your original code wherever it can, such as helper functions, protocol logic and constants, and rewrites only the parts that depend on the original RTOS or driver model. If keeping the code and keeping the behavior conflict, behavior takes priority. The planner chooses the mode and records it in the plan.
5.4.1.3.2.2. Licenses¶
Your source project may include third-party code with its own license. The migration looks at the license header of each file and handles it as follows. Detection is based on header patterns. It is not a legal review.
Permissive license. The file is migrated normally.
Restrictive license on library code. The file is not copied or read. The skill instead reconstructs the affected peripheral behavior from TI's SDK documentation only, a "clean-room" approach, and says so in the plan. If the documentation alone does not give enough information, the skill asks you to describe in your own words what the excluded file does. Only your description is used. The agent never reads the original file.
Restrictive license on example or application code. The file is ported and built so that you can see the application work on the TI device, but it is flagged as something you must rewrite before distributing or using in production.
5.4.1.4. Resuming¶
The migration can span more than one session, and you can stop at any time.
The plan is the intent. The report's Migration Checklist records what has been done. Each step is ticked when it finishes.
If you start the skill again in the same workspace, it detects the existing plan and asks whether to Resume from the first unfinished step, Start over (deletes the plan and report and plans a fresh migration), or Abort.
The steps are safe to repeat. Re-running a partially completed step reuses the project, configuration and files that already exist.
If a step fails, the skill reports what went wrong. It retries when it can fix the cause, such as re-dispatching after a transient failure, and otherwise stops and leaves the files on disk so you can resume.
5.4.1.5. What you get¶
Item |
Where |
Contents |
|---|---|---|
New CCStudio IDE project |
Workspace folder |
The TI project that builds with the ported code, with its SysConfig file (or devicetree overlay and |
|
Workspace folder |
The assessment, the project and SDK details, the memory comparison, the pin translation, and the ordered steps. |
|
Inside the new project |
The record of what was done: project details, peripheral summary, the SysConfig configuration, pin assignments, API mappings, code porting notes, license notes, unsupported features, and the checklist. |
Note
The report begins with an AI-Assisted Migration banner that repeats the notice shown when the skill started: the report was generated by an AI assistant, you retain ownership of your code, and you are responsible for reviewing and confirming the result before relying on it.
Open migration-report.md before relying on the port. In particular, review License Notes
(files with non-permissive or unknown license terms), and under Code Porting Notes the items
marked as clean-room regeneration (reconstructed from documentation and not verified against the
original) and those marked "rewrite required before distribution".
When the build succeeds, the skill sets the report status to Build verified - hardware testing pending. It leaves the Tested on hardware checklist item unticked. That item is ticked by the test skill.
5.4.1.6. Example¶
Open an empty workspace folder in CCStudio IDE.
Ask the agent: "Migrate the project in
C:\work\blinkyto MSPM0G3507."Read the disclaimer. Answer any questions about board and package.
Review the assessment and the plan. Choose Yes, proceed.
When the build completes, review
migration-report.md.Start a fresh conversation (for example with
/clearin Claude Code) and run the test-migration skill.
Tip
Starting a fresh conversation before testing keeps the migration's context from crowding out the hardware-testing work.
5.4.2. Testing a Migrated Project on Hardware¶
ti-ccstudio-test-migration is the second half of the migration workflow. A migrated project that builds has not been shown to work. Pins may be assigned differently, timing may differ, and the behavior of the ported drivers may not match the original. This skill helps you test the migrated project on a real board, tailored to the equipment you have, and records the results.
Run it in the same workspace as the migration, after ti-ccstudio-migrate-to-ti has finished, because it reads migration-plan.md and migration-report.md to learn what was migrated. It does not perform the migration itself.
Note
As with the migration, the testing skill is an assistant and you stay in charge. The test report begins with an AI-Assisted Testing banner that tells you to verify all pass and fail results, and any fixes the skill applied, against the target hardware before relying on the migration in production. You confirm each wiring step, and you decide whether to accept a failed or skipped test.
Caution
Hardware can be damaged by incorrect wiring. Reversed polarity, a signal pin connected to a supply rail, or mismatched voltage levels can destroy a board. The skill displays this warning when it starts, and pauses for you to confirm every physical connection before any test runs. Check each connection against your board schematic.
5.4.2.1. How the testing works¶
Phase |
What happens |
Result |
|---|---|---|
|
Checks for an unfinished test session in the workspace and offers to resume it. |
|
|
Shows the hardware warning and reads the compact project details from the migration report. |
|
|
Detects the connected board and debug probe, and asks how you want to test (see below). |
Inputs |
|
If you use a bench instrument, researches how to control it and saves a profile. Skipped otherwise. |
Instrument profile |
|
Writes the test plan. You review and approve it. |
|
|
Optional. Creates a standalone, runnable test project from the plan. |
Test project |
|
Runs each test in order, fixing and rebuilding when a test fails. |
|
|
Records the outcome and updates the migration report. |
Final status |
5.4.2.1.1. Choose a testing mode¶
The skill asks what you want help with.
I have existing tests. You tell the skill how to run your tests (the command, the working directory and what counts as pass or fail). It builds a plan around them, runs them, and helps you debug and fix failures.
Help me create a test plan. You do not have tests yet. The skill builds a test plan from what was migrated, such as one test per migrated peripheral area, and can generate a test framework for it.
In the second mode, you also say what test resources you have:
Resource |
What the skill can do with it |
|---|---|
JTAG access |
Load and run the program, halt it, and read variables and memory with the debug server. |
Serial access |
Send and receive data over the UART with the serial server. |
Bench instrument |
Drive and measure real signals with an oscilloscope, logic analyzer or signal generator. The Digilent Analog Discovery 3 is supported with built-in knowledge, and a USB logic analyzer such as the Saleae Logic can be named. Other instruments can be named too, and the skill researches how to control them. |
Only one bench instrument can be used per run.
5.4.2.1.2. The test plan and your approval¶
The plan, migration-test-plan.md, is saved inside the new project. It contains the test strategy, the ordered list of test cases, and, when you have no existing tests, a Fixed Wiring Setup. This section lists every connection to make once for the whole session (for example, jumper wires between two pins for a loopback test, or which instrument channel connects to which pin). The plan also states an estimated target I/O voltage, and shows where the estimate came from, so that you can check it against the board before any signal is driven.
Each test case is marked as one of:
Automatic. The skill can run it and judge the result by itself.
Stub. The test is described but cannot be automated yet. The skill records it as a stub and continues.
Cases that need you to do something physical list their steps, and the skill prompts you for them.
You then choose what to do with the plan.
With existing tests: Proceed, Tweak the plan, or Abort.
When creating tests: Generate a test framework, Tweak the plan, or Stop here. If you stop, the plan on disk is a checklist you can follow yourself, and you can run the skill again later to pick it back up.
5.4.2.1.3. Generating a test framework¶
If you choose to generate a framework, the skill asks which language and test framework to use. JavaScript with Mocha is the default recommendation, and Python with pytest is also offered. You can name another. The skill creates a standalone test project, including a README with the command to run it. If the framework or the instrument needs software that is not installed, the skill lists what is missing and how it would be installed, then asks you to choose: install it for you, install it yourself, or continue without instrument automation. It installs nothing without your permission.
Because the generated project stands alone, you can re-run the tests yourself later, with no AI agent present, for example before each release.
5.4.2.1.4. Running the tests¶
Before the first test runs, the skill prints the Fixed Wiring Setup and asks you to make the connections and confirm. Once you confirm, all tests in the session then run without further wiring prompts. If you resume in a later session, it asks again, because the physical setup may have changed.
The skill then runs the tests in order, and for each test it:
Loads and runs the program on the target as needed.
Observes the result through the debugger, the serial port, or the instrument.
If a test fails, investigates, applies a fix to the migrated code, rebuilds, and tries again.
Ticks the test in the Test Checklist in
migration-test-report.mdwhen it passes.
Some fixes are deferred rather than applied automatically, such as reassigning a pin. When that happens the skill explains the recommendation and asks whether to apply the fix, skip the test, or accept the result as is. If an instrument is not available (not connected, runtime not installed, or in use by another program), you are asked to fix the problem and retry, or skip the test.
5.4.2.1.5. Finalizing¶
When all tests have passed, or you accept the remaining results, the skill:
Sets the test report status to Complete.
Ticks Tested on hardware in
migration-report.mdand updates its status, but only if at least one test actually passed on hardware.Prints a summary of how many tests passed, how many failures you accepted, and how many fixes it applied.
If it changed any code during testing, lists the changes and recommends that you re-test everything.
Test progress is saved as it goes. If the session ends part way, run the skill again in the same workspace to resume from the first unfinished test.
Note
Some targets have limited debug automation. For example, projects built on devicetree and Kconfig may use fewer of the automatic debugger-based tests. The skill sets its expectations from the project it finds.
5.4.3. Code Coverage¶
ti-ccstudio-clang-code-coverage generates a code coverage or profiling report for a project built with the TI Arm Clang or TI C29 Clang compiler. It shows which lines, functions and branches of your program ran while the program ran on the target. It is useful for measuring how much of your code a test run exercised, and for finding code that never runs.
The skill automates a flow that is otherwise manual: the compiler is instrumented to count execution, the counters are read back from the target's memory, and the compiler tools convert them to a report.
What it does
Adds the coverage options. Adds the compiler options for instrumentation to every build configuration. You can also choose optional modes: MC/DC (modified condition/decision coverage) for safety-oriented analysis, function-level coverage only (less overhead), or smaller 32-bit counters (less target memory).
Rebuilds the project fully, so that every file is instrumented, and checks that the options were applied.
Runs the program on the target. The skill starts a debug session and runs the application. You decide how long it runs, so that you can exercise the code paths you want to measure, and tell the skill when to stop.
Reads the counters from the halted target. The skill reads the counter memory while the debug session is still open, because ending the session can let the processor run briefly and skew the counts. It then saves the data to a file.
Generates the report. The compiler's profile and coverage tools convert the data into an HTML report that you can open in a browser. The report is branded, and is placed in a
coverage_reportfolder next to the program. Several runs can be merged into one report.Offers to remove the coverage options. If you accept, the options are removed from every configuration, and the project is rebuilt and checked, so that the code you ship is not instrumented.
Requirements: a project that uses the TI Arm Clang or TI C29 Clang compiler, and a board that can be debugged from CCStudio IDE.
Note
Instrumented code is larger and slower. The instrumented build needs extra flash and RAM for the counters. Do not ship an instrumented build.
Example prompt: "Generate a code coverage report for my project. I will tell you when I have finished exercising the program."
5.4.4. BoosterPack Compatibility Check¶
ti-ccstudio-check-bp-compatibility checks whether one or more BoosterPack plug-in modules can be used with a LaunchPad development kit. It compares the pin assignments of the LaunchPad with those of each BoosterPack, and reports where they clash. Use it when choosing a BoosterPack for a LaunchPad, or when you want to stack more than one.
The skill uses the board guidance files that CCStudio IDE provides (see Board and SDK Knowledge) and does not change any file.
What it does
Finds the board data for the LaunchPad and each BoosterPack. A board without data is marked as unknown, and the check continues with the boards it has.
Asks which LaunchPad signals you do not need, such as the backchannel UART, the debug (SWD) pins, the LEDs or the buttons, so that it can leave out warnings about pins you will not use.
Compares each connected BoosterPack pin with the LaunchPad function on the same pin.
Compares the BoosterPacks with each other when you give more than one.
Reports the result.
How results are classified
Result |
Meaning |
|---|---|
Conflict |
The pins cannot be used together as they are. For example, the BoosterPack uses a pin that is hard-wired on the LaunchPad to an LED, button, or flash chip, or two stacked BoosterPacks use the same pin for different functions. Where the LaunchPad documentation mentions a resistor or jumper that can free the pin, the report includes the hint. |
Warning |
The pin can probably be used, but check it. Examples are a pin that the LaunchPad also routes to the backchannel UART or debug pins, a general-purpose pin the LaunchPad could repurpose, and two BoosterPacks sharing a bus such as SPI, which may be intentional. |
Unknown |
The skill could not determine the function of a pin from the guidance file, so it does not guess. |
Compatible |
No problem was found. |
Example prompt: "Is the BOOSTXL-EDUMKII compatible with the LP-EM-CC1314R10?"
Note
The check is as good as the board guidance it reads. Treat the result as a way to find problems early, then confirm against the board schematics before you build hardware.
5.4.5. Using a Specific Board¶
ti-ccstudio-use-specific-board configures a project to always use one particular debug probe. When several boards are connected at once, the debugger cannot tell which board a project should use, and debugging or flashing fails with a probe-selection error. This skill fixes that by saving the probe's serial number in the project's target configuration (.ccxml file). It does not change anything on the board.
What it does
Finds the target configuration in the project, and the device it is for.
Lists the connected debug probes and picks out those that match the project's device.
Decides what to do based on what is connected:
No matching board connected: offers to save a serial number you type, for example before the hardware arrives.
One probe connected: explains that selecting a probe is optional, and asks whether to configure it anyway for when you add more boards.
One matching board among several probes: configures the project for that board.
More than one matching board: shows the serial numbers and asks you to choose. It never picks one for you.
Writes the serial number into the target configuration, replacing any previous setting.
Verifies the file and reports the file that changed and the serial number that was set.
After this, every debug session and flash for the project uses that probe. Run the skill again with a different serial number to change it.
Example prompt: "I have two LaunchPads connected. Make this project always use the one with serial number L40001BC."
5.5. Board and SDK Knowledge¶
Agents produce much better results when they know the specifics of your hardware. CCStudio IDE provides this knowledge in three kinds of files that the agent reads automatically:
Central guide (
CCS.md): Describes how the agent should work with CCStudio IDE: the workflow for modifying or creating projects, the rules for using each MCP server, and rules such as never changing SDK content. The agent is directed to read this file before any TI-related task.SDK guidance (
AGENTS.md): For supported SDKs, describes the SDK's structure, drivers, examples and conventions, with optional supplemental guides for peripherals and software stacks.Board guidance (
AGENTS.md): For TI LaunchPad and BoosterPack boards and other evaluation modules, describes the pin assignments, the UART backchannel, LEDs, buttons, onboard sensors and jumper settings.
When you say "my LaunchPad" or name a specific board, the agent uses this information to select the right pins and settings rather than relying on general knowledge that may be wrong for that board.
Note
These files are installed with CCStudio IDE under its AI resources folder and are updated with CCStudio IDE. They are read-only reference material for the agent.
5.6. AI Assistant Configurator¶
The AI Assistant Configurator view allows you to configure and manage supported AI coding assistants. Agents configured through this view will have access to specific information provided by CCStudio IDE to provide the agent the information and context it needs to fully automate development flows.
You can access this view by using the Set up an AI assistant link from the Get Started view or by navigating to Help > Get Started with AI.
The AI Assistant Configurator view appears as below:
5.6.1. Step 1: Select Agent¶
The first step in configuring an AI coding assistant is to select the Agent you want to use. Currently, only Claude Code and Codex is supported, but more agents will be added in the future.
If the extension for the selected agent is not already installed, it will be installed automatically. Please ensure the proxy is configured correctly in CCStudio IDE to allow for the installation of the extension.
The Enable checkbox is used to enable or disable the selected agent. When selected, the agent will be available for use in CCStudio IDE. When unselected, the agent will not be available for use, and any existing configuration will be preserved but not active. You can enable or disable the agent at any time by using the Enable checkbox. Disabling the agent will not remove any existing configuration and will not uninstall the extension, and you can re-enable the agent later to restore its functionality.
5.6.2. Step 2: Connection Settings¶
After selecting the Agent, configure the Connection Settings.
Select the Provider from the available options. The list of available options with vary depending on the Agent selected. After selecting the provider, additional fields will appear to allow you to provide the necessary information to connect to the provider's services.
Select the Scope for the Connection Settings. You can choose to apply the settings to the current workspace (Workspace) or to your entire system (Global). The settings file path will be automatically populated based on the selected scope. The Settings File is where your configuration will be saved. If you select Workspace, the settings will be saved in a file within your current workspace. If you select Global, the settings will be saved in a global configuration file that applies to all workspaces. Any existing configuration file will be automatically detected and loaded when the relevant scope is selected. If no existing configuration file is found, a new one will be created when you apply your settings.
Warning
Any settings stored in the Workspace will always override any settings stored in the Global configuration file. This allows you to have different configurations for different workspaces, while still maintaining a global default configuration that can be used when a workspace-specific configuration is not available. Even if the AI Assistant Configurator view is used to configure settings at the Global level, any workspace that has settings configured at the Workspace level will override the global settings when that workspace is active.
The below parameters are used to connect to the provider's services and configure the AI assistant:
Auth Token / API Key: Enter the token/key for the selected provider to authenticate your access to the AI model.
Base URL: Provide the base URL for the API endpoint of the selected provider.
Custom Headers / HTTP Headers: If the provider requires any custom headers for API requests, you can add them here.
Model: Choose the specific AI model you want to use for code assistance.
If you have already configured your model for this agent and provider in the past, this information will be automatically populated with the relevant information for the selected Scope. If you have an existing subscription with the provider and wish to use those credentials, the above connection parameters can often be left blank.
Note
Depending on your environment, not all of these parameters may be applicable/needed. Please refer to the provider's documentation and/or your local IT department for instructions.
5.6.3. Step 3: Enable MCP servers¶
To allow the AI assistant to interact with CCStudio IDE functionality, you need to enable the MCP (Model Context Protocol) servers. This can be done by checking the Enable CCStudio IDE ecosystem MCP servers option in the configuration view. Enabling this option allows the AI assistant to access CCStudio IDE functionality such as building, debugging, monitoring, and controlling SysConfig.
MCP servers are only active when CCStudio IDE is running and a workspace configured for AI functionality is active. When enabled, the configuration will attempt to start the MCP servers automatically. The servers are stopped when CCStudio IDE is closed or when the option is disabled.
Once all the steps are complete, press the Apply button to enable AI functionality for the current workspace and save your configuration. If the Claude Code or Codex extension is not already installed, it will be installed automatically.
Note
Claude Code: Only the Claude Code extension is installed by CCStudio IDE. The Claude Code desktop and CLI terminal is not installed as part of this process. If you wish to use the desktop version of Claude Code, it will need to be installed separately. Note that some features of the Claude Code extension may require the desktop version to be installed and running.
Warning
CCStudio IDE will install the latest available version of the Claude Code or Codex extension. Due to the frequent updates to the extension, there may be occasional issues with new versions. If you encounter any issues after installation, please refer to the FAQ for troubleshooting steps and potential workarounds.
The AI coding assistant is now configured for use within CCStudio IDE with the current workspace. If using Claude Code, open Claude Code with the Open Claude Code link or with the menu option View > Claude Code Chat to start using the assistant. If using Codex, open Codex with the Open Codex link or with the menu option View > Codex to start using the assistant.
5.7. Using Claude Code¶
Important
Claude Code requires Git to manage the local repository that it uses to store conversation history and other relevant data. Please ensure Git is installed and properly configured on your system before using Claude Code.
Once the Claude Code extension is installed and configured, you can start using it to assist with your coding tasks. To open the Claude Code chat interface, use the Open Claude Code link in the AI Assistant Configurator view or navigate to View > Claude Code. This will open the chat interface where you can interact with the Claude Code assistant.
If a subscription will be used and the Auth Token and Base URL fields were left blank, the below login prompt will appear in the chat interface:
Select the relevant option to log in to your account and authenticate the connection between the AI assistant and your subscription. Once authenticated, the AI assistant will be able to access the configured model and provide code assistance based on that model.
Once the AI assistant is set up and authenticated, you can start using it to assist with your coding tasks. You can ask questions, request code suggestions, or seek help with debugging and other coding tasks. The assistant will provide responses based on the context of your project and the information you provide in the chat. You can also use the chat interface to manage your conversation history and access other features provided by the Claude Code extension.
For more information on using the Claude Code extension and its features, please refer to the Use Claude Code in VS Code documentation.
Tip
For tips and best practices on using Claude Code with CCStudio IDE, please refer to the Supercharge development with AI-powered CCStudio™ IDE video series.
5.8. Using Codex¶
Important
Codex requires Git to manage the local repository that it uses to store conversation history and other relevant data. Please ensure Git is installed and properly configured on your system before using Codex.
Once the Codex extension is installed and configured, you can start using it to assist with your coding tasks. To open the Codex chat interface, use the Open Codex link in the AI Assistant Configurator view or navigate to View > Codex. This will open the chat interface where you can interact with the Codex assistant.
If a subscription will be used and the API Key and Base URL fields were left blank, the below login prompt will appear in the chat interface:
Select the relevant option to log in to your account and authenticate the connection between the AI assistant and your subscription. Once authenticated, the AI assistant will be able to access the configured model and provide code assistance based on that model.
Once Codex is set up and authenticated, it required to set up the Codex Agent sandbox to allow Codex to execute code in a safe and controlled environment. Press the Set up button to configure the sandbox environment. This will allow the Codex to execute code and perform actions on your behalf without giving it unrestricted access to your machine.
The below message should appear after the set up process is complete:
Once the set up is completeyou can start using it to assist with your coding tasks. You can ask questions, request code suggestions, or seek help with debugging and other coding tasks. The assistant will provide responses based on the context of your project and the information you provide in the chat. You can also use the chat interface to manage your conversation history and access other features provided by the Codex extension.
For more information on using the Codex extension and its features, please refer to the Use Codex in VS Code documentation.
5.9. Agent Configuration Files¶
When Claude Code or Codex is launched with the agent enabled, it automatically generates a configuration file (CLAUDE.md for Claude Code or AGENTS.md for Codex) in the workspace directory to provide context and guidelines for the AI agent. These files are always read by the respective agents at the start of each session to understand the workspace context and constraints.
5.9.1. File Structure¶
Both configuration files follow the same structure:
Auto-populated content (between "DO NOT EDIT" comments): This section is automatically populated when the agent is launched and cleared when it is shut down. The auto-populated content provides CCStudio IDE-specific context such as installation directories, device-specific information, and mandatory requirements for interacting with CCStudio IDE. This ensures the agent has the most current and accurate CCS-specific information available.
User instructions section (below "User instructions" comment): Any custom content you add in this section will be preserved across sessions, allowing you to maintain persistent instructions and guidelines for how the agent should behave within your workspace. This allows you to customize agent behavior on a per-workspace basis by adding your own instructions, preferences, and guidelines.
Warning
Any content placed between the "DO NOT EDIT" comment markers will be automatically cleared when CCStudio IDE is shut down, even if the agent has been disabled. To ensure your custom instructions and guidelines are preserved, always add them below the "User instructions should be added below this line" comment. Only content in this section will persist across sessions.
5.9.2. Example Content¶
Below is an example of the structure and content that appears in these configuration files:
<!-- DO NOT EDIT - This part is automatically generated. -->
# Agent Guidelines
## CCStudio IDE Installation Directory
CCStudio IDE is installed at `C:/ti/ccs2100`. Save it as `{ccs-install-dir}` for the session — scripts and tools will need it.
## MANDATORY Pre-Task Requirement (DO NOT SKIP)
**CRITICAL - NO EXCEPTIONS**: Before ANY CCS/Texas Instruments-related task (even simple ones), you MUST read `C:/ti/ccs2100/ccs/theia/resources/ai/CCS.md`. This file includes information on how to interact with CCS as well as device-specific information (UART backchannel pins, LED setup, transmit best practices, etc.).
Do NOT call any ccs-project, ccs-debug, ccs-sysconfig, or ccs-serial MCP tools until CCS.md has been read.
<!-- DO NOT EDIT - This part is automatically generated. -->
<!-- User instructions should be added below this line -->
5.10. Using other AI Assistants¶
While Claude Code and Codex are the only AI assistants fully supported for use within CCStudio IDE, it is possible to use other AI assistants that are available as extensions on Open VSX. To use a different AI assistant, you will need to install the relevant extension from Open VSX and configure it according to the instructions provided by the extension developer. Once the extension is installed and configured, you can use it within CCStudio IDE to assist with your coding tasks. Please refer to the documentation for the specific AI assistant extension you are using for more information.
Please refer to the Using AI Code Assistants with CCStudio IDE documentation more details on some extentions tested with CCStudio IDE and instructions on how to get started with them.
Caution
Only Claude Code and Codex are fully supported out of the box with CCStudio IDE. While other AI assistants may work to some extent, they will not have the same level of integration or functionality as Claude Code and Codex when used with CCStudio IDE. Use at your own discretion when using other AI assistants with CCStudio IDE, and be aware that you may encounter issues or limitations when using assistants that are not fully supported.
Note that the CCStudio IDE MCP servers are designed to work with any AI assistant that supports the Model Context Protocol, so you may be able to use the MCP servers with other AI assistants as well. However, the level of integration and functionality may vary depending on the specific AI assistant and its capabilities. Claude Code and Codex are currently the only AI assistants that have been fully tested and verified to work with the CCStudio IDE MCP servers, so if you choose to use a different AI assistant, you may need to do some additional configuration and testing to ensure it works properly with CCStudio IDE.
To configure the MCP servers to work with a different AI assistant, you will need to refer to the documentation for that specific assistant to understand how to set up the connection and ensure compatibility with the Model Context Protocol. The below information provides the command and configuration file information for the MCP servers in CCStudio IDE, which will be required when configuring other AI assistants to work with CCStudio IDE:
Command:
[CCS INSTALL DIR]/ccs/tools/node/nodeArguments:
Debug MCP Server:
[CCS INSTALL DIR]/ccs/theia/resources/app/plugins/ccs-ai/extension/dist/mcp-server-proxy.js debugBuild MCP Server:
[CCS INSTALL DIR]/ccs/theia/resources/app/plugins/ccs-ai/extension/dist/mcp-server-proxy.js projectSysConfig MCP Server:
[CCS INSTALL DIR]/ccs/theia/resources/app/plugins/ccs-ai/extension/dist/mcp-server-proxy.js sysconfigSerial (UART) MCP Server:
[CCS INSTALL DIR]/ccs/theia/resources/app/plugins/ccs-ai/extension/dist/mcp-server-proxy.js serial
[CCS INSTALL DIR] refers to the directory where CCStudio IDE is installed on your system.
Below is the JSON configuration file that CCStudio IDE generates for MCP servers when using Claude Code. This configuration follows the standard MCP server format and can be adapted for use with other MCP-compatible AI assistants such as Cline:
{
"mcpServers": {
"ccs-debug": {
"__comment": "DO NOT MODIFY: Auto-generated properties",
"command": "C:\\ti\\ccs2100\\ccs\\tools\\node\\node",
"args": [
"C:\\ti\\ccs2100\\ccs\\theia\\resources\\app\\plugins\\ccs-ai\\extension\\dist\\mcp-server-proxy.js",
"debug"
]
},
"ccs-project": {
"__comment": "DO NOT MODIFY: Auto-generated properties",
"command": "C:\\ti\\ccs2100\\ccs\\tools\\node\\node",
"args": [
"C:\\ti\\ccs2100\\ccs\\theia\\resources\\app\\plugins\\ccs-ai\\extension\\dist\\mcp-server-proxy.js",
"project"
]
},
"ccs-sysconfig": {
"__comment": "DO NOT MODIFY: Auto-generated properties",
"command": "C:\\ti\\ccs2100\\ccs\\tools\\node\\node",
"args": [
"C:\\ti\\ccs2100\\ccs\\theia\\resources\\app\\plugins\\ccs-ai\\extension\\dist\\mcp-server-proxy.js",
"sysconfig"
]
},
"ccs-serial": {
"__comment": "DO NOT MODIFY: Auto-generated properties",
"command": "C:\\ti\\ccs2100\\ccs\\tools\\node\\node",
"args": [
"C:\\ti\\ccs2100\\ccs\\theia\\resources\\app\\plugins\\ccs-ai\\extension\\dist\\mcp-server-proxy.js",
"serial"
]
}
}
}
Note
Different AI assistants may use different MCP server configuration formats. The format shown above is the standard used by Claude Code and is compatible with other assistants like Cline. If you are using a different AI assistant, refer to that assistant's documentation for the correct configuration format.
It is also recommended to create an agent configuration file similar to the content generated by CCStudio IDE to get the most out of your AI assistant when using it within CCStudio IDE. This allows you to provide context-specific instructions and guidelines for the agent. Please refer to the Agent Configuration Files section for more details on how to structure and create your own configuration file.
Note
Different AI assistants use different configuration file formats and naming conventions. Some common formats include:
Claude Code: Looks for
CLAUDE.mdin the workspace root directoryCodex: Looks for
AGENTS.mdin the workspace root directoryOther AI Assistants: Check the specific assistant's documentation to determine the supported configuration file format(s) and the directory where it searches for the file. Most assistants look for configuration files in the workspace root directory, but this may vary.
When creating a configuration file for your AI assistant, ensure it follows the format expected by that specific assistant and place it in the location where the assistant looks for it (typically the workspace root directory). If you are unsure about the format or location for your AI assistant, refer to the assistant's documentation or extension marketplace page for more information.
An example of setting up an alternative agent (Cline) with CCStudio IDE is available in the Getting Started with Cline in CCStudio™ IDE application note.
5.11. Theia AI¶
Theia AI is an extension to the Theia IDE framework that integrates artificial intelligence (AI) capabilities to enhance the software development experience within the IDE. It comes bundled with CCStudio IDE and can be used as an AI coding assistant option. Please refer to the Theia AI section of the Using AI Code Assistants with CCStudio IDE documentation.
5.12. Training¶
Please refer to the Supercharge development with AI-powered CCStudio™ IDE video series for examples on effectively using Claude Code (configured with the AI Assistant Configurator view) within CCStudio IDE.
5.13. Data Privacy and Information Handling¶
When using an AI assistant with CCStudio IDE, it is important to understand how your code and data are processed and transmitted. This section explains the data flow and privacy considerations for AI-powered development workflows.
5.13.1. Local Processing¶
When you interact with an AI assistant in CCStudio IDE, the assistant runs locally within your IDE instance on your machine. Texas Instruments infrastructure does not process your code, queries, or project information. The MCP (Model Context Protocol) servers that enable AI assistants to interact with CCStudio IDE also run locally on your machine and are only active when CCStudio IDE is running.
5.13.2. Communication with Third-Party AI Providers¶
When you send a query to an AI assistant, the query and any code context you include are sent directly to the third-party AI model provider (such as Anthropic, OpenAI, or other configured providers). Texas Instruments does not act as an intermediary and has no involvement in these communications.
The specific information sent to the third-party provider depends on:
The question or request you submit to the AI assistant
Any code snippets, file contents, or project files you explicitly include or reference in your conversation
Context provided through MCP servers if you have enabled that functionality (such as project structure, build information, or debug session details)
Your conversation history (if retained by the AI assistant extension)
5.13.3. Third-Party Data Handling and Privacy Policies¶
How third-party AI model providers handle your data, including data retention, usage for model training, and other processing, is governed by their own privacy policies and terms of service. Texas Instruments does not control or determine how these providers handle your information.
For details on data handling practices, please refer to the privacy documentation provided by your configured AI model provider:
Anthropic (Claude Code): Visit Anthropic's privacy resources for information about how Anthropic handles data, conversations, and model usage.
OpenAI (Codex): Visit OpenAI's privacy policy and security documentation for information about their data handling practices.
Other Providers: Refer to the privacy documentation and terms of service provided by the specific provider or proxy service you have configured (such as LiteLLM or OpenRouter).
5.13.4. Locally Hosted Models¶
If you configure CCStudio IDE to use a locally hosted AI model (such as through a proxy service like LiteLLM pointing to a local deployment), your queries and code context remain on your local network and are not sent to external third-party providers. This configuration option provides enhanced data privacy if your organization has deployed local AI infrastructure.
When using locally hosted models:
Your code and queries are processed entirely within your organization's network
No data is transmitted to external cloud-based AI providers
You maintain complete control over where your data resides
You are responsible for the security, maintenance, and data handling practices of your local infrastructure
Refer to your organization's IT department or infrastructure documentation for guidance on setting up and using locally hosted AI models with CCStudio IDE.
5.13.5. Local Storage and Configuration¶
Your AI assistant configuration and conversation data are stored locally on your machine:
API keys and authentication tokens: Stored locally according to your selected scope (workspace-specific or global)
Conversation history: Retained locally by the AI assistant extension
MCP server configuration: Stored locally with workspace or global settings
Configuration files: Stored in your workspace settings or global configuration directory
This local data is not transmitted to Texas Instruments and remains under your control. You are responsible for protecting API keys and credentials, as these grant access to your third-party provider account.
5.14. FAQ¶
Please refer to the FAQs for answers to common questions and troubleshooting steps related to using AI coding assistants with CCStudio IDE.