cc-1c-skills and giving a coding agent the 1C:Enterprise vocabulary

The problem is that 1C is XML and the model does not know the XML

The project description says it plainly: the skills give the model ready-made abstractions over the XML formats and the configurator CLI, so it works on the substance of the task rather than on the implementation details. Web testing gives it eyes and hands for interacting with the 1C interface.

That is the whole idea, and it is a specific kind of idea. A general-purpose coding agent that has never seen 1C:Enterprise 8.3 does not know what an external data processor is, does not know that its source is a directory of XML files with a particular naming convention, and does not know that the configurator has a command line for loading a configuration into an infobase. It will guess, and in a platform where the metadata is XML with 23 object types, guessing produces files that look right and are not.

The scope is the full development cycle on the platform, according to the README: creating configurations, extensions, external data processors and reports, then loading the changes into an infobase, updating, launching, publishing to a web server with a portable Apache build, testing through the web client, and recording video instructions.

The target audience is AI agents, primarily Claude Code, and the README is explicit that the project is alive and actively developed, with new capabilities, bug fixes and optimisation.

Seventeen skill groups, one per platform object family

The skill catalogue is the substance of the project, and the README groups it into seventeen families with a guide document linked for each, and the per-group skill counts are given alongside.

External data processors, the EPF group, have 7 skills under the /epf-* prefix for creating, building, disassembling and validating processors from XML sources. External reports, ERF, have 4 /erf-* skills for the same cycle. There are also universal operations, /template-add, /template-remove, /help-add and /form-remove, for adding or removing templates, forms and help for any object.

The rest follow the platform's object model. The tabular document group, MXL, has 4 /mxl-* skills for analysing, creating and compiling print form layouts. Managed forms, /form-*, have 6 skills covering creation, analysis, generation, modification and validation. Roles, /role-*, have 3 skills for analysing role rights, creating from a JSON DSL and validating. Layout schema, SKD, has 4 /skd-* skills. Configuration metadata, /meta-*, has 5 skills for creating, analysing, editing, deleting and validating metadata objects across 23 types. Root configuration, /cf-*, has 4. Extensions, CFE, have 5 for creation, borrowing, method interception, validation and analysis. Subsystems have 4, the command interface has 2 for editing and validating CommandInterface.xml, and XDTO packages have 5.

The largest group is databases, with 13 /db-* skills covering creating infobases, loading and unloading configurations, database updates, loading from Git, configuration storage, and managing extensions inside a database. Web publishing has 4 /web-* skills for publishing through Apache, checking status, stopping and removing publications.

The web-test skill is doing three jobs at once, which is unusual. It handles interaction with the 1C web client, covering navigation, forms, tables and reports. It records video instructions with subtitles, highlighting and text-to-speech narration. And it runs an automatic regression of the configuration, with tests, checks, reports and a run after changes.

Two utility skills sit alongside, /img-grid for a grid overlay on an image to determine column proportions, and /v8-xsd-fetch for downloading the platform's XSD schemas to validate exports.

Installing: copy the directory, add a plugin, or run the installer

There are three installation routes, and they suit different situations.

The simplest is to copy the .claude/skills/ directory from the repository into the root of your project. The skills become available when Claude Code is launched from that directory.

The second is as a Claude Code plugin, which is how you get updates rather than a frozen copy:

/plugin marketplace add https://github.com/Nikolay-Shirokov/cc-1c-skills
/plugin install 1c-skills@cc-1c-skills        # PowerShell (Windows)

The third is the install script, which clones the repository and runs a switch script. It offers a copy mode, described as the recommended one, where the skills are an independent copy and you update by running it again, and a link mode, described as experimental, where updates arrive through a git pull:

git clone https://github.com/Nikolay-Shirokov/cc-1c-skills.git tools/cc-1c-skills
python tools/cc-1c-skills/scripts/switch.py claude-code --project-dir .
python tools/cc-1c-skills/scripts/switch.py claude-code --project-dir . --link
python tools/cc-1c-skills/scripts/switch.py

The last form runs interactively, letting you pick the platform, the installation method and the runtime step by step. There is an OpenAI Codex plugin route too, with a marketplace add and a plugins command.

The README makes a point about not needing to memorise commands and parameters, since you can describe the task in your own words and Claude picks the right skills. Slash commands such as /epf-init with a name are also available for exact control.

