ai

Design GitHub Copilot-based agentic AI systems. Use when turning a user brief into a complete system with agents, prompts, skills, instructions, hooks, MCP integration, manifests, runbooks, and rollout guidance.

Parse AUTOSAR, MISRA, and similar C++ standards documents, extract rule records, map rule interactions, and synthesize a core guideline with canonical coding patterns and fix-order guidance.

Use when identifying and modeling task dependencies in a project plan. Covers building a Directed Acyclic Graph (DAG) of task relationships using Mermaid flowchart syntax, detecting dependency cycles, and computing the critical path. Applies to any task list that needs a structured execution order.

Use when identifying, classifying, and mitigating project risks. Covers the full risk management workflow: brainstorming risks across five categories, scoring them on a probability × impact matrix, writing proactive mitigation strategies, reactive contingency plans, and maintaining a Markdown risk register.

Use when breaking a complex goal or project requirement into atomic, measurable, assignable tasks. Covers the full SMART decomposition workflow: understanding the goal, identifying deliverables, creating work packages, assigning ownership and duration, and validating completeness. Applies to software projects, planning agents, and any structured task list creation.

Use when asked to create a new local MCP (Model Context Protocol) tool/server for GitHub Copilot — file readers, API wrappers, CLI integrations, or any capability that Copilot cannot do natively. Covers the full workflow: Python MCP server implementation, dependency setup, VS Code mcp.json registration, Windows installation script, and end-to-end verification. Applies to any OS-local tool that must run without internet access (corporate environments).

Use when asked to generate a git commit message for a code change. Reads the diff (unstaged or staged), infers the commit type and scope from the changed files, then produces a commit message that matches the project's convention — either from a templates/commit-template.md file in this skill folder, or derived from the last 5–10 commits in the repo.

Use when writing, reviewing, or debugging AIDL (Android Interface Definition Language) interface files for IPC between Android processes. Covers .aidl syntax, primitive and Parcelable types, oneway modifier, directional parameters, versioning and stability, and generating Java/C++ binder stubs in Gradle and AOSP Soong builds.

Use when writing, reviewing, or scaffolding Android application components (Activity, Fragment, Service, BroadcastReceiver, ContentProvider) in either Android Studio (Gradle) or AOSP (Soong) build environments. Covers Android lifecycle, Intents, Permissions, AndroidManifest, Navigation, and app-level architecture conventions for Android Automotive / AAOS targets.

Use when designing, implementing, or reviewing Android app architecture — MVVM or MVI patterns, Clean Architecture layer separation (data/domain/presentation), Hilt dependency injection, feature modularization, and Repository pattern. Applies to Android Studio (Gradle) and AOSP (Soong) projects targeting AAOS.

Use when implementing or reviewing native C++ Binder services in AOSP using libbinder directly (BnInterface/BpInterface, Parcel, onTransact). Covers the IInterface pattern with DECLARE/IMPLEMENT_META_INTERFACE macros, server-side BnFoo stub, client-side BpFoo proxy, Parcel serialization, ServiceManager registration, ProcessState thread pool setup, and IBinder death notifications. Applies to AOSP system services, platform components, and vendor native services.

Use when configuring, reviewing, or troubleshooting Android app build files in either Android Studio (Gradle: Version Catalogs, Convention Plugins, KSP, build variants, build performance) or AOSP (Soong: Android.bp, Android.mk, module types, signing certificates, product packages, partition placement). Covers both environments for Android Automotive / AAOS projects.

Use when developing Android apps for Android Automotive OS (AAOS), Car App Library, or CarService API integration. Covers driver distraction guidelines, CarAppService, template navigation, Car UX Restrictions (UXR), CarPropertyManager, HVAC APIs, and automotive-specific manifest/build configuration in Gradle and AOSP (Soong).

Use when implementing image loading in Jetpack Compose using Coil. Covers AsyncImage, ImageRequest, placeholder/error states, transformations, memory and disk cache configuration, custom ImageLoader, and performance optimization. Applies to Android Studio (Gradle) and AOSP (Soong) on Android Automotive / AAOS targets.

