Skip to content
Back to search

qt-skills-and-tools

MarketplaceWorks with Claude CodeGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/theqtcompanyrnd--agent-skills/badge.svg)](/listings/theqtcompanyrnd--agent-skills)

HTML

<a href="/listings/theqtcompanyrnd--agent-skills"><img src="/api/listings/theqtcompanyrnd--agent-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Most AI coding tools can install skills directly from this GitHub repository. Choose the method for your platform below.

Claude Code CLI

Install as a plugin using the Claude Code CLI plugin system:

/plugin marketplace add TheQtCompanyRnD/agent-skills
/plugin install qt-development-skills

Or install individual skills manually:

# Symlink a skill into your personal skills directory
ln -s "$(pwd)/skills/qt-qml-review" ~/.claude/skills/qt-qml-review

# Or copy into a project for team use
cp -r skills/qt-qml-review .claude/skills/qt-qml-review

# Review skills only: also install their review agents. The plugin
# install does this for you; a skill-only copy does not include agents/.
mkdir -p ~/.claude/agents
cp agents/cpp-review-agent.md agents/qml-review-agent.md ~/.claude/agents/

Without the agents, `qt-cpp-review` and `qt-qml-review` still work: they fall back to the general-purpose agent.

Claude Code auto-discovers skills — no restart needed.

Codex CLI

Use Vercel's cross-platform skill installer:

npx skills add TheQtCompanyRnD/agent-skills

Or copy skills manually:

cp -r skills/qt-qml-review ~/.codex/skills/qt-qml-review

Restart Codex after adding skills.

> **Note:** Codex is evolving rapidly. If `~/.codex/skills/` > does not work, try `~/.agents/skills/` or `.agents/skills/` > in your project root.

GitHub Copilot CLI

Copilot natively reads the same `SKILL.md` directory format as Claude Code. Install individual skills using GitHub CLI (preview):

gh skill install TheQtCompanyRnD/agent-skills qt-qml-review

Or copy/symlink the skill into one of Copilot's discovery paths:

# User-wide (available in any project)
cp -r skills/qt-qml-review ~/.copilot/skills/qt-qml-review

# Or scoped to a specific project
cp -r skills/qt-qml-review .github/skills/qt-qml-review

Copilot also auto-discovers skills installed for Claude Code under `.claude/skills/`, so a single install can serve both tools. Use `/skills list` inside Copilot CLI to confirm what loaded.

`qt-qml-test` also ships a self-contained Copilot variant in `skills/qt-qml-test/platforms/copilot.prompt.md`.

VSCode Agents (Copilot and others)

Run `Chat: Install Plugin From Source` from the Command Palette. Enter `https://github.com/TheQtCompanyRnD/agent-skills` (this repo) to clone and install

Gemini CLI

Install as an extension:

gemini extensions install https://github.com/TheQtCompanyRnD/agent-skills

Or import skills into your project's context file:

# Add to GEMINI.md (loaded automatically)
echo '@skills/qt-qml-review/SKILL.md' >> GEMINI.md

Cursor and Windsurf

Neither tool reads skill directories. Copy the skill in as a rule:

# Cursor: the full SKILL.md becomes a project rule
mkdir -p .cursor/rules/qt-qml-review
cp skills/qt-qml-review/SKILL.md .cursor/rules/qt-qml-review/RULE.md

# Windsurf: use the condensed variant from platforms/
mkdir -p .windsurf/rules
cp skills/qt-qml-review/platforms/windsurf.md .windsurf/rules/qt-qml-review.md

Windsurf variants exist for `qt-cpp-review`, `qt-qml-review`, `qt-qml-docs` and `qt-qml`. Scripts and subagents don't run on these tools, so only the static guidance applies.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 27 lines
  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "qt-skills-and-tools",
  4. "owner": {
  5. "name": "Qt Group",
  6. "email": "info@qt.io"
  7. },
  8. "metadata": {
  9. "description": "Official agentic engineering skills and tools for Qt software development",
  10. "version": "1.8.1"
  11. },
  12. "plugins": [
  13. {
  14. "name": "qt-development-skills",
  15. "description": "This plug-in contains agentic engineering skills for Qt software development, such as Qt C++/QML code review, QML coding, or Qt C++/QML code documentation skills, plus the hosted Qt Documentation MCP server for live Qt API lookups. The skills have been tested with frontier LLMs from the Claude, Gemini, and GPT LLM families. These agentic development skills use AI and can make mistakes. Always double-check the output carefully.",
  16. "source": "./",
  17. "version": "1.8.1",
  18. "author": {
  19. "name": "Qt Group"
  20. },
  21. "license": "BSD-3-Clause",
  22. "repository": "https://github.com/TheQtCompanyRnD/agent-skills",
  23. "category": "development",
  24. "keywords": ["qt", "code-review", "qml", "qt-quick", "development", "mcp", "documentation"]
  25. }
  26. ]
  27. }