PS and Py: the same skills in two runtimes

Every skill exists in two variants, and the choice is a real fork rather than a packaging detail.

PS is the version with PowerShell scripts, described as the standard and the one for Windows. Py is the version with Python scripts, for when PowerShell does not work. The README says you can start with PS, since that is the main variant.

The repository maintains separate branches per agent platform and per runtime: for Claude Code there is a main branch for PS and a port-claude-code-py branch for Py, and the same pairing exists for Cursor and Codex, with port-cursor, port-cursor-py, port-codex and port-codex-py.

The runtime requirements follow from that. Windows with PowerShell 5.1 or later is the default runtime. 1C:Enterprise 8.3 is needed for building and disassembling external processors and reports, although the XML generation skills work without the platform. Node.js 18 or later is needed for /web-test, because that skill tests through a browser.

The Python runtime has its own small dependency set, and it is narrow. The requirements file lists lxml at 4.9.0 or later for the DOM skills that edit, validate, inspect and compile, Pillow at 10.0.0 or later for /img-grid, and psutil at 5.9.0 or later for the web skills that manage Apache. The file's own comment gives the install command as pip install -r requirements.txt.

The lxml dependency is the one to notice, because it is the reason the DOM-oriented skills can edit XML trees rather than treating them as text.

Agent Skills as an open standard, and the release cadence

The portability story rests on a published specification rather than on the author's own tooling. The README states that the skills are built on the open Agent Skills standard and are compatible with any platform that supports that format, and gives the fastest path as downloading a ready-made build for your platform from the branch list and unpacking it into the root of your project.

The platform table maps each supported agent platform to a target directory, though the table is cut off in the version of the README available here. What is visible is the pattern: each platform has its own branch, and each branch has a release archive you can download rather than clone.

The release naming is unusual and worth understanding. The tags are w-2026-10-04, w-2026-09-06 and w-2026-08-23, and the release titles are week ranges in Russian, for example the weeks of 7 September to 4 October 2026. So the project cuts a release roughly weekly, and the version number tells you which week the snapshot is from.

The repository is not archived and the last push was on 2026-10-20, so the work is current. The licence is MIT.

The repository layout is more than a set of skill files. There is a .claude directory with the skills themselves, a .claude-plugin directory for the plugin packaging, an .agents directory, a hooks directory, a scripts directory holding the switch script, a tests directory, a docs directory with the per-group guides, a requirements.txt, and a .v8-xsd directory holding the platform schemas.

Where this approach stops helping

There are limits that are not fixable by adding more skills.

The first is platform. 1C:Enterprise 8.3 is a Windows-centric business application platform, and the default runtime is Windows with PowerShell. The Python port exists, but the platform itself, the configurator CLI and the web client all still assume a Windows host in practice. A team on Linux or macOS is working with a port of the tooling, not with a natively supported setup.

The second is the breadth. Roughly seventy skills covering seventeen object families is a large surface, and the README's own point that you do not need to memorise the commands cuts both ways. A skill set this size is easier to adopt wholesale than selectively, and the risk of an agent picking a plausible-looking skill for the wrong object type is real. The slash command form, /epf-init with a name, is the escape hatch, and the README points at it for exactly this reason.

The third is the boundary of the abstraction. The skills cover the XML formats and the configurator CLI. They do not cover the business logic inside a configuration, and nothing in the README claims they would. An agent that can build a valid external processor has still not written your accounting logic.

The last is the dependency on the platform for a subset of the work. Building and disassembling external processors needs 1C:Enterprise 8.3 installed, even though generating the XML does not, which means part of the value is only reachable on a machine with the platform present.

Editorial conclusion

cc-1c-skills is a good fit for a team already developing on 1C:Enterprise 8.3 and already using an AI coding agent, because the skills encode the platform's XML and CLI details that a general-purpose model has no reason to know, and because the web-test skill gives the agent a way to drive the actual client interface. It is a poor fit for a team that is not on Windows with PowerShell 5.1 or later, and a poor fit if you need the platform installed, since some skills need 1C:Enterprise itself. Before adopting, count how many of the skill groups map to work you actually do, pick the PS or Py variant of the branch that matches your platform, and read the requirement that 1C:Enterprise 8.3 is needed for building and disassembling external processors even though XML generation works without it.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Nikolay-Shirokov/cc-1c-skills on GitHub
4. README
5. Releases