Use when writing, reviewing, or refactoring Jetpack Compose UI code for Android apps (IVI, HUD, RSE on Android Automotive / AAOS). Covers composable design, state management, Material Design 3 theming, performance (recomposition), side effects, navigation in Compose, animations, and XML interop. Applies to Android Studio (Gradle) and AOSP (Soong) builds.

Use when implementing, registering, or debugging Android Hardware Abstraction Layer (HAL) services. Covers AIDL HAL (current standard, Android 11+): implementing the AIDL stub in C++, registering with ServiceManager, writing init.rc service declarations, and VINTF manifest entries. Includes a brief note on HIDL as a legacy approach for Android 8–10.

Use when implementing or reviewing Jetpack library integrations in Android apps: Navigation Component, Room database, DataStore, WorkManager, Paging 3, and Lifecycle-aware components (LiveData, StateFlow, repeatOnLifecycle). Covers both Android Studio (Gradle) and AOSP (Soong) on Android Automotive / AAOS.

Use when writing, reviewing, or debugging JNI (Java Native Interface) code that bridges Android Java/Kotlin and C/C++ native code. Covers function naming conventions, JNI type mappings, local and global references, string and array handling, exception propagation, threading with JavaVM, and JNI_OnLoad setup.

Use when writing, reviewing, or debugging asynchronous Kotlin code using Coroutines and Flow in Android apps. Covers suspend functions, CoroutineScope and Job, Dispatchers, structured concurrency, exception handling, Flow operators, StateFlow, SharedFlow, Channels, lifecycle-safe collection patterns, and testing with TestCoroutineDispatcher and Turbine. Applies to AAOS Android app development.

Use when asked to fix Android Lint, Kotlin compiler warnings, or Detekt violations in Kotlin/Java Android app code. Provides a safe per-rule fix workflow that prevents cascading new issues. Covers Android Lint IDs, Kotlin compiler warnings, and Detekt rules. Does NOT cover Lint tool setup or Gradle configuration.

Use when setting up, configuring, or reviewing Android NDK native build integration for C/C++ libraries in Android apps (Gradle + CMake) or AOSP modules (Soong/Android.bp). Covers NDK toolchain setup, CMakeLists.txt for Android, ABI selection, STL choice, API level targeting, and exposing native libraries to Java/Kotlin via System.loadLibrary.

Use when implementing or reviewing networking code in Android apps using Retrofit and OkHttp. Covers typed API service interfaces, JSON serialization (Kotlin Serialization / Gson / Moshi), interceptors (auth, logging, retry), error handling, SSL/certificate pinning, and offline-first patterns with Flow. Applies to Android Studio (Gradle) and AOSP (Soong) on Android Automotive / AAOS targets.

Use when writing, reviewing, or debugging tests for Android applications: unit tests (JUnit4/5, MockK), ViewModel and Flow tests (Turbine), Hilt integration tests, UI tests (Espresso, Compose Test API), and screenshot tests (Paparazzi/Roborazzi). Covers both Android Studio (Gradle) and AOSP (Soong) test modules on AAOS targets.

Use when converting XML-based Android layouts and Views to idiomatic Jetpack Compose. Covers layout mapping (LinearLayout, ConstraintLayout, RecyclerView), widget migration (TextView, ImageView, Button, EditText), theme/style migration to Material 3, interop (AndroidView, ComposeView), incremental migration strategy, and common pitfalls. Applies to AAOS legacy app modernization.

Use when setting up, debugging, or reviewing cross-compilation toolchains for C/C++ embedded projects targeting ARM (Linux), AArch64 (Android NDK), or QNX. Covers toolchain selection, sysroot configuration, CMake toolchain files, pkg-config wrappers, multilib, Android NDK integration, and common pitfalls.

Use when designing, implementing, or reviewing inter-process communication (IPC) in C/C++ automotive embedded projects (IVI, HUD, RSE on Linux/QNX/Android). Covers D-Bus (libdbus / sdbus-c++), SOME/IP (vsomeip), Android Binder (AIDL/NDK), POSIX shared memory, UNIX domain sockets, message queues, and architectural considerations for choosing the right IPC mechanism.

Use when writing, reviewing, or refactoring C++ code involving memory ownership, lifetime management, smart pointers, RAII, custom allocators, or memory safety in automotive embedded projects (IVI, HUD, RSE on Linux/QNX/Android NDK). Covers Rule of Zero/Five, unique_ptr/shared_ptr, weak_ptr, placement new, arena allocators, AddressSanitizer, and common memory bug patterns.

