Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Get Started Free →

qt-cmake-project-generator · a5c-ai | DecimalAI

a5c-ai/qt-cmake-project-generator

NewSkillScoreMaintained

Generate CMake-based Qt project with proper module dependencies, cross-compilation support, and modern Qt6 configuration

codingby a5c-ai

Links this skill to your agents and keeps it current with the author’s updates.

Automatic

Coding pack

1 · One-time — install the CLI (docs ↗)

pip install decimalai

2 · Get the skill — writes .claude/skills/a5c-ai-qt-cmake-project-generator/SKILL.md

decimalai skills pull a5c-ai-qt-cmake-project-generator --out .claude/skills/

No CLI? Get the same file — curl · raw file

curl -fsSL --create-dirs -o .claude/skills/a5c-ai-qt-cmake-project-generator/SKILL.md https://app.decimal.ai/s/a5c-ai-qt-cmake-project-generator/SKILL.md

Raw file: /s/a5c-ai-qt-cmake-project-generator/SKILL.md ↗ · machine-readable summary at /s/a5c-ai-qt-cmake-project-generator.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

No production data for this skill yet — usage numbers appear here once agents start running it.

Anonymized aggregate across every org using this skill — proof from real production use, not a demo.

Does this skill help? · Benchmark: with vs. withoutsign in to run this on your agents

23 test cases from the publisher’s eval.yaml · each run twice on gemini-3.6-flash — with the skill injected, then without · last run 55d ago

No measurable change+85% tokens0% turns91% of whole cases pass with skill (21/23)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-01	✗→✓	▲ Improved	57%	0%
case-02	✗→✓	▲ Improved	55%	0%
case-09	✓→✗	▼ Worse	55%	0%
case-11	✓→✗	▼ Worse	74%	0%
case-03	✓→✓	＝ Same ✓	39%	0%

Showing 5 of 23 cases

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 7/31/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

a5c-ai / babysitter

library/specializations/desktop-development/skills/qt-cmake-project-generator/SKILL.md

View on GitHub ↗

License MITImported 7/31/2026Version v1

Skill contents

SKILL.md

qt-cmake-project-generator

Generate CMake-based Qt project configurations with proper module dependencies and cross-compilation support. This skill handles Qt6 CMake integration, module discovery, and platform-specific build configurations.

Capabilities

Generate modern CMake configuration for Qt6 projects
Configure Qt module dependencies (Core, Widgets, Quick, Network, etc.)
Set up cross-compilation toolchains
Configure vcpkg/Conan package management integration
Generate platform-specific build configurations
Set up Qt deployment scripts (windeployqt, macdeployqt)
Configure static vs dynamic linking
Generate CMake presets for development and CI

Input Schema

json
{
  "type": "object",
  "properties": {
    "projectPath": {
      "type": "string",
      "description": "Path to create/update the Qt project"
    },
    "projectName": {
      "type": "string",
      "description": "Project name"
    },
    "qtVersion": {
      "type": "string",
      "default": "6.6",
      "description": "Target Qt version"
    },
    "qtModules": {
      "type": "array",
      "items": {
        "enum": ["Core", "Gui", "Widgets", "Quick", "Qml", "Network", "Sql", "Multimedia", "WebEngine", "Charts", "3D"]
      },
      "default": ["Core", "Gui", "Widgets"]
    },
    "appType": {
      "enum": ["widgets", "quick", "console", "library"],
      "default": "widgets"
    },
    "targetPlatforms": {
      "type": "array",
      "items": { "enum": ["windows", "macos", "linux", "android", "ios", "wasm"] }
    },
    "packageManager": {
      "enum": ["none", "vcpkg", "conan"],
      "default": "none"
    },
    "cppStandard": {
      "enum": ["17", "20", "23"],
      "default": "17"
    },
    "generatePresets": {
      "type": "boolean",
      "default": true
    }
  },
  "required": ["projectPath", "projectName"]
}

Output Schema

json
{
  "type": "object",
  "properties": {
    "success": { "type": "boolean" },
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "path": { "type": "string" },
          "description": { "type": "string" }
        }
      }
    },
    "buildCommands": {
      "type": "object",
      "properties": {
        "configure": { "type": "string" },
        "build": { "type": "string" },
        "install": { "type": "string" }
      }
    },
    "warnings": { "type": "array", "items": { "type": "string" } }
  },
  "required": ["success"]
}

Generated CMakeLists.txt Example

cmake
cmake_minimum_required(VERSION 3.21)
project(MyQtApp VERSION 1.0.0 LANGUAGES CXX)

# C++ Standard
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Qt Configuration
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)

