AI coding assistants, such as GitHub Copilot and Claude, are rapidly changing the way software is built. These agent-based development tools can generate code and accelerate development workflows. These tools can generate scaffolding, suggest code, and accelerate development workflows.

However, when working with specialized software development kits (SDKs) and complex components, generic AI often lacks the detailed knowledge required to generate correct implementations. Consequently, developers often have to guide the AI with lengthy prompts, documentation references, or repeated instructions.

At Text Control, we are actively working to make development with TX Text Control easier in the age of AI assisted programming.

Alongside the introduction of Text Control Agent Skills, we have released the Text Control MCP Server. This server exposes more than 30 developer tools to AI assistants. These tools provide access to documentation, a blog search, and other resources to help AI agents find the right information when generating code.

Together, Agent Skills and the MCP server provide a robust foundation for AI-aware development with TX Text Control.

This article introduces Text Control Agent Skills, which enable AI coding assistants to learn how to correctly build applications with the TX Text Control Document Editor and its APIs.

What Are Agent Skills?

Agent Skills are an emerging open standard designed to extend AI agents with reusable workflows and domain specific expertise.

Instead of prompting an AI assistant with lengthy instructions every time, developers can provide structured skill definitions that describe how a task should be performed.

A skill typically includes:

• Task Description: A clear explanation of the task the skill is designed to perform.
• Instructions: Detailed steps that guide the AI through the process of completing the task.
• References: Links to documentation, code examples, or other resources that provide additional context.

When a developer requests that an AI assistant perform a task, the assistant scans the available skills in the workspace. If a matching skill is found, the assistant loads the instructions and follows the defined workflow.

This enables AI assistants to serve as component-aware development partners rather than general-purpose code generators.

Introducing Text Control Agent Skills

The Text Control Agent Skills repositories provide structured skills that teach AI assistants how to build applications using TX Text Control.

Currently two repositories are available. One focuses on building applications with the TX Text Control Document Editor and its JavaScript APIs, while the second repository focuses on server side document processing using ServerTextControl.

TX Text Control Document Editor Skills

Skills that teach AI assistants how to build web applications using the TX Text Control Document Editor and its JavaScript APIs.

https://github.com/TextControl/txtextcontrol-document-editor-skills

TX Text Control ServerTextControl Skills

Skills that guide AI assistants when implementing server side document processing workflows using ServerTextControl, including document generation and MailMerge scenarios.

https://github.com/TextControl/txtextcontrol-servertextcontrol-skills

Available Text Control Skills Repositories

The current Text Control Agent Skills ecosystem consists of two repositories that cover different parts of the platform.

Learn more

Discover the latest ServerTextControl skills for AI-assisted document processing, enhancing your Text Control Agent capabilities. Learn how these new skills can streamline your workflow and improve efficiency in handling documents.

Expanding Text Control Agent Skills: New ServerTextControl Skills for AI Assisted Document Processing

Rather than having the AI guess how to integrate the editor or how specific APIs behave, the skills provide structured instructions that guide the AI through the correct implementation process.

This helps developers:

• Bootstrap working applications faster
• Generate reliable example code
• Avoid common configuration mistakes
• Follow recommended integration patterns

The goal is simple: Make AI assisted development with TX Text Control reliable and predictable.

Example Skill: Create a Document Editor Application

One of the included skills shows how to build a complete ASP.NET Core document editor application.

It contains instructions for an AI assistant to generate a working editor application using TX Text Control.

The workflow includes the following steps:

• Creating a new ASP.NET Core project
• Installing the required NuGet packages
• Configuring the TX Text Control Document Editor
• Setting up WebSocket communication
• Running the editor inside a browser

When a developer prompts the AI assistant with a request like:

Create an ASP.NET Core application using the TX Text Control Document Editor.

the assistant can automatically load the skill and generate a complete working project.

Example Skill: Working with Comments in the Document Editor

Another skill focuses on using the Document Editor API to work with comments.

These comments are commonly used in collaborative document review workflows.

