Claude Skills by LUC4N3X

Coordinates Android/Kotlin/Jetpack Compose/Gradle/Media3 work. Use for Android UI, playback, services, device behavior, build/toolchain, R8, Room/data access, testing, edge-to-edge, adaptive layout, localization, performance, or runtime debugging. Prefer official Google Android skills/CLI when installed and use device or emulator evidence for runtime-specific acceptance.

Contract-first API engineering for HTTP/REST, RPC, event-driven interfaces, and service boundaries. Use for new endpoints, API changes, client/server integrations, pagination, idempotency, errors, retries, compatibility, or externally consumed contracts.

Evidence-driven software architecture design and review. Use for module/service boundaries, dependency direction, monolith vs distributed decomposition, system design, scalability, platform/data decisions, ADRs, architecture refactors, or cross-cutting changes where tradeoffs and quality attributes matter more than local code style.

Runs bounded evidence-driven experiment loops for measurable optimization, repeated hypothesis testing, agent/prompt tuning, benchmark improvement, difficult debugging with a stable evaluator, and implementation search. Establishes a reproducible baseline, changes one causal surface at a time, measures under comparable conditions, keeps only demonstrated improvements, reverts failed candidates, records an experiment ledger, protects correctness guardrails, and stops on budget or convergence. ...

Verifies web UI behavior in a real browser using the strongest browser/DevTools/Playwright capability actually available on the current host. Use after frontend changes or for browser-only bugs. Checks interaction, console, network, responsive behavior, screenshots, recordings, accessibility signals, and performance evidence rather than treating a successful build as proof.

Diagnoses and reviews CI/CD, GitHub Actions, build pipelines, packaging, signing, and release automation. Use for failing checks or workflow changes. Separates log evidence from guesses, reviews untrusted input and token permissions, and never deploys/releases merely to test a fix unless explicitly authorized.

Universal coding-quality overlay for implementation and review across languages. Use on meaningful code changes to keep the solution idiomatic, minimal, repository-native, incrementally verifiable, and evidence-backed while preventing common agent mistakes such as invented APIs, speculative abstractions, broad exception swallowing, dependency bloat, and fake-success behavior.

Builds a bounded, evidence-backed mental model of an unfamiliar or large repository before architecture work, broad refactors, feature-level repair, onboarding, review, or cross-module debugging. Uses read-only project and diff probes to orient routing without replacing task-relevant source inspection.

Product-quality Jetpack Compose UI workflow for redesigning or extending an existing Android app without losing its design language, accessibility, adaptive behavior, localization, state correctness, or runtime performance. Use for Compose screens, settings, media/player UI, visual redesigns, or interaction-heavy Android surfaces that require rendered device evidence.

Extracts reusable, verified engineering knowledge after difficult tasks so future work gets cheaper. Use after a non-trivial bug fix, architecture discovery, recurring failure, benchmark, or review that revealed a stable lesson. Routes useful outcomes through thalarch-experience, thalarch-memory, and optionally thalarch-project-brain while rejecting guesses, sensitive data, task-specific noise, and overbroad generalization.

Curates task context to reduce hallucination, stale assumptions, and attention dilution. Use when starting unfamiliar work, switching major task areas, after long sessions/compaction, when agent quality drifts, or when a task would otherwise require loading many files/logs/docs. Builds a compact evidence packet from rules, relevant source, tests, interfaces, current failures, and selectively revalidated project/general memory instead of flooding the model with unrelated context.

Database and SQL engineering for relational persistence, migrations, transactions, query correctness, indexing, pagination, ORM behavior, and data-safe rollout. Use when code touches schemas, queries, transactions, repositories/ORMs, migrations, or database performance.

Performs causal root-cause debugging before fixes. Use for bugs, crashes, failing tests or builds, intermittent behavior, regressions, incorrect state, networking failures, or performance anomalies. Requires reproduction/evidence, a falsifiable hypothesis, minimal diagnostic experiments, and architecture reassessment after repeated failed hypotheses.

Safe dependency and toolchain upgrade workflow. Use when adding, replacing, or upgrading libraries, language runtimes, plugins, build tools, frameworks, lockfiles, or transitive dependency constraints. Minimizes unrelated churn and verifies version-specific APIs.

Creates or extracts a semantic visual system for websites and applications. Use before major frontend redesigns, multi-page sites, brand-heavy UI, or when an existing codebase needs its visual language made explicit. Produces a compact design contract covering atmosphere, color roles, typography, spacing, components, layout, motion, responsive behavior, imagery, and anti-patterns without forcing a particular framework or design tool.

Fresh-context adversarial challenge for non-trivial engineering decisions before they harden into implementation. Use for D2+ work when a decision changes branching, crosses boundaries, asserts a non-compiler-verifiable property, has high blast radius, or rests on uncertain context. Extracts the artifact and contract, challenges them independently, reconciles findings against evidence, and stops after a bounded number of cycles instead of turning review into recursion.