Use when writing, reviewing, or debugging CMake build scripts for C/C++ projects in embedded automotive context (IVI, HUD, RSE on Linux/QNX/Android NDK). Covers modern target-based CMake (3.16+), CMakePresets, toolchain files, cross-compilation setup, install rules, packaging, and CI/CD integration.

Use when asked to fix static analysis violations in C/C++ code — from clang-tidy, cppcheck, Coverity, MISRA C:2012, or AUTOSAR C++14 reports. Provides a safe per-rule fix workflow that prevents cascading new violations. Covers AUTOSAR C++14, MISRA C:2012, CERT C++, and clang-tidy findings. Does NOT cover tool setup or CI/CD configuration.

Use when writing, reviewing, or debugging C++ unit tests with Google Test (gtest) and Google Mock (gmock) in automotive embedded projects (IVI, HUD, RSE on Linux/QNX/Android NDK). Covers test structure, AAA pattern, fixture design, mock creation, parameterized tests, death tests, test doubles, CMake integration, and code coverage.

Use when asked to create, update, or review a VS Code custom agent (.agent.md). Provides the correct file format, frontmatter fields, tool configuration, handoff patterns, and guidelines for designing effective, focused agents.

Use when asked to create, update, or review a VS Code custom instruction file (.instructions.md or copilot-instructions.md). Provides the correct file format, frontmatter fields, location rules, and writing guidelines for effective instructions.

Use when asked to create, update, or review a VS Code prompt file (.prompt.md). Provides the correct file format, frontmatter fields, and guidelines for writing effective, reusable slash-command prompts.

Use when asked to create, update, or review a VS Code Agent Skill (SKILL.md). Provides the correct directory structure, frontmatter fields, body format, and guidelines for writing effective, maintainable skills.

Use when writing, reviewing, or debugging Bash shell scripts on Linux for embedded development workflows. Covers script structure, error handling (set -euo pipefail), argument parsing, string/array manipulation, file operations, process management, ADB automation, build system helpers (AOSP/Yocto), log parsing, and CI/CD integration for automotive IVI / HUD / RSE projects running on Linux or QNX targets.

Use when writing, reviewing, or refactoring C code (*.c, *.h) in an automotive embedded context (IVI, HUD, RSE on Linux/QNX). Covers MISRA C:2012 compliance, fixed-width types, null/bounds safety, memory management without dynamic allocation in critical paths, Doxygen documentation, error-code patterns, and a full pre-commit review checklist.

Use when writing, reviewing, or refactoring C++ code (*.cpp, *.hpp, *.h) in an automotive embedded or Android NDK context (IVI, HUD, RSE on Linux/QNX/Android). Covers Modern C++11–17 idioms, SOLID principles, OOP design, RAII, smart pointers, move semantics, design patterns, Doxygen documentation, and a full pre-commit review checklist.

Use when writing, reviewing, or refactoring Java code (*.java) in an Android Automotive context (IVI, HUD, RSE on Android / AOSP). Covers Modern Java 8–17 idioms, SOLID principles, OOP design, immutability, null safety, clean error handling, concurrency, design patterns, Javadoc documentation, and a full pre-commit review checklist. Applies to Android Framework, Android App, and Android System Service development.

Use when writing, reviewing, or refactoring Kotlin code (*.kt) for Android App development (IVI, HUD, RSE on Android Automotive / AOSP). Covers Kotlin idioms, null safety, coroutines, Flow, MVVM/MVI architecture, Jetpack Compose, immutability, extension functions, design patterns, KDoc documentation, and a full pre-commit review checklist. Focused on the App layer — not Android Framework / System Services.

Use when writing, reviewing, or debugging PowerShell scripts on Windows for embedded development workflows. Covers script structure, error handling, parameter binding, pipeline patterns, file operations, ADB automation from Windows, toolchain setup, Gerrit/Artifactory REST API calls, and CI/CD pipeline scripting (Jenkins, GitLab CI) for automotive IVI / HUD / RSE projects targeting Android Automotive / Linux / QNX.