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.
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.
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.
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.
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?”.
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.
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.
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:
Trigger planning
Say “plan this change before implementing” or “walk me through how you’d approach this” to activate structured planning before any code is written.
Trigger self-review
Say “review what you just wrote” or “check your work before showing me” to activate the self-review pass explicitly.
Trigger root cause analysis
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.
Trigger exploration
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.