Designs safe automatic entity-resolution and candidate-matching logic for searches such as title+artist to media ID, product to catalog item, album to provider entity, or similar fuzzy identity mapping. Use when a system must choose among near-duplicate remote search results without silently binding the wrong entity.

Anti-hallucination evidence gate for repository, API, runtime, external-fact, visual, and completion claims. Use on all meaningful Thalarch work and especially when exact files, symbols, commands, versions, APIs, logs, test results, commit metadata, current documentation, or runtime behavior matter. Requires inspect-before-claim, source hierarchy, claim-to-evidence matching, semantic validation, and explicit UNKNOWN/UNVERIFIED states instead of plausible invention.

Evaluates and retunes Thalarch itself. Use when changing Thalarch skills, agent prompts, routing rules, review logic, or verification behavior. Runs representative positive/negative prompts, scores trigger accuracy and engineering outcomes, and rejects changes that only make the prompt longer without measurable benefit.

Converts verified task outcomes into compact reusable experience cards. Use after meaningful bug fixes, failed hypotheses, performance investigations, migrations, design corrections, or repeated workflows when the result contains a lesson worth reusing. Captures trigger, discriminator, intervention, failed alternatives, evidence, transfer conditions, and counterexamples; separates project lessons from general engineering knowledge; and prevents one successful anecdote from becoming an overbro...

Safe Git and GitHub delivery workflow for any repository. Use when the user asks to branch, commit, push, prepare/open a pull request, update an existing PR, or otherwise publish code changes. Preserves unrelated work, verifies the exact diff, keeps commits intentional, and never merges/releases/force-pushes unless explicitly authorized.

Project-aware Go engineering for services, CLIs, libraries, concurrency, networking, and systems code. Use for Go source, modules, goroutines/channels, APIs, tests, profiling, performance, or Go-specific refactoring.

Visual-fidelity workflow for translating screenshots, generated design references, mockups, or section comps into real frontend code. Use when matching a visual reference is central to acceptance. Extracts a measurable design contract before implementation and verifies the real browser result rather than treating the reference image or source code as proof.

Routes and governs image-centric work across generation, editing, inspection, comparison, annotation, screenshots, branding, raster assets, vector assets, diagrams, infographics, mockups, and export validation. Use whenever an image is an input, output, reference, acceptance artifact, or major source of truth. Chooses the correct host-supported visual workflow before generation or editing begins.

Creates and edits project images through the strongest image-generation/editing capability actually available on the current host. Uses disciplined visual briefs, reference-role labeling, light art-direction guidance, invariants, deliberate iteration, exact-text handling, brand consistency, design-reference grounding, and post-generation review. Use for raster artwork, photography, mockups, marketing assets, textures, concept visuals, compositing, and semantic image edits.

Project-version-aware Java/JVM engineering for production code, libraries, services, and enterprise applications. Use for Java source, Maven/Gradle JVM projects, Spring when actually present, concurrency, JVM performance, testing, persistence, or Java-specific refactoring.

Java/JVM concurrency and asynchronous-execution specialist. Use when code touches threads, executors, virtual threads, CompletableFuture, locks, atomics, shared mutable state, ThreadLocal or ScopedValue, Spring @Async, blocking work, cancellation, or thread-safety/performance risks. Requires version-aware API verification and evidence for race/deadlock/performance claims.

Kotlin-specific JPA/Hibernate persistence engineering for entities, repositories, relationships, fetch plans, transactions, equality/identity, uniqueness constraints, optimistic locking, and N+1 or LazyInitialization diagnostics.

Semantics-preserving Java→Kotlin and Kotlin/tooling migration workflow for staged conversions where behavior, interop, nullability, framework semantics, serialization, persistence, and public API compatibility must not drift.

Project-aware Kotlin engineering for JVM, Android, server, and multiplatform code. Use for Kotlin source, coroutines/Flow, Gradle Kotlin projects, Compose when present, KMP boundaries, testing, performance, interoperability, and Kotlin-specific refactoring.

Localization and i18n quality workflow for multi-locale applications. Use when adding or changing user-facing strings, locale resources, plurals, formatting, RTL behavior, or when a UI redesign must remain complete and natural across all languages supported by the project.

Specialist reliability workflow for AndroidX Media3 playback, MediaSession/MediaLibrarySession, MediaLibraryService, Android Auto browsing, queue/timeline identity, caching, preload/recovery, audio/video track selection, and audio-processing pipelines. Use when Media3 behavior, APIs, deprecations, playback lifecycle, controller contracts, or automotive media browsing are material.

Retrieves, classifies, validates, and optionally persists compact durable knowledge so future tasks can reuse verified experience without treating memory as current truth. Use when prior project decisions, recurring failures, user-authorized workflow preferences, or general engineering lessons could materially improve a task. Separates IGNORE/SESSION/PROJECT/GENERAL memory, revalidates load-bearing memories against current evidence, prevents sensitive-data and chain-of-thought persistence, an...