README.md · README · 358 lines
  1. # Qt AI Skills
  2. Official agentic skills for Qt software development
  3. and quality assurance, designed for use with AI coding tools
  4. such as Claude Code, Codex CLI, and GitHub Copilot.
  5. Skills have been tested with frontier LLMs from the Claude,
  6. Gemini, and GPT model families.
  7. There is no settled industry standard for AI skill packaging.
  8. Each platform has its own conventions. Our canonical format
  9. uses `SKILL.md` with YAML frontmatter in a directory-based
  10. structure — this works natively on Claude Code, Codex CLI,
  11. and GitHub Copilot, and can be adapted to other platforms
  12. through condensed variants. See [CONTRIBUTING.md](CONTRIBUTING.md)
  13. for the full cross-platform story.
  14. > These agentic development skills use AI and can make mistakes.
  15. > Always double-check the output carefully.
  16. >
  17. > Before using the skills under Qt commercial licensing, make
  18. > sure you have understood and agree to the
  19. > [Qt AI Services Terms & Conditions](https://www.qt.io/terms-conditions/ai-services-2025-06).
  20. > By using the skills or MCP tools, you accept these terms &
  21. > conditions and that you have the right to do so on behalf of
  22. > your employer.
  23. ## Skills
  24. | Skill | Type | Description |
  25. |-------|------|-------------|
  26. | `qt-cpp-review` | Review | Deterministic linting + deep analysis for Qt C++ code (inline for small scopes, parallel shard agents above about 2,500 lines). Covers model rule compliance, memory ownership, thread safety, correctness, error handling, and performance. |
  27. | `qt-qml-review` | Review | Deterministic QML linting (48+ rules) + deep analysis (inline for small scopes, parallel shard agents above about 1,500 lines) for bindings, layout, loaders, delegates, states, and performance. |
  28. | `qt-qml` | Conceptual | QML best practices for writing, reviewing, fixing, and refactoring. Corrects systematic LLM pre-training biases around bindings, scoping, modules, JS interop, and types. |
  29. | `qt-canvas2d` | Conceptual | Qt Canvas2D (Qt 6.12+, Qt Canvas Painter) best practices for GPU-accelerated imperative 2D drawing in QML — gauges, charts, waveforms, freehand drawing. Corrects LLM confusion with the legacy Qt Quick `Canvas` and HTML5 `<canvas>` APIs |
  30. | `qt-ui-design` | Conceptual | UI design and audit for Qt/QML, web, and embedded (MPU/MCU) targets. Covers screen layout, navigation, and UX review with platform-aware defaults for geometry, viewing distance, input, and locale. |
  31. | `qt-qml-docs` | Process | Generates Markdown reference documentation for QML components and applications from .qml source files. |
  32. | `qt-cpp-docs` | Process | Generates Markdown reference documentation for Qt/C++ source files — classes, modules, utilities, headers, and entry points. |
  33. | `qt-qml-profiler` | Tool | Runs `qmlprofiler` on a 2D QML / Qt Quick application, parses the `.qtd` trace, and analyzes hotspots against the source code with frame-time, memory, and pixmap-cache summaries. Does not cover Qt Quick 3D. |
  34. | `qt-qml-test` | Process | Generates Qt Quick Test cases (`tst_*.qml`) for QML components using `TestCase`, `SignalSpy`, and `tryCompare`. Handles single files and batches. Does not cover CMake or runner setup. |
  35. | `qt-qml-test-run` | Tool | Builds and runs Qt Quick Test (`qmltestrunner`) tests for a CMake project, parses the JUnit XML, and writes a Markdown report. Opt-in CMake test-infrastructure wiring with `--wire-up`. Companion to `qt-qml-test`. |
  36. | `qt-figma-token-extraction` | Process | Extracts design tokens, text styles, and variables from a Figma design system and produces a design-tokens.json plus ready-to-use QML singletons. |
  37. | `qt-figma-component-generation` | Process | Extracts component metadata from a Figma design system and generates production-ready QML controls mapped to Qt Quick Controls 2 patterns. Requires tokens from `qt-figma-token-extraction`. |
  38. | `qt-cmake-project` | Conceptual | Sets up and manages Qt 6 projects built with CMake — fresh projects, executables, libraries, QML modules, plugins, folder layout, and static resources. Corrects systematic LLM biases around qmake-isms and the legacy `qt5_*` macros. |
  39. ### Skill types
  40. - **Review** — structured code review workflows combining
  41. deterministic linters with deep AI analysis
  42. - **Process** — workflows and decision frameworks
  43. (architecture, build, test, documentation)
  44. - **Conceptual** — mental model corrections for areas where
  45. LLMs consistently fail (declarative QML, C++/QML boundary,
  46. Widgets patterns, UI design)
  47. - **Tool** — guidance on Qt CLI tools and testing solutions
  48. ## MCP Tools
  49. | Tool | Description |
  50. |------|-------------|
  51. | `qt-documentation-mcp` | Hosted MCP server for Qt API documentation lookup across the latest release and active LTS branches. Bundled with the `qt-development-skills` plugin; also available standalone via the official MCP registry as `io.qt/qt-documentation-mcp`. |
  52. | `qml-live-preview-mcp` | A local MCP server that launches a Qt Quick application and live-previews QML edits in it, without a rebuild. |
  53. ### Qt Documentation MCP Tool
  54. See [`mcp/qt-documentation-mcp/README.md`](mcp/qt-documentation-mcp/README.md)
  55. for endpoint and manual setup instructions for AI clients other than
  56. Claude Code.
  57. ### QML Live Preview MCP Tool
  58. Read the [`Introducing the QML Live Preview MCP Tool for Agentic Development of Embedded Devices`](https://www.qt.io/blog/introducing-the-qml-live-preview-mcp-tool-for-agentic-development-of-embedded-devices) blog post to gain more information about the QML-Live-Preview-MCP-Server.
  59. See [`mcp/qml-live-preview-mcp/README.md`](mcp/qml-live-preview-mcp/README.md) for endpoint and manual setup instructions.
  60. ## Repository Structure
  61. ```
  62. skills/ # All skills live here
  63. qt-cpp-review/ # Each skill is a directory
  64. SKILL.md # with a SKILL.md entry point
  65. references/ # and optional reference docs
  66. lint-scripts/
  67. qt-review-checklist.md
  68. platforms/ # Platform-specific variants
  69. qt-qml-review/
  70. qt-qml/
  71. qt-canvas2d/
  72. qt-ui-design/
  73. qt-qml-docs/
  74. qt-cpp-docs/
  75. qt-qml-profiler/
  76. qt-qml-test/
  77. qt-qml-test-run/
  78. qt-cmake-project/
  79. mcp/ # MCP servers bundled with the plugin
  80. qt-documentation-mcp/ # Each server is a directory
  81. README.md # with its own README
  82. .mcp.json # MCP registration for Claude Code
  83. .claude-plugin/ # Claude Code CLI & Copilot CLI plugin config
  84. gemini-extension.json # Gemini CLI extension manifest
  85. docs/ # Source for the docs site (MkDocs)
  86. CONTRIBUTING.md
  87. LICENSE
  88. README.md
  89. ```
  90. ## Skill Format
  91. Every skill is a directory containing a `SKILL.md` file with
  92. YAML frontmatter. This format aligns with what Claude Code and
  93. Codex CLI support natively:
  94. ```yaml
  95. ---
  96. name: qt-qml-review
  97. description: >-
  98. Reviews QML source files for correctness, performance, and
  99. maintainability. Deterministic linting (48+ rules) plus
  100. deep analysis (parallel shard agents for large scopes) for
  101. bindings, layout, loaders, delegates, states, and performance.
  102. license: LicenseRef-Qt-Commercial OR BSD-3-Clause
  103. compatibility: >-
  104. Designed for Claude Code, GitHub Copilot, and similar agents.
  105. metadata:
  106. author: qt-ai-skills
  107. version: "1.0"
  108. qt-version: "6.x"
  109. ---
  110. ```
  111. ### Key conventions
  112. - **`name`** must be lowercase alphanumeric + hyphens, max
  113. 64 chars, and must match the directory name
  114. - **`description`** must describe what the skill does AND when
  115. to use it — front-load the key information in the first 250
  116. characters, as some platforms truncate beyond that point
  117. - **SKILL.md body** should stay under 500 lines — move detailed
  118. content to `references/` files
  119. - **Progressive disclosure**: agents load only
  120. `name`/`description` at startup, read `SKILL.md` body on
  121. activation, and pull `references/` files only when needed
  122. ## Multi-Tool Support
  123. Skills are authored to be tool-agnostic wherever possible.
  124. However, different AI coding tools consume skills in different
  125. ways:
  126. | Tool | Skill Location | Format | Notes |
  127. |------|---------------|--------|-------|
  128. | **Claude Code CLI** | `~/.claude/skills/` | SKILL.md + references (native) | Full directory model with progressive loading |
  129. | **Codex CLI** | `~/.codex/skills/` | SKILL.md + references (native) | Full directory model; registered in `~/.codex/config.toml` |
  130. | **GitHub Copilot** | `.github/skills/` or `.claude/skills/` (project), `~/.copilot/skills/` (personal) | SKILL.md + references (native) | Auto-discovered across Copilot CLI, coding agent, and VS Code; existing `.claude/skills/` setups Just Work |
  131. ### When platform-specific variants are needed
  132. Most skills work across tools without changes. When a skill
  133. needs to reach platforms that cannot read multi-file directories
  134. (e.g. Windsurf, Amazon Q), create variants in a `platforms/`
  135. directory:
  136. ```
  137. skills/qt-qml-review/
  138. ├── SKILL.md # Core skill (tool-agnostic)
  139. ├── references/
  140. │ ├── qml-lint-rules.md
  141. │ └── qml-review-checklist.md
  142. └── platforms/ # Platform-specific variants
  143. └── windsurf.md # Self-contained compact variant
  144. ```
  145. The `platforms/` directory is a convention for this repository.
  146. See [CONTRIBUTING.md](CONTRIBUTING.md) for full details on
  147. creating platform variants.
  148. Condensed variants and tools that can't run scripts or subagents
  149. give less thorough results. For example, GitHub Copilot loads only
  150. the static guidance of the review skills, without the linter or
  151. the deep-analysis agents. See
  152. [Requirements and platform support](docs/skills/requirements.md)
  153. for per-skill requirements and limits.
  154. ## Installation
  155. Most AI coding tools can install skills directly from this
  156. GitHub repository. Choose the method for your platform below.
  157. ### Claude Code CLI
  158. Install as a plugin using the Claude Code CLI plugin system:
  159. ```
  160. /plugin marketplace add TheQtCompanyRnD/agent-skills
  161. /plugin install qt-development-skills
  162. ```
  163. Or install individual skills manually:
  164. ```bash
  165. # Symlink a skill into your personal skills directory
  166. ln -s "$(pwd)/skills/qt-qml-review" ~/.claude/skills/qt-qml-review
  167. # Or copy into a project for team use
  168. cp -r skills/qt-qml-review .claude/skills/qt-qml-review
  169. # Review skills only: also install their review agents. The plugin
  170. # install does this for you; a skill-only copy does not include agents/.
  171. mkdir -p ~/.claude/agents
  172. cp agents/cpp-review-agent.md agents/qml-review-agent.md ~/.claude/agents/
  173. ```
  174. Without the agents, `qt-cpp-review` and `qt-qml-review` still work:
  175. they fall back to the general-purpose agent.
  176. Claude Code auto-discovers skills — no restart needed.
  177. ### Codex CLI
  178. Use Vercel's cross-platform skill installer:
  179. ```bash
  180. npx skills add TheQtCompanyRnD/agent-skills
  181. ```
  182. Or copy skills manually:
  183. ```bash
  184. cp -r skills/qt-qml-review ~/.codex/skills/qt-qml-review
  185. ```
  186. Restart Codex after adding skills.
  187. > **Note:** Codex is evolving rapidly. If `~/.codex/skills/`
  188. > does not work, try `~/.agents/skills/` or `.agents/skills/`
  189. > in your project root.
  190. ### GitHub Copilot CLI
  191. Copilot natively reads the same `SKILL.md` directory format as
  192. Claude Code. Install individual skills using GitHub CLI (preview):
  193. ```bash
  194. gh skill install TheQtCompanyRnD/agent-skills qt-qml-review
  195. ```
  196. Or copy/symlink the skill into one of Copilot's discovery paths:
  197. ```bash
  198. # User-wide (available in any project)
  199. cp -r skills/qt-qml-review ~/.copilot/skills/qt-qml-review
  200. # Or scoped to a specific project
  201. cp -r skills/qt-qml-review .github/skills/qt-qml-review
  202. ```
  203. Copilot also auto-discovers skills installed for Claude Code
  204. under `.claude/skills/`, so a single install can serve both
  205. tools. Use `/skills list` inside Copilot CLI to confirm what
  206. loaded.
  207. `qt-qml-test` also ships a self-contained Copilot variant in
  208. `skills/qt-qml-test/platforms/copilot.prompt.md`.
  209. ### VSCode Agents (Copilot and others)
  210. Run `Chat: Install Plugin From Source` from the Command Palette.
  211. Enter `https://github.com/TheQtCompanyRnD/agent-skills` (this repo) to clone and install
  212. ### Gemini CLI
  213. Install as an extension:
  214. ```bash
  215. gemini extensions install https://github.com/TheQtCompanyRnD/agent-skills
  216. ```
  217. Or import skills into your project's context file:
  218. ```bash
  219. # Add to GEMINI.md (loaded automatically)
  220. echo '@skills/qt-qml-review/SKILL.md' >> GEMINI.md
  221. ```
  222. ### Cursor and Windsurf
  223. Neither tool reads skill directories. Copy the skill in as a rule:
  224. ```bash
  225. # Cursor: the full SKILL.md becomes a project rule
  226. mkdir -p .cursor/rules/qt-qml-review
  227. cp skills/qt-qml-review/SKILL.md .cursor/rules/qt-qml-review/RULE.md
  228. # Windsurf: use the condensed variant from platforms/
  229. mkdir -p .windsurf/rules
  230. cp skills/qt-qml-review/platforms/windsurf.md .windsurf/rules/qt-qml-review.md
  231. ```
  232. Windsurf variants exist for `qt-cpp-review`, `qt-qml-review`,
  233. `qt-qml-docs` and `qt-qml`. Scripts and subagents don't run on
  234. these tools, so only the static guidance applies.
  235. ## Documentation site
  236. A browsable documentation site is built from the `docs/` directory
  237. using [MkDocs Material](https://squidfunk.github.io/mkdocs-material/)
  238. and published at:
  239. > **<https://doc.qt.io/agentictools/>**
  240. The canonical repo is on Gerrit
  241. (`codereview.qt-project.org/qtai/qtaiskills`); doc.qt.io builds are
  242. driven by the `qtaiskills` Rundeck job in `tqtc-doctools` on each
  243. push to the publishing branch.
  244. ### Local preview
  245. Requires Python 3.12+:
  246. ```bash
  247. pip install -r requirements-docs.txt
  248. mkdocs serve
  249. ```
  250. Then open <http://127.0.0.1:8000/agent-skills/> — the dev server
  251. live-reloads on every save.
  252. ### Production build
  253. ```bash
  254. mkdocs build --strict
  255. ```
  256. Output goes to `site/`. `--strict` fails on broken links and
  257. malformed nav, matching the GitHub Actions check.
  258. ### Adding a new skill page
  259. Skill pages are generated at build time by `gen_skills.py`: each
  260. `skills/<skill-name>/SKILL.md` becomes a page, a row in the skills
  261. overview table and an entry in the Skills nav. Adding the skill
  262. directory is enough; don't create `docs/skills/<skill-name>.md` or
  263. edit `nav:` in `mkdocs.yml`. Run `mkdocs serve` to verify.
  264. ## Contributing
  265. See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines
  266. on authoring new skills, including:
  267. - Naming conventions and frontmatter requirements
  268. - How to structure progressive disclosure
  269. - Testing skills across AI coding tools
  270. - When and how to create platform-specific variants
  271. ## License
  272. BSD-3-Clause — see [LICENSE](LICENSE) for details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.