> ## Documentation Index
> Fetch the complete documentation index at: https://docs.luminy.tech/llms.txt
> Use this file to discover all available pages before exploring further.
# Skills: Specialized Agent Behaviors for Coding Tasks
> Luminy skills auto-activate to give the agent structured guidance for specialized tasks — debugging, refactoring, design, and UI verification.
**Skills** are specialized instruction sets that shape how the agent approaches a particular category of task. When you ask Luminy to fix a failing test, design a data model, or explain a codebase, the agent automatically detects what kind of task you're describing and injects the relevant skill instructions into its context — giving it a structured, proven approach for that specific situation. You don't invoke skills manually; they activate based on what you ask.
## How skills activate
When you send a message, the agent analyzes your intent and matches it against a library of built-in skills. Each skill has a set of trigger conditions — phrases, task types, and contextual signals. When a match is found, the skill's instruction set is added to the agent's active context for that turn, guiding how it reasons, what it checks, and how it structures its response.
Skills are **additive**: they add guidance and best-practice structure on top of the agent's normal behavior. They don't restrict what you can ask for or limit the agent's capabilities. If no specific skill matches, the agent proceeds with its default behavior.
Multiple skills can be active in the same turn. For example, a complex refactor might simultaneously activate `planning_complex_change`, `gather_context`, and `refactor_to_pattern`.
## Built-in skills
Luminy ships with 35 built-in skills. The most commonly triggered ones are described below.
### Understanding code
| Skill | What it does |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `explain_codebase` | Produces a structured tour of a codebase — architecture, service boundaries, key components, and how the pieces connect. Triggers when you're new to a project or want a high-level overview. |
| `explain_concept` | Shifts the agent into teaching mode to explain a technology, pattern, or principle clearly and at the right level. Triggers on "explain X", "how does X work?", "what's the difference between A and B?". |
| `trace_data_flow` | Follows a value or request through the codebase — where it originates, how it transforms, and where it ends up. Triggers on "where does this value come from?", "trace this request". |
| `gather_context` | Pulls the relevant code, project rules, and known facts into context before acting on an existing codebase. Triggers automatically before most implementation or debugging tasks. |
### Debugging & fixing
| Skill | What it does |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `debug_logic_bug` | Applies systematic reasoning to bugs where the code runs but produces wrong results. Triggers on "it works but gives the wrong answer", "this test is failing and I don't know why". |
| `debug_runtime_error` | Guides runtime error diagnosis — reading stack traces, identifying the failure site, and tracing the root cause. Triggers on exception messages, crashes, and runtime panics. |
| `find_root_cause` | Distinguishes the true underlying cause from surface-level symptoms for recurring or persistent bugs. Triggers on "why does this keep happening?", "what's actually causing this?". |
| `handle_build_failure` | Reads compiler errors, type errors, and CI failures and resolves them systematically. Triggers on build output with errors, "it won't compile", "tsc error", "cargo build failed". |
| `handle_test_failure` | Diagnoses and fixes failing tests — distinguishing test bugs from implementation bugs and restoring the test suite to green. Triggers on test output with failures or "my tests are failing". |
| `fix_msbuild_rsp_error` | Handles MSBuild and .NET build errors, including response file and project configuration issues. Triggers on MSBuild output, `.csproj` or `.sln` errors, and .NET build failures. |
### Planning & design
| Skill | What it does |
| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `planning_complex_change` | Decomposes a large multi-file change into a clear, ordered sequence of steps before any code is written. Triggers on "plan this out", "how should I approach this?", or any task that spans many files. |
| `design_system_architecture` | Provides structured guidance for high-level system design — service boundaries, component responsibilities, data flows, and trade-offs. Triggers on architecture and system design questions. |
| `design_api_contracts` | Guides API design decisions — endpoint structure, request/response shapes, versioning, and consistency. Triggers on "design an API for", "what should this endpoint look like?". |
| `design_data_model` | Helps model domain entities, value objects, and aggregates before touching database schemas or ORMs. Triggers on "how should I model this domain?", "what entities do I need?". |
| `design_database_schema` | Guides relational schema design — table structure, normalization, indexes, and referential integrity. Triggers on "design a schema for", "what tables do I need?", "how should I structure this database?". |
| `design_ui` | Guides UI layout and component structure decisions for a given feature or screen. Triggers on UI design questions and requests to sketch out a new interface. |
| `design_ui_ux` | Applies UX thinking alongside visual design — user flows, interaction patterns, accessibility, and usability. Triggers on "improve the UX of", "how should this flow work?". |
### Implementation
| Skill | What it does |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `react_component` | Applies React best practices for components, hooks, context, and state management. Triggers on `.tsx` files, "create a React component", "write a hook for", and frontend UI work. |
| `refactor_to_pattern` | Structures a refactor around a named pattern — strategy, repository, factory, etc. — and applies it consistently. Triggers on "refactor this to use X pattern". |
| `write_new_module` | Guides the creation of a new module or package that fits the existing project conventions. |
| `write_tests` | Produces test coverage that is meaningful, readable, and correctly structured for the project's test framework. |
| `write_migration` | Writes database migrations safely, accounting for data integrity and rollback. |
| `modify_existing_code` | Applies targeted changes to existing code while preserving surrounding conventions and style. |
| `git_operation` | Guides git workflows — committing, branching, rebasing, resolving conflicts, and writing commit messages. Triggers on git commands and version control questions. |
| `django_clean_arch` | Applies Django-specific clean architecture patterns — app boundaries, models, views, serializers, and URL configuration. Triggers when working in a Django project. |
| `seaorm_query` | Writes and debugs SeaORM queries in Rust — entity definitions, relations, filters, and async queries. Triggers on SeaORM usage in Rust projects. |
| `tauri_ipc` | Guides Tauri IPC design — Tauri commands, events, and the boundary between Rust and the frontend. Triggers when working with Tauri command handlers or frontend-to-backend calls. |
### Quality & verification
| Skill | What it does |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `code_review_self` | Runs a structured self-review checklist before the agent presents any non-trivial code output. Automatically triggers after writing more than \~50 lines or changes across multiple files. |
| `verify_ui` | Launches a read-only verifier sub-agent that observes the running UI and reports layout, interaction, and rendering issues. Triggers for UI verification tasks. |
| `verify_ui_web` | Web-specific UI verification procedure — opens the app in a browser, navigates to the affected route, and checks rendering and interaction. Triggers for web projects (React, Vue, Svelte, etc.). |
| `verify_ui_react_native` | React Native UI verification — boots the app on a connected device or emulator and inspects the affected screen. Triggers for React Native projects. |
| `verify_ui_flutter` | Flutter UI verification — runs the app and checks widget rendering and layout on the target platform. Triggers for Flutter projects. |
| `verify_ui_swiftui` | SwiftUI UI verification — launches the app on a simulator and inspects the affected views. Triggers for SwiftUI projects. |
| `verify_ui_compose` | Jetpack Compose UI verification — runs the app on an Android emulator and checks composable rendering. Triggers for Compose projects. |
### Communication
| Skill | What it does |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ask_clarifying_question` | Structures a blocking clarification prompt when the agent needs more information before proceeding — presenting clear options rather than guessing. |
## Triggering skill-like behavior explicitly
Because skills activate automatically, you typically don't need to think about them. However, you can guide the agent toward skill-like behavior by framing your request explicitly:
Say **"plan this change before implementing"** or **"walk me through how you'd approach this"** to activate structured planning before any code is written.
Say **"review what you just wrote"** or **"check your work before showing me"** to activate the self-review pass explicitly.
Say **"don't just fix the symptom — find the root cause"** to activate systematic root cause reasoning before the agent reaches for a quick patch.
Say **"explore the codebase first"** or **"gather context before making changes"** to make sure the agent reads the relevant code before acting.
Skills work best when your message is specific about what you want. "Fix the bug" is fine, but "fix the bug in the auth middleware where expired tokens aren't being rejected" gives the agent enough signal to activate the right skill and skip unnecessary exploration.