suggest-tooling

Suggest Cardano Tooling

Help the developer choose the right tools, SDKs, and libraries for their Cardano project based on their requirements and preferred programming language.

When to use

• Developer is starting a new Cardano project and needs tool recommendations
• Comparing SDKs (Mesh vs Evolution SDK vs PyCardano vs others)
• Choosing a smart contract language (Aiken vs Plutus vs others)
• Selecting infrastructure components (indexers, APIs, testing tools)
• Evaluating wallet integration options
• Understanding which CIPs are relevant to their project

When NOT to use

• Already chosen tools and needs help using them (use specific tool skills)
• Setting up a devnet (use setup-devnet skill)
• Querying chain data with a specific provider (use query-chain skill)
• Detailed wallet integration steps (use connect-wallet skill)

Key principles

1. Start from the project requirements, not the tools. Understand what they are building before recommending.
2. Language preference matters. A Python developer should know about PyCardano; a TypeScript developer about Mesh and Evolution SDK.
3. Recommend production-ready tools first. Flag experimental tools clearly.
4. Fewer tools is better. Do not recommend 10 options when 2 will do.
5. Consider the full stack. Smart contracts, off-chain code, infrastructure, testing, and deployment are all part of the picture.

Workflow

Step 1: Understand the project

Ask the developer (if not already clear):

• What are you building? (dApp, DeFi protocol, NFT platform, governance tool, data analytics, wallet, library)
• What programming language(s) do you prefer?
• Do you need smart contracts? If yes, how complex?
• What is your deployment target? (mainnet, testnet, local devnet)
• What is your experience level with Cardano? (new, intermediate, advanced)
• Any existing infrastructure? (running a node, using hosted APIs)

Step 2: Search Bundled Documentation

Search the bundled documentation for relevant content:

• ${CLAUDE_SKILL_DIR}/../../docs/sources/mesh-sdk/ - Mesh SDK docs
• ${CLAUDE_SKILL_DIR}/../../docs/sources/evolution-sdk/ - Evolution SDK docs
• ${CLAUDE_SKILL_DIR}/../../docs/sources/aiken/ - Aiken language docs
• ${CLAUDE_SKILL_DIR}/../../docs/sources/ogmios/ - Ogmios WebSocket bridge docs
• ${CLAUDE_SKILL_DIR}/../../docs/sources/blockfrost-openapi/ - Blockfrost API docs

Step 3: Search the ecosystem map

Reference the ecosystem map for the full landscape:

File: skills/suggest-tooling/references/ecosystem-map.md

Step 4: Recommend by category

Smart Contract Languages

Language	Best for	Language base	Status
Aiken	Most new projects, performance-critical validators	Own syntax (Rust-like)	Production
Plinth (formerly Plutus Tx)	Haskell teams, complex on-chain logic	Haskell	Production
OpShin	Python developers writing validators	Python	Production
Pebble	TypeScript developers wanting on-chain code in TS (@harmoniclabs/pebble, successor of Plu-ts)	TypeScript	Production
Scalus	Scala/JVM teams	Scala	Production
Helios	Simple validators, quick prototyping	Own syntax (JS-like)	Production

Default recommendation: Aiken. Best tooling, fastest compilation, growing community, excellent documentation. Unless the team has a strong reason to use another language.

Off-Chain SDKs

SDK	Language	Best for	Status
Mesh SDK	TypeScript/JS	Full-stack dApp development, beginners	Production
Evolution SDK	TypeScript/JS	IntersectMBO's canonical Lucid-lineage successor. Type-safe, Effect-based composable tx building (Client.make(...).withBlockfrost(...).newTx().payToAddress(...).build())	Production
PyCardano	Python	Python backends, scripting, data science	Production
Cardano CLI	Shell	DevOps, scripting, node operators	Production
cardano-js-sdk	TypeScript	Lace wallet ecosystem, full node interaction	Production
Blaze	TypeScript	Lightweight, modular tx building	Production
Cardano Java Client Lib	Java/Kotlin	JVM backends, Android	Production
whisky	Rust	Transaction building for dApps (Mesh-like API; young project by SIDAN Lab)	Production
Pallas	Rust	Low-level building blocks: network protocols, ledger primitives, indexers (foundation of Dolos, Oura, Amaru)	Production

