Nexa AI Assist

Expert Nexa knowledge for AI coding agents. Drop the skills into your Kotlin project and your agent writes correct wallet, transaction, token, and smart-contract code from day one.

AI-assisted Nexa development

What it is

Nexa AI Assist is a curated set of documents that your coding agent consults while it works - each one packed with the mental models, working code patterns, common mistakes, and security pitfalls for each area of Nexa development.

The collection of skills covers the full development stack (see table below).

With the skills in place, your agent writes Nexa-specific code based on vetted documentation of all the major Nexa Kotlin code libraries instead of guessing - and avoids carrying over habits from other blockchains that don't apply to Nexa.

The skills are initially aimed at Kotlin + Compose Multiplatform development paired with Claude Code agents, but should be compatible with various other coding agents.

Who it's for

Nexa AI Assist meets you wherever you are on the learning curve:

Idea-first builders: you know what you want to create but not (yet) how to code it. Your agent carries the Nexa expertise, so describing the application is enough to get working, correct code.
Developers new to Nexa: you can build software but don't know the Nexa ecosystem. The skills give your agent the libraries, patterns, and pitfalls up front, so you skip the weeks of trial and error.
Experienced Nexa developers: you know the stack and want to move faster. Use your agent to generate boilerplate, answer deep questions instantly, and review your code for correctness and security like a Nexa expert would.

How to start

Add the skills to your project

Path A: your own project (existing or from scratch). Clone the skills repository and copy the skills/ folder into your project's .claude/skills/ directory:

git clone https://gitlab.com/nexa/nexaaiskills.git
cp -r nexaaiskills/skills your-project/.claude/skills

This means when a new version of the skills is available, you will need to delete the skills from your project, pull the latest skills from the git repo, and re-copy the new skills.

With a bit more up-front setup, you can easily update your skills in the future: Gradle projects can let the plugin manage the skills as a versioned dependency instead - this means only needing to bump your version and run a single command to update your skills in the future. Declare the registry in settings.gradle.kts:

pluginManagement {
    repositories {
        maven { url = uri("https://gitlab.com/api/v4/projects/83996664/packages/maven") }
        gradlePluginPortal()
    }
}

dependencyResolutionManagement {
    repositories {
        maven {
            url = uri("https://gitlab.com/api/v4/projects/83996664/packages/maven")
            content { includeModule("org.nexa", "nexaaiskills-files") }
        }
    }
}

apply the plugin in the root build.gradle.kts (the package registry lists available versions):

plugins {
    id("org.nexa.aiskills") version "<version>"
}

then pull the skills into .claude/skills/:

./gradlew syncNexaSkills

Path B: build on the Nexa Starter App. The starter app already includes the skills plugin, so clone it and sync:

git clone https://gitlab.com/nexa/examples/starter.git
cd starter
./gradlew syncNexaSkills

Prime your agent

At the start of each new conversation, point your agent at the priming prompt. It teaches the agent the full scope of the available skills, when to consult each one, and the development practices and conventions to follow. A one-liner is enough:

Before doing any work, read .claude/skills/primeAgentPrompt.md and follow the guidance it contains.

Tip: add that line to your project's agent instructions file (for example CLAUDE.md) so it happens automatically in every session.

Describe what you want to build

Now just tell your agent what you want. Anything works, from a one-line idea to a full technical spec. More detail buys you more design control: a rich prompt means the first result matches your intent more closely, with fewer follow-up rounds. But correctness doesn't depend on it. The skills carry the Nexa expertise, so even a simple prompt is enough for the agent to produce a working, correct application.

A simple, high-level prompt:

Build me a web app where visitors connect their Wally wallet and can mint
their own NFT collection. Each NFT should show its artwork on the site.

A detailed, spec-style prompt:

Build a loyalty rewards service for my shop. Ktor backend, Compose
Multiplatform frontend.
- The server holds its own signing wallet with the MINT authority for a
  "points" token group it creates at first startup.
- Customers connect their Wally wallet. When they pay an invoice in NEXA
  via a TDPP payment request, the server mints points to their wallet
  proportional to the amount paid.
- Customers can redeem points for a discount: they send points back to the
  server wallet, which melts them and issues a discount code.
- Confirm incoming payments by monitoring the server address over Electrum;
  show each customer's live points balance in the UI via server flows.
Start with a written implementation plan for my review, then build it.

The skills at a glance

Skill	What it covers
`nexa-capd-messaging`	Nexa's off-chain P2P message bus for multi-party coordination.
`nexa-compose-ui-design`	Building a themed, responsive frontend with the Compose Multiplatform design library.
`nexa-debugging-onchain-errors`	Diagnosing failures: maps error symptoms to their cause - whether at build time, at runtime, or on-chain.
`nexa-electrum-monitoring`	Light-client queries and monitoring of any on-chain state, no node required.
`nexa-identity-and-addresses`	Nexa address types and the stable-identity vs rotating-payout address split.
`nexa-ktor-server-integration`	Wiring the Ktor server: config, wallet routes, sessions, and serving the frontend.
`nexa-locktime-cltv`	Time-locked coins and contracts, including the built-in TimeLockVault.
`nexa-npl-smart-contracts`	Writing, compiling, and spending NPL (Kotlin DSL) smart contracts.
`nexa-project-setup`	Gradle setup, version compatibilities, the Nexa Maven repos, and the skills-sync plugin.
`nexa-rpc-node-client`	Talking JSON-RPC to a full node you operate: chain reads, broadcasting, regtest testing.
`nexa-script-machine-testing`	Executing and debugging contract spends locally against the real script VM.
`nexa-server-state-and-flows`	Live server-to-UI state over WebSocket flows and notifications.
`nexa-spec-authoring`	Writing and revising pages of the Nexa protocol specification.
`nexa-tokens-and-groups`	Native tokens and NFTs: creating groups, minting, metadata, and ownership proofs.
`nexa-transaction-construction`	Building, signing, validating, and broadcasting Nexa transactions.
`nexa-wallet-connection`	Connecting a user's external Wally wallet: login QR codes, payment pushes, and callbacks.
`nexa-wallet-lifecycle-and-chain`	Create, restore, and open wallets your own code holds the keys to, and sync them to the chain.

Links

Nexa AI Assist on GitLab

Starter App on GitLab