skills

Skills

A set of skills for Kotlin, Jetpack Compose, Android development, and grounded writing.

The repository is also a portable Agent Plugins v1.0.0 package. Conforming clients discover the root plugin.json and the immediate skill directories under skills/.

Install

With the skills CLI:

npx skills add chrisbanes/skills

Or install as a Claude Code plugin:

/plugin marketplace add chrisbanes/skills
/plugin install chrisbanes-skills@chrisbanes-skills

Or install as a Codex plugin:

codex plugin marketplace add chrisbanes/skills --ref main
codex plugin add chrisbanes-skills@chrisbanes-skills

Or install as an OpenCode V2 plugin (2.0.22 or newer):

{
  "plugins": ["chrisbanes-skills@git+https://github.com/chrisbanes/skills.git"]
}

OpenCode V1 1.18.29 or newer uses plugin instead of plugins. See .opencode/INSTALL.md for details.

External skill providers

Most skills in this repository are self-contained. The workflows below compose with skills from other repositories; installing chrisbanes/skills does not install them, and the workflows never install them implicitly.

Delivery and parallel implementation use one fresh independent read-only reviewer against the approved source and repository standards; no external review skill or issue-tracker setup is required. Reviews include the production paths and boundary cases examined and material uncertainty. The authoritative behavioral review and repair procedure covers related boundary repairs, sensitive fixture calibration before expansion, rendering-consumer tracing, repeated external findings and browser diagnostics. npm run references:sync supplies identical local copies to its consumers; edit the authoritative source, not the copies. The same mechanism supplies to-plan's boundary-validation rule to implementation consumers.

Delivery and planning select affected existing tests through shared-structure consumers and structural audits. Unsettled fixtures establish one sensitive case before expanding the acceptance matrix; established fixtures reuse valid evidence.

Review mode in implement-with-subagents, and review or setup mode in run-github-project, do not require these external skills. See the run-github-project provider matrix for its lane-specific fallback and blocking behavior.

Skills

Start here

• Working on Compose state or effects? Start with compose-state-and-effects.
• Investigating recomposition, stability, or jank? Start with compose-performance.
• Comparing Android benchmark configurations or a measured Android default? Start with android-benchmark-comparison.
• Reviewing Flow or coroutine architecture? Start with kotlin-concurrency-and-flow.

Routing

• using-chrisbanes-skills — route Kotlin and Jetpack Compose work to focused skills, adding a second only for an independent decision in the same change.

Benchmarking

• android-benchmark-comparison — compare physical Android benchmark configurations with verified coverage, controlled conditions, trace-backed diagnosis of unstable rankings, and bounded conclusions.

Jetpack Compose

State and side effects

• compose-state-and-effects — decide state ownership and effect lifecycle for local UI state, screen state holders, Flow collection, callbacks, cleanup, navigation, snackbar, analytics, and focus requests.

Performance

• compose-performance — diagnose stability, deferred reads, composition contracts, and cross-phase back-writing from concrete runtime evidence.

UI API design and layout

• compose-component-design — design caller-placeable Compose APIs whose variable visual regions are caller-provided slots.
• compose-animations — choose Compose animation APIs for visibility, value targets, coordinated transitions, and content swaps; align with official quick guide and decision tree.
• compose-focus-navigation — design and test keyboard, TV, D-pad, and focus-first Compose navigation behavior.

Testing

• compose-ui-testing-patterns — choose between plain UI tests, semantics assertions, key/focus tests, interaction state tests with MutableInteractionSource, screenshot tests, and integration tests.

Kotlin

• kotlin-concurrency-and-flow — review coroutine, raw Thread, and Executor ownership, cancellation, Flow state/event modeling, sharing, replay, and one-shot delivery.
• kotlin-control-flow — write and review Kotlin branching with subject when, guard conditions, sealed exhaustiveness, smart casts, nullable branching, and early returns.
• kotlin-api-design — choose function owners, semantic domain types, and Kotlin Multiplatform platform boundaries.

Writing

• changelog — reconcile Unreleased or specified-release notes with verified history, issue/PR links and contributor credit; preserve curated text and prerelease history across languages and publishing systems.
• grounded-writing — draft or review public developer documentation and other user-owned text using Chris Banes’s writing as the sole style model, including internal report reviews, while preserving evidence, format, review-only authority, and material-edit restraint.

Workflows

• deliver-spec — coordinate one approved spec or verified Project-controller handoff through solo or justified delegated implementation, a planning-free fast path for small well-understood tickets, CI-supplied full-suite evidence, concurrent external review with verified draft support or earlier PR readiness, reusable scope approval and evidence, independent integrated-candidate review and focused repair review, and PR shepherding; validate applicable live-qualification harness paths offline (isolated production stores for persistent paths, fake runtimes for asynchronous paths), then reconcile failures under bounded approved allowances.
• release-kotlin-library — assess readiness, prepare, and verify Kotlin library releases; check the gradle-maven-publish-plugin prerequisite, use changelog for notes, prepare Metalava API snapshots, and follow repository checks and publication gates.
• gradle-run — run every agent-initiated Gradle command through a compact-output wrapper; recover run identity and bounded results by workflow ID with read-only status, and diagnose failures with optional investigation helpers.
• subagent-delegation — provider-neutral delegation playbook, loaded by name or through a one-line user-level opt-in, with separate Codex and Claude Code model routing, installed-role precedence, parallel briefs, independent audits, and lead acceptance.
• implement-with-subagents — choose solo implementation for a single item or serial graph and worker ownership for every item in a graph with parallel work; preserve dependency-aware integration, independent final review, same-owner repair, bounded checkout reuse, and read-only orchestration review.
• to-plan — create risk-scaled implementation plans that prove baselines from green CI, with observable slices and consequential boundary validation before dependent work, plus authenticated integration amendments and explicit consumer handoffs; decide separate PRs by coherent deliverable boundaries.
• run-github-project — set up, review, or operate a repository's GitHub Project workflow with current-column authorization, human-only Backlog promotion, and deterministic configured agent selection; deliver ordinary implementation tickets through deliver-spec, resolve run-level merging once at startup with a 60-second default-no question unless already specified, preflight offline live-qualification harness evidence, preserve asynchronous or persistent failures in durable checkpoints, prioritize active delivery through safe planner checkpoints, fast-path small Todo tickets straight into implementation, start external review while CI runs after local qualification, free slots while reviewed PRs wait on CI, record ticket-local pauses while independent work continues, and keep drain alive under a read-only Project Watcher instead of returning at the first human wait.
• shepherd — poll open PRs and MRs directly in the controller, using a read-only helper only for a bounded large failed-log question, or follow a host PR monitor's wake events (such as Claude desktop's Auto-fix) instead of polling, triage review comments, and repair CI failures with affected checks and required integrated-candidate validation; start external review during CI while retaining final-head merge gates.

For selective skill installations, install changelog alongside release-kotlin-library; the full plugin includes both.

Workflows that delegate agents share the subagent selection and handoff reference. Each workflow retains its own delegation trigger, authority, and acceptance rules. Each consuming skill also contains a copy of the reference for standalone installation. deliver-spec bundles its own solo-or-delegated implementation procedure; implement-with-subagents chooses solo or delegated ownership once from the whole task graph.

Planning and drain admission distinguish behavioral prerequisites, shared-file mutation conflicts and final integration requirements. Plan-proven independent preparation needs explicit slice ownership, permitted paths/resources, focused checks and a stop before shared edits; native blockers, accepted-plan ordering,