Default recommendation by language:

• TypeScript/JavaScript: Mesh SDK (comprehensive, well-documented, great for beginners) or Evolution SDK (type-safe, Effect-based composable builder)
• Python: PyCardano
• Rust: Pallas
• Java/Kotlin: Cardano Java Client Lib

Infrastructure

Tool	Purpose	Type
Blockfrost	Chain data API	Hosted
Koios	Chain data API	Hosted (community)
Ogmios	Node WebSocket bridge	Self-hosted
Kupo	UTxO indexer	Self-hosted
DB-Sync	Full chain PostgreSQL	Self-hosted
Oura	Event pipeline	Self-hosted
Yaci DevKit	Local devnet	Self-hosted

Default recommendation: Blockfrost for getting started (easy, hosted). Ogmios + Kupo for production self-hosted.

Testing

Tool	Purpose
Aiken built-in tests	Unit and property tests for Aiken validators
Yaci DevKit	Local devnet for integration tests
Preview testnet	Public testnet with frequent hard forks
Preprod testnet	Public testnet mirroring mainnet
tx-village	Transaction-level testing framework

Wallet Integration

Tool	Purpose
Mesh SDK	React hooks and components for wallet connection
CIP-30 direct	Vanilla JS wallet connection
CIP-95	Governance extensions for wallets
WalletConnect	Mobile wallet connection

Step 5: Recommend a stack

Based on the project requirements, recommend a concrete stack. Example stacks:

Beginner dApp (TypeScript)

• Smart contracts: Aiken
• Off-chain: Mesh SDK
• Infrastructure: Blockfrost
• Testing: Aiken tests + Yaci DevKit
• Wallet: Mesh wallet hooks

DeFi Protocol (TypeScript, advanced)

• Smart contracts: Aiken
• Off-chain: Evolution SDK or Blaze
• Infrastructure: Ogmios + Kupo (self-hosted)
• Testing: Aiken property tests + Preview testnet
• Wallet: CIP-30 direct integration

Python Backend

• Smart contracts: Aiken (or OpShin if team prefers Python on-chain too)
• Off-chain: PyCardano
• Infrastructure: Blockfrost or Koios
• Testing: Aiken tests + pytest with PyCardano

Data Analytics Platform

• Infrastructure: DB-Sync (SQL) + Oura (streaming)
• Language: Python or SQL
• No smart contracts needed

Governance Tool

• Off-chain: Mesh SDK (CIP-95 support)
• Infrastructure: Blockfrost or Koios (governance endpoints)
• Wallet: CIP-30 + CIP-95
• Reference: CIP-1694 for governance actions

Step 6: Mention relevant CIPs

Based on the project type, flag relevant CIPs:

Project type	Relevant CIPs
Any dApp	CIP-30 (wallet bridge), CIP-57 (blueprints)
Token/NFT	CIP-25 (NFT metadata), CIP-68 (rich FTs/NFTs)
Governance	CIP-1694 (governance), CIP-95 (wallet governance)
Multi-sig	CIP-1854 (multi-sig wallets)
Metadata	CIP-20 (tx metadata), CIP-25 (NFT metadata)
DEX	CIP-35 (on-chain message signing)

Step 7: Flag trade-offs

For each recommendation, briefly note:

• Maturity: How battle-tested is this tool?
• Community: Size and responsiveness of the community
• Documentation: Quality and completeness
• Maintenance: Is it actively maintained? Who maintains it?
• Lock-in: How easy is it to switch later?

References

• skills/suggest-tooling/references/ecosystem-map.md -- Full ecosystem map with all tools
• Cardano developer portal: https://developers.cardano.org
• Aiken: https://aiken-lang.org
• Mesh SDK: https://meshjs.dev
• Evolution SDK: https://github.com/IntersectMBO/evolution-sdk (docs: https://evolution-sdk.dev)
• PyCardano: https://pycardano.readthedocs.io
• Blockfrost: https://blockfrost.io