Introducing Text Control Agent Skills

ASP.NET AI ASP.NET Core Document Editor Skills

Bjoern Meyer

March 27, 2026

With the introduction of Text Control Agent Skills, AI coding assistants can now understand how to correctly work with the TX Text Control Document Editor and its APIs. This means that developers can now ask their AI coding assistants to write code that interacts with the Document Editor, making it easier than ever to create powerful applications with TX Text Control.

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 are preparing to release 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 repository provides structured skills that teach AI assistants how to build applications using TX Text Control.

TX Text Control Skills

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

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

This skills package provides proven workflows and implementation patterns for the TX Text Control Document Editor.

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:

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.

Comments UI

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.

Topic	Tasks
Application Fields	Check whether an application field can be added, insert application fields, retrieve the current field, retrieve fields by ID, list fields, update field content, remove fields.
Comments	Add comments for selections or positions, reply to comments, retrieve the current comment, list comments, navigate between comments, delete comments.
Editable Regions	Add editable regions, retrieve regions at the current position, read region metadata, navigate between regions, update user settings, remove editable regions.
Footnotes	Add footnotes at the current cursor position, retrieve footnote information, navigate to footnotes, update footnote formatting settings, remove footnotes.
Form Fields	Insert text fields, checkboxes, selection fields and date fields, retrieve form fields by name or ID, get the current form field, list form fields, remove form fields.
Headers and Footers	Add headers and footers, retrieve specific headers or footers, activate or deactivate them, update layout settings such as distance and connection to previous sections, remove headers or footers.
Images	Add inline or anchored images, retrieve selected images, retrieve images by ID, update image properties, scale images, remove images.
SubTextParts	Add subtextparts, retrieve the current subtextpart, read metadata, navigate between subtextparts, rename subtextparts, remove subtextparts.
Tables	Check whether tables can be inserted, insert tables, retrieve tables by ID, list tables, select tables, remove tables.
Track Changes	Enable and disable track changes, check the current track changes status, retrieve the current tracked change, navigate tracked changes, accept or reject changes.

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 repository is available here.

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

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.
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.
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.

Download and Fork This Sample on GitHub

We proudly host our sample code on github.com/TextControl.

Please fork and contribute.

Download ZIP

Open on GitHub

Open in Visual Studio

Requirements for this sample

TX Text Control Document Editor
AI Coding Assistant

ASP.NET

Integrate document processing into your applications to create documents such as PDFs and MS Word documents, including client-side document editing, viewing, and electronic signatures.