This skill teaches the AI how to:

• Add comments to a document
• Retrieve comment information
• Work with comment metadata
• Use the Document Editor APIs correctly

Since the instructions are part of the skill, the AI generates code that adheres to the proper API usage patterns rather than guessing how the feature works.

For example, when a developer asks the AI assistant:

Add buttons to a floating toolbar with icons to add and manipulate comments.

The assistant can then load the comments skill and generate code that correctly implements the requested functionality. This is the Copilot chat results:

The final result is a working implementation of comment manipulation in the Document Editor, generated by the AI assistant using the structured instructions from the skill.

Document Editor API Tasks

The txtextcontrol-document-editor-api skill provides tasks that teach AI assistants how to interact with the Document Editor JavaScript API. These tasks focus on common document editing workflows that developers typically implement in web applications.

The following tasks are currently available.

When to Use Text Control Agent Skills

Text Control Agent Skills are especially useful when working with AI coding assistants in development workflows.

Typical scenarios include:

• Bootstrapping Projects: Quickly generate working applications using TX Text Control without needing to write detailed prompts.
• Learning the APIs: Get AI-generated code that follows best practices and correct API usage patterns.
• Accelerating Development: Let the AI handle routine implementation details while you focus on higher-level design and logic.

How to Set Up Text Control Agent Skills

The Text Control Agent Skills follow the open Agent Skills structure. This structure organizes each skill as a self-contained folder containing instructions and reference documentation.

The skills repositories is available here.

https://github.com/TextControl/txtextcontrol-document-editor-skills

https://github.com/TextControl/txtextcontrol-servertextcontrol-skills

1. Clone the Repository

   Start by cloning the repository or downloading it as a ZIP archive.

   git clone https://github.com/TextControl/txtextcontrol-document-editor-skills

   The repository contains a skills directory with multiple Text Control skills.

   Example structure:

   skills/
    ├── txtextcontrol-aspnetcore-document-editor/
    │    ├── SKILL.md
    │    └── references/
    │         └── create-a-document-editor-application.md
    │
    ├── txtextcontrol-document-editor-api/
    │    ├── SKILL.md
    │    └── references/
    │         └── work-with-comments-in-document-editor.md

   Each skill contains two key parts.

   • SKILL.md: This file contains the main instructions that guide the AI assistant through the implementation process.
   • References: This folder contains additional documentation and code examples that provide context and support for the instructions in SKILL.md.

2. Add the Skills to Your Workspace

   In order to make the skills available in your AI development environment, copy the skill folders into a directory that your agent environment scans for skills.

   Typical supported locations include:

   .github/skills/
   .claude/skills/
   .codestudio/skills/

   Example workspace layout:

   my-project/
    ├── .github/
    │    └── skills/
    │         ├── txtextcontrol-aspnetcore-document-editor/
    │         └── txtextcontrol-document-editor-api/
    ├── src/
    ├── README.md

   Once the skills are in place, your AI assistant will automatically discover them when you start a new chat session.

3. Start a Chat Session and Use the Skills

   With the skills available in your workspace, you can now start a new chat session with your AI assistant.

   When you ask the assistant to perform a task related to TX Text Control, it will automatically scan the available skills for relevant instructions.

   If a matching skill is found, the assistant will load the instructions and follow the defined workflow to generate code that correctly implements the requested functionality.

Continuous Expansion of the Skills Library

The initial release focuses on skills for the TX Text Control document editor.

However, this is only the beginning.

We plan to continuously expand the repository to include additional skills that cover other parts of the Text Control platform. These include:

• ServerTextControl for server-side document processing
• MailMerge workflows for automated document generation
• Additional Document Editor APIs and automation scenarios

Over time, these additions will create a comprehensive library of AI-ready development workflows for Text Control.

Try the Text Control Agent Skills Today

You can explore the skills repository on GitHub:

Text Control Agent Skills Repository

As AI powered development continues to evolve, structured workflows like Agent Skills will play an important role in making AI generated code accurate, reliable, and component aware.