High-rigor model-agnostic engineering and visual-production skill protocol for complex, risky, multi-file, debugging, architecture, refactoring, performance, API/data, Java, Kotlin, Python, TypeScript, Go, Rust, UI, images, Android, CI, security, observability, or publication tasks. Routes work through the smallest relevant skill stack, context hygiene, adaptive deliberation, source grounding, anti-hallucination evidence gates, in-flight doubt, host-native specialists when available, causal a...

Defines a compact preservation contract before risky changes to working systems. Use for cache, playback, persistence, sync, migrations, concurrency, networking, UI state machines, or any task where a narrow improvement could accidentally break adjacent behavior that currently works.

Production observability and instrumentation skill for services, background jobs, queues, external integrations, retries, distributed systems, and production incident follow-up. Use when adding or reviewing logs, metrics, traces, correlation, alerting, telemetry privacy, or when a feature needs evidence that production behavior can be diagnosed after release.

Evidence-driven performance engineering for latency, throughput, CPU, memory, startup, build time, rendering, I/O, concurrency, and scalability problems. Use for explicit optimization work or when profiling/benchmark/build evidence is needed before changing a hot path or feedback loop.

Maintains an opt-in, repository-local project knowledge layer for stable architecture, invariants, decisions, regressions, commands, design rules, and project-scoped experience. Use when a project is revisited repeatedly and durable context would reduce rediscovery. Current repository/runtime evidence always outranks the brain; entries carry provenance/freshness; stale facts are retired; secrets and private chain-of-thought are forbidden; and repository files are created or changed only when ...

Project-version-aware Python engineering for services, libraries, automation, data tooling, and applications. Use for Python source, async code, typing, packaging, APIs, testing, profiling, data pipelines, or Python-specific refactoring.

Adaptive deliberation layer for difficult engineering and design work. Use when a task is ambiguous, high-risk, multi-step, architecture-heavy, debugging-heavy, version-sensitive, cross-module, or otherwise likely to reward slower reasoning. Forces explicit problem framing, competing hypotheses/approaches, disconfirmation, independent challenge, evidence-based adjudication, uncertainty tracking, and a final falsifiable proof without exposing private chain-of-thought or adding ceremony to triv...

Behavior-preserving refactoring protocol for simplifying, restructuring, modularizing, or modernizing existing code without silently changing externally observable behavior. Use for non-trivial cleanup, decomposition, abstraction changes, package/module moves, or legacy modernization where regression risk matters.

Runs risk-sized, evidence-first review of code changes. Use before completion, PR creation, or after meaningful implementation. Separates requirement compliance from engineering quality, uses independent reviewer contexts and perspective shifts to break self-review blind spots, confirms findings before fixing them, and supports lite, standard, and deep review depth.

Chooses the smallest compatible process, language, domain, platform, visual, cognitive, and installed-skill stack for a task. Use before complex work and after project discovery. Combines autonomous skill intelligence with task, stack, risk, evidence, source-grounding, context, no-regression, memory/experience, teacher/eval, and in-flight doubt routing instead of requiring the user to manually name the best skills.

Project-aware Rust engineering for libraries, services, CLIs, async applications, and systems code. Use for Rust source, Cargo workspaces/features, ownership/lifetimes, unsafe code, concurrency, tests, performance, or Rust-specific refactoring.

Performs evidence-backed application and agentic-workflow security review. Use for auth, authorization, untrusted input, secrets, cryptography, network exposure, command execution, file/path handling, dependencies, GitHub Actions, MCP/tool integrations, or any explicit security audit. Trace sources to sinks and confirm findings to reduce false positives.

Autonomous skill-selection layer for Thalarch. Use at the start of non-trivial work and again after project discovery when the current host may expose stronger project-local, official platform, Thalarch, or third-party expertise. Shortlists the smallest high-value skill stack based on task fit, project/toolchain compatibility, authority/currentness, tool leverage, evidence needs, redundancy, conflicts, context cost, and actual host availability.

Grounds version-sensitive framework, library, runtime, browser, database, and platform decisions in the exact project version plus current primary documentation. Use before implementing or reviewing non-trivial external APIs, configuration, migration guidance, compatibility behavior, or framework-specific patterns where model memory can be stale.

Turns broad feature or architecture requests into an executable acceptance contract. Use for multi-file features, refactors, migrations, architecture work, ambiguous behavior, or whenever implementation could succeed technically while missing the user's actual intent.

Audits provenance and instruction-supply-chain risk for external skills, MCP/tool descriptions, retrieved prompts, agent packs, plugins, installers, and imported automation. Use before trusting third-party agent instructions or when prompt/tool poisoning, hidden directives, integrity drift, or credential exfiltration is plausible.

Runs a bounded teacher/judge/revision loop around model-produced engineering work. Use when an independent evaluator can materially improve correctness, scope discipline, regression safety, evidence honesty, design quality, or general-purpose skill/prompt behavior. Judges artifacts and acceptance evidence rather than private reasoning, uses hard gates before optional scoring, prevents self-certification and benchmark gaming, limits revision cycles, and combines with thalarch-autoresearch plus...