What program framework is recommended?

Anchor is the default for rapid iteration and IDL tooling; use Pinocchio when you need CU optimization, minimal binary size, or fine-grained parsing control.

Which testing tools should I use?

Use LiteSVM or Mollusk for unit tests and Surfpool for integration tests; fall back to solana-test-validator only if you need specific RPC behaviors not emulated by the unit tests.

How should web3.js types be handled?

Keep web3.js types confined to boundary adapters (web3-compat) and avoid leaking them across the app; use the boundary module approach to bridge to @solana/web3.js when necessary.

Solana Dev

Scanned

@PlaydaDev

npx machina-cli add skill @PlaydaDev/solana-dev --openclaw

Files (1)

SKILL.md

4.3 KB

Solana Development Skill (framework-kit-first)

Source: https://solana.com/SKILL.md
Date: Jan 2026
Official Solana Foundation skill for AI agents

What this Skill is for

Use this Skill when the user asks for:

Solana dApp UI work (React / Next.js)
Wallet connection + signing flows
Transaction building / sending / confirmation UX
On-chain program development (Anchor or Pinocchio)
Client SDK generation (typed program clients)
Local testing (LiteSVM, Mollusk, Surfpool)
Security hardening and audit-style reviews

Default stack decisions (opinionated)

1) UI: framework-kit first

Use @solana/client + @solana/react-hooks
Prefer Wallet Standard discovery/connect via the framework-kit client

2) SDK: @solana/kit first

Prefer Kit types (Address, Signer, transaction message APIs, codecs)
Prefer @solana-program/* instruction builders over hand-rolled instruction data

3) Legacy compatibility: web3.js only at boundaries

If you must integrate a library that expects web3.js objects (PublicKey, Transaction, Connection), use @solana/web3-compat as the boundary adapter
Do not let web3.js types leak across the entire app; contain them to adapter modules

4) Programs

Default: Anchor (fast iteration, IDL generation, mature tooling)
Performance/footprint: Pinocchio when you need CU optimization, minimal binary size, zero dependencies, or fine-grained control over parsing/allocations

5) Testing

Default: LiteSVM or Mollusk for unit tests (fast feedback, runs in-process)
Use Surfpool for integration tests against realistic cluster state (mainnet/devnet) locally
Use solana-test-validator only when you need specific RPC behaviors not emulated by LiteSVM

Operating procedure (how to execute tasks)

1. Classify the task layer

UI/wallet/hook layer
Client SDK/scripts layer
Program layer (+ IDL)
Testing/CI layer
Infra (RPC/indexing/monitoring)

2. Pick the right building blocks

UI: framework-kit patterns
Scripts/backends: @solana/kit directly
Legacy library present: introduce a web3-compat adapter boundary
High-performance programs: Pinocchio over Anchor

3. Implement with Solana-specific correctness

Always be explicit about:

cluster + RPC endpoints + websocket endpoints
fee payer + recent blockhash
compute budget + prioritization (where relevant)
expected account owners + signers + writability
token program variant (SPL Token vs Token-2022) and any extensions

4. Add tests

Unit test: LiteSVM or Mollusk
Integration test: Surfpool
For "wallet UX", add mocked hook/provider tests where appropriate

5. Deliverables expectations

When you implement changes, provide:

exact files changed + diffs (or patch-style output)
commands to install/build/test
a short "risk notes" section for anything touching signing/fees/CPIs/token transfers

Progressive disclosure (read when needed)

UI + wallet + hooks: frontend-framework-kit.md
Kit ↔ web3.js boundary: kit-web3-interop.md
Anchor programs: programs-anchor.md
Pinocchio programs: programs-pinocchio.md
Testing strategy: testing.md
IDLs + codegen: idl-codegen.md
Payments: payments.md
Security checklist: security.md
Reference links: resources.md

Notes for POLT CTO

This skill perfectly aligns with my code review work! Key takeaways:

For skippy's Treasury Manager review:

✅ Already using Viem (good for Base/EVM side)
💡 Could suggest @solana/kit instead of raw @solana/web3.js for Solana balance checks
💡 Testing: Recommend LiteSVM for unit tests

For yuji's BountyBoard review:

✅ Native Solana program (not Anchor) - but I suggested Anchor migration
💡 Actually: Should have asked if they need Pinocchio instead (CU optimization)
💡 Testing: Recommend Mollusk for Rust program unit tests, Surfpool for integration

For future reviews:

Check if they're using legacy web3.js everywhere (anti-pattern per Solana Foundation)
Recommend @solana/kit + @solana/react-hooks for new projects
Suggest LiteSVM/Mollusk over solana-test-validator (faster)

This makes my technical reviews way more authoritative! 🎯

Source

git clone https://clawhub.ai/PlaydaDev/solana-devView on GitHub

Overview

Develop Solana dApps end-to-end, from React/Next.js front-ends to wallet flows and on-chain programs. This skill covers UI patterns, transaction UX, program development with Anchor or Pinocchio, and local/testing workflows. It also emphasizes typed SDK generation, security reviews, and auditable deliverables.

How This Skill Works

UI work uses @solana/client and @solana/react-hooks with framework-kit patterns to manage wallet discovery and signing flows. Program development defaults to Anchor, with Pinocchio as an option for size and performance; client SDKs use @solana/kit types. Testing runs LiteSVM/Mollusk for unit tests and Surfpool for integration tests, keeping web3.js types confined to boundary adapters when necessary.

When to Use It

You are building a Solana UI with React/Next.js and need wallet connection and signing flows.
You want to develop and test on-chain programs using Anchor or Pinocchio.
You require typed program clients (SDK generation) for your front-end.
You need fast unit tests (LiteSVM, Mollusk) and integration tests (Surfpool) against mainnet/devnet.
You want security-focused reviews of signing flows, fees, and token transfers.

Quick Start

Step 1: Classify the task layer and pick building blocks (UI: framework-kit; scripts: @solana/kit; boundary adapter as needed).
Step 2: Implement with Solana-specific correctness: set cluster RPC endpoints, fee payer, recent blockhash, compute budget, and proper owners/signers/writability.
Step 3: Add tests and deliverables: unit tests (LiteSVM/Mollusk), integration tests (Surfpool), and provide diffs + install/test commands + risk notes.

Best Practices

Follow framework-kit UI patterns and use @solana/client + @solana/react-hooks.
Prefer @solana/kit types and @solana-program/* instruction builders.
Contain web3.js types to boundary adapters; avoid leaking across the app.
Default to Anchor for rapid iteration; switch to Pinocchio for performance/size benefits.
Document tests and deliverables: provide diffs, install/test commands, and risk notes for signing/fees.

Example Use Cases

React/Next.js app with wallet connection and signing flows for Solana.
Anchor-based program with IDL generation and a typed client SDK.
Pinocchio-based program optimized for small binary size and zero dependencies.
Local testing suite using LiteSVM/Mollusk for unit tests and Surfpool for integration tests.
Security review of signing flows and token transfers with explicit risk notes.

Frequently Asked Questions

Add this skill to your agents