# Find Qt packages
find_package(Qt6 REQUIRED COMPONENTS Core Gui Widgets)

# Source files
set(SOURCES
    src/main.cpp
    src/mainwindow.cpp
    src/mainwindow.h
    src/mainwindow.ui
)

# Resources
set(RESOURCES
    resources/resources.qrc
)

# Create executable
qt_add_executable(${PROJECT_NAME}
    ${SOURCES}
    ${RESOURCES}
)

# Link Qt libraries
target_link_libraries(${PROJECT_NAME} PRIVATE
    Qt6::Core
    Qt6::Gui
    Qt6::Widgets
)

# Platform-specific settings
if(WIN32)
    set_target_properties(${PROJECT_NAME} PROPERTIES
        WIN32_EXECUTABLE TRUE
    )
elseif(APPLE)
    set_target_properties(${PROJECT_NAME} PROPERTIES
        MACOSX_BUNDLE TRUE
        MACOSX_BUNDLE_INFO_PLIST "${CMAKE_SOURCE_DIR}/platform/macos/Info.plist"
    )
endif()

# Installation
install(TARGETS ${PROJECT_NAME}
    BUNDLE DESTINATION .
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

# Qt deployment
qt_generate_deploy_app_script(
    TARGET ${PROJECT_NAME}
    OUTPUT_SCRIPT deploy_script
    NO_UNSUPPORTED_PLATFORM_ERROR
)
install(SCRIPT ${deploy_script})

CMake Presets

json
{
  "version": 6,
  "configurePresets": [
    {
      "name": "default",
      "displayName": "Default",
      "binaryDir": "${sourceDir}/build/${presetName}",
      "cacheVariables": {
        "CMAKE_BUILD_TYPE": "Debug"
      }
    },
    {
      "name": "release",
      "inherits": "default",
      "displayName": "Release",
      "cacheVariables": {
        "CMAKE_BUILD_TYPE": "Release"
      }
    },
    {
      "name": "windows-msvc",
      "inherits": "default",
      "displayName": "Windows MSVC",
      "generator": "Visual Studio 17 2022",
      "architecture": "x64",
      "condition": {
        "type": "equals",
        "lhs": "${hostSystemName}",
        "rhs": "Windows"
      }
    },
    {
      "name": "macos",
      "inherits": "default",
      "displayName": "macOS",
      "generator": "Ninja",
      "cacheVariables": {
        "CMAKE_OSX_ARCHITECTURES": "x86_64;arm64"
      },
      "condition": {
        "type": "equals",
        "lhs": "${hostSystemName}",
        "rhs": "Darwin"
      }
    },
    {
      "name": "linux",
      "inherits": "default",
      "displayName": "Linux",
      "generator": "Ninja",
      "condition": {
        "type": "equals",
        "lhs": "${hostSystemName}",
        "rhs": "Linux"
      }
    }
  ],
  "buildPresets": [
    {
      "name": "default",
      "configurePreset": "default"
    },
    {
      "name": "release",
      "configurePreset": "release"
    }
  ]
}

Cross-Compilation Toolchain

cmake
# toolchain-linux-aarch64.cmake
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR aarch64)

set(CMAKE_SYSROOT /opt/sysroots/aarch64-linux-gnu)
set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

Package Manager Integration

vcpkg

cmake
# CMakeLists.txt
if(DEFINED ENV{VCPKG_ROOT})
    set(CMAKE_TOOLCHAIN_FILE "$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake")
endif()

Conan

python
# conanfile.py
from conan import ConanFile
from conan.tools.cmake import cmake_layout

class MyQtAppConan(ConanFile):
    settings = "os", "compiler", "build_type", "arch"
    generators = "CMakeToolchain", "CMakeDeps"

    def requirements(self):
        self.requires("qt/6.6.0")

    def layout(self):
        cmake_layout(self)

Best Practices

Use qt_add_executable: Preferred over add_executable for Qt6
Enable AUTOMOC/AUTOUIC/AUTORCC: Automatic meta-object compilation
Use CMake Presets: Simplify configuration for different environments
Version your Qt requirement: find_package(Qt6 6.4 REQUIRED ...)
Use modern CMake: target_ commands over global settings
Generate deploy scripts: Use Qt's deployment tools

Related Skills

qt-qml-component-generator - QML component creation
qt-installer-framework-config - Installer configuration
qt-test-fixture-generator - Test setup

Related Agents

qt-cpp-specialist - Qt/C++ expertise
desktop-ci-architect - CI/CD for Qt projects

Illustrative Want to see what a5c-ai/qt-cmake-project-generator would put in front of your model? Preview the rendered body and check its trigger phrases — no LLM call, no signup.

Latest benchmark · publisher runVerified

8/1/2026, 03:07 UTC · 23 cases

Lift

0%

91% vs 91%

Agent turns

0%

1.0 vs 1.0

Tokens

+85%

4,767.52 vs 2,580.04

fail → pass · 2pass → pass · 19pass → fail · 2

Per-case results (23)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-01 Please generate a complete Qt6 CMake project structure for a database dashboard tool located at `/workspace/db_dashboard`. The application should be a C++ Widgets app using Core, Gui, Widgets, and Sql modules with CMake presets enabled. Make sure the response reports whether generation succeeded, provides a list of created files with brief descriptions, and includes the step-by-step terminal build commands.	fail→pass	16,855	17,712	+5%	1	1	0%	4,246	6,647	+57%	0	0	—
case-02 We are creating a headless network daemon using Qt6 at path `/apps/net_daemon`. It should be a console app with Core and Network capabilities using C++17. Please set up the CMake build files and return a structured outcome showing if the operation was successful, all generated files with their details, the necessary configure and build instructions, and any relevant build warnings.	fail→pass	12,262	11,021	-10%	1	1	0%	2,971	4,609	+55%	0	0	—
case-03 Generate a CMake build structure for a Qt6 QML media application located at `/projects/media_player` named `MediaPlayerApp`. Configure the project for C++20 standard and integrate vcpkg package management. Output the complete build plan as JSON reporting execution success, generated files list, and build commands.	pass→pass	14,142	13,288	-6%	1	1	0%	3,695	5,136	+39%	0	0	—
case-04 Create cross-compilation toolchain and project files targeting aarch64 Linux for a Qt6 app `EmbeddedDash` located at `/build/embedded_dash`. Produce structured JSON detailing success flag, files created, and build commands.	pass→pass	12,136	10,389	-14%	1	1	0%	2,968	4,603	+55%	0	0	—
case-05 Generate a Qt6 CMake project for a Windows application named `WinAssetTool` at path `/apps/win_asset_tool`. Set up deployment script generation for executable dependencies. Format the output as a JSON object with success, created files, and build commands.	pass→pass	8,945	11,900	+33%	1	1	0%	2,201	5,131	+133%	0	0	—
case-06 Configure CMake files for a macOS Qt6 desktop app named `MacPhotoEditor` at `/code/mac_photo_editor`. The project must build an application bundle with custom Info.plist mapping. Output the standard JSON structure with success status, file list, and commands.	pass→pass	12,004	12,267	+2%	1	1	0%	3,171	5,240	+65%	0	0	—
case-07 Scaffold a C++ Qt6 library target named `CoreEngine` at `/libs/core_engine` integrated with Conan package management. Output JSON containing status, files inventory, and build commands.	pass→pass	10,810	15,592	+44%	1	1	0%	2,655	5,964	+125%	0	0	—
case-08 Set up a Qt6 project named `KioskBrowser` at `/apps/kiosk` requiring WebEngine and Multimedia components. Return structured JSON output with success, files, and terminal commands.	pass→pass	9,077	7,709	-15%	1	1	0%	2,126	3,846	+81%	0	0	—
case-09 Generate CMake files for a Qt6 UI app named `ChartViewer` at `/dev/chart_app`. Ensure Qt meta-object, UI, and resource compilers are automatically processed. Output standard JSON response.	pass→fail	8,768	4,312	-51%	1	1	0%	1,998	3,100	+55%	0	0	—
case-10 Scaffold CMake configuration with presets for project `MultiDash` at `/repo/multidash`. Presets should include debug, release, and OS platform conditions. Output JSON formatted structure.	pass→pass	14,166	10,787	-24%	1	1	0%	3,255	4,822	+48%	0	0	—
case-11 Create CMake build configuration for a modern Qt6 project named `NextGenApp` located at `/projects/nextgen` requiring C++23 support. Output the response in JSON schema format.	pass→fail	8,490	5,434	-36%	1	1	0%	1,914	3,324	+74%	0	0	—
case-12 Generate deployment script CMake setup for a Qt6 application named `DeployApp` at `/src/deploy_app` that tolerates unsupported platforms without failing. Return standard JSON schema output.	pass→pass	15,694	9,481	-40%	1	1	0%	2,629	4,436	+69%	0	0	—
case-13 Build CMake project files for a 3D visualization app named `SciViz` at `/apps/sciviz` using Qt6 3D and Charts modules. Provide output in JSON format detailing files and build commands.	pass→pass	16,025	14,290	-11%	1	1	0%	4,089	5,564	+36%	0	0	—
case-14 Generate CMake project files for a command-line tool named `LogParser` at `/tools/log_parser` using Qt6 Core only. Output JSON structured outcome.	pass→pass	12,567	10,441	-17%	1	1	0%	2,252	4,757	+111%	0	0	—
case-15 Configure CMake presets for Windows MSVC 64-bit targeting for project `MsvcTool` at path `/dev/msvctool`. Return structured JSON output.	pass→pass	8,885	11,326	+27%	1	1	0%	2,119	4,843	+129%	0	0	—
case-16 Generate modern CMake project setup for Qt6 application `ModernApp` located at `/work/modern_app`. Ensure the declared minimum CMake version supports modern Qt6 deployment macros. Return standard JSON.	pass→pass	11,018	15,036	+36%	1	1	0%	2,559	5,614	+119%	0	0	—
case-17 Scaffold CMake configuration for Qt6 app `InstallableApp` at `/apps/installable` including standard binary installation commands. Return JSON schema structure.	pass→pass	7,150	10,449	+46%	1	1	0%	1,499	4,611	+208%	0	0	—
case-18 Generate CMake setup for a mobile Qt6 application `MobileSync` located at `/apps/mobile_sync` targeting Android. Output JSON formatted results.	pass→pass	14,296	15,783	+10%	1	1	0%	2,635	4,944	+88%	0	0	—
case-19 Build CMake project setup for a WebAssembly browser app `WasmViewer` at `/web/wasm_viewer` using Qt6. Return structured JSON with success flag and file list.	pass→pass	8,322	8,911	+7%	1	1	0%	1,938	4,135	+113%	0	0	—
case-20 Create Qt6 CMake project setup for `ResApp` at `/apps/res_app` including resource file compiling settings. Return JSON outcome.	pass→pass	8,281	9,072	+10%	1	1	0%	1,847	4,322	+134%	0	0	—
case-21 Write the C++ and QML source code for a custom animated toggle switch component named 'AnimatedSwitch.qml' with smooth transitions and active state property.	pass→pass	19,478	19,332	-1%	1	1	0%	3,480	6,487	+86%	0	0	—
case-22 Refactor this legacy Qt C++ connection from old macro syntax to new pointer-to-member syntax: QObject::connect(button, SIGNAL(clicked()), slider, SLOT(setValue()));	pass→pass	8,047	7,218	-10%	1	1	0%	1,422	3,431	+141%	0	0	—
case-23 Write a `.github/workflows/ci.yml` GitHub Actions workflow file that checks out code, sets up Qt 6.6 on Ubuntu 22.04, and runs cmake build and test steps.	pass→pass	7,999	11,227	+40%	1	1	0%	1,672	4,087	+144%	0	0	—

These cases were also screened by the skill’s intent / safety pass.See the Trust review ↗Reproduce this benchmark in Colab ↗

How this skill was measured

DecimalAI ran this skill against gemini-3.6-flash twice over the same eval suite — once with the skill loaded and once without — and compared the two runs case by case. 23 cases were attempted. The headline lift of 0 percentage points is the difference between those two pass rates over the 23 comparable cases. 2 cases got worse with the skill loaded, and they are included in that figure.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 91.3%
Pass rate with the skill: 91.3%
Cases attempted: 23
Cases counted toward lift: 23
Cases that regressed: 2
Skill version measured: v1
Run completed: 8/1/2026, 03:07 UTC

Measured example — same prompt, with vs. without the skill · from the benchmark run · case case-01

Prompt

Please generate a complete Qt6 CMake project structure for a database dashboard tool located at `/workspace/db_dashboard`. The application should be a C++ Widgets app using Core, Gui, Widgets, and Sql modules with CMake presets enabled. Make sure the response reports whether generation succeeded, provides a list of created files with brief descriptions, and includes the step-by-step terminal build commands.

Without the skill loaded, the model failed this case. With it loaded, the same prompt on the same model passed. This is one improved case from the latest verified run; every case, including any that regressed, is in the table above.

Show both answers

SkillScore blends 4 signalsno signals yet

BenchmarkRun a verified benchmark with positive lift

Live evalNeeds ≥10 evaluated traces in 30 days

AI ratingNeeds ≥10 rated traces

AdoptionNeeds ≥10 serves across ≥2 orgs in 30 days

Efficiency · separate axis (at equal correctness)+0% turns+91% tokens

Shown for transparency; not credited unless a verified run shows no correctness regression.

No signals yet — run a benchmark or collect evaluated traces to earn a score.

Verified on gemini-3.6-flash · re-tested 54 days ago

Other measured skills in the registry, with their headline benchmark lift.