nft-standards

Overview of nft-standards skill

What the nft-standards skill does

The nft-standards skill helps an agent design and implement NFT contracts and related product logic around ERC-721 and ERC-1155, with attention to metadata, minting patterns, royalties, marketplace behavior, soulbound variants, and dynamic NFTs. It is most useful when you need code structure and decision guidance for NFT features, not just a one-off Solidity snippet.

Who should use nft-standards

This nft-standards skill is a good fit for:

• Web3 developers choosing between ERC-721 and ERC-1155
• teams launching NFT collections or game assets
• marketplace builders handling metadata and transfers
• product engineers adding royalties, reveal mechanics, or non-transferable tokens

If your job is “help me implement NFTs correctly for my use case,” this skill is closer to the task than a generic smart-contract prompt.

Real job-to-be-done

Users usually care less about the standard names and more about practical decisions:

• Which NFT standard fits my product?
• How should metadata be stored and exposed?
• What minting limits and pricing checks do I need?
• How do royalties and marketplace expectations affect the contract?
• When should I use soulbound or dynamic NFT patterns?

The nft-standards page is valuable because it frames those choices in implementation terms.

What makes this skill different from a generic prompt

The source skill is narrowly scoped to NFT standards for Web3, so it gives the model a stronger default frame than “write me an NFT contract.” It covers:

• ERC-721 for unique tokens
• ERC-1155 for multi-token or semi-fungible systems
• metadata patterns
• royalties and advanced NFT behaviors

That focus reduces prompt drift, especially when you want the agent to reason about standard selection before writing code.

Limits you should know before installing

This skill is content-only: the repository path exposes just SKILL.md and no helper scripts, tests, reference docs, or decision tables. That means nft-standards install is lightweight, but output quality depends heavily on the prompt you provide. Treat it as guided implementation context, not a full audited framework or production-ready contract suite.

How to Use nft-standards skill

Install context for nft-standards

Install the skill from the parent repository:

npx skills add https://github.com/wshobson/agents --skill nft-standards

Because the skill lives at plugins/blockchain-web3/skills/nft-standards, there is no separate package setup inside the skill itself. After install, your agent can pull this domain context when your request clearly involves NFT standards.

Read this file first

Start with:

• SKILL.md

There are no additional README.md, rules/, resources/, or helper files in this skill folder, so nearly all useful guidance is concentrated in that single file. This makes evaluation fast: you can skim the whole skill before deciding whether it matches your stack.

Best nft-standards usage cases

Use nft-standards usage when you need the agent to:

• choose between ERC-721 and ERC-1155
• scaffold an NFT contract with minting constraints
• define metadata fields and token URI strategy
• add royalty support and marketplace-friendly behavior
• propose dynamic NFT or soulbound adaptations

It is especially useful early in architecture and first implementation, when the wrong standard choice is expensive to reverse.

Inputs the skill needs to work well

The skill performs much better if you provide:

• target standard if already known, or the business model if not
• chain or EVM environment
• whether metadata is on-chain, IPFS, or centralized
• mint model: public mint, allowlist, lazy mint, admin mint
• transfer policy: transferable, restricted, or soulbound
• supply rules and per-wallet/per-tx limits
• royalty expectations
• marketplace compatibility requirements
• whether tokens are unique, editions, or game inventory items

Without these details, the model will default to common examples rather than your actual constraints.

Turn a rough goal into a strong prompt

Weak prompt:

Build me an NFT contract.

Stronger nft-standards guide prompt:

Use the nft-standards skill to recommend ERC-721 or ERC-1155 for a game with unique character NFTs and stackable item NFTs. We need IPFS metadata, OpenSea-compatible metadata, creator royalties, admin minting for rewards, and a soulbound achievement badge. Explain the standard split, then generate Solidity contracts using OpenZeppelin and list security and marketplace tradeoffs.

Why this is better:

• it gives product shape
• it asks for a standard decision, not just code
• it names metadata and marketplace constraints
• it surfaces mixed asset types that may need multiple contracts

Prompt pattern for contract generation

A reliable structure is:

1. describe the asset model
2. state transferability rules
3. define metadata location
4. state minting permissions and limits
5. name external compatibility needs
6. request code plus reasoning

Example:

Use nft-standards for Web3 contract design. Build an ERC-1155 for in-game items with fungible and semi-fungible token IDs, URI substitution metadata, batch minting, operator approvals, and royalties. Include admin-only mint, pause controls, and a short explanation of why ERC-1155 is better than ERC-721 here.

Choosing between ERC-721 and ERC-1155

This is often the highest-value use of the skill.

Use ERC-721 when:

• every token is meaningfully unique
• collection identity matters
• marketplaces and wallet display for 1/1 assets are the priority

Use ERC-1155 when:

• you need many token types in one contract
• batch transfers or mints matter
• some items are semi-fungible or supply-based
• gas efficiency is important across many asset classes

Ask the skill to justify the choice in terms of inventory model, metadata structure, and transfer behavior.

Practical workflow for nft-standards for Web3

A good workflow is:

1. ask the skill to classify your NFT model
2. request a recommended standard and contract shape
3. review minting, metadata, and transfer assumptions
4. ask for production hardening gaps
5. then generate or refactor code in your repo

This sequence is better than asking for final code immediately, because NFT projects fail on requirements mismatch more often than syntax.

What to inspect in the output

When the agent uses nft-standards, verify that the response covers:

• standard choice and why
• metadata URI design
• mint permissions and supply caps
• royalty mechanism
• marketplace compatibility assumptions
• whether transfer restrictions break standard expectations
• edge cases like reveal, freezing metadata, or evolving state

If those are missing, the output is too generic.

Common adoption blockers

The main blockers are not installation issues but implementation ambiguity:

• unclear distinction between ERC-721 and ERC-1155
• missing metadata strategy
• assuming royalties are enforced on-chain everywhere
• requesting soulbound behavior without considering ecosystem compatibility
• mixing unique and fungible asset models in one vague brief

The skill helps most when you make those product decisions explicit up front.

nft-standards skill FAQ

Is nft-standards good for beginners?

Yes, if you already understand basic Solidity and token concepts. The nft-standards skill gives useful implementation direction, but it is not a full beginner tutorial on smart contracts, deployment, or security auditing.

When should I not use nft-standards?

Do not reach for nft-standards if your task is mainly:

• token economics for fungible tokens
• wallet integration without contract design
• marketplace backend indexing only
• legal/compliance advice
• production security review or audit signoff

It is strongest on NFT contract and metadata design, not the whole launch lifecycle.

Does nft-standards replace OpenZeppelin docs?

No. It complements them. Use the skill to frame the solution and generate a fit-for-purpose implementation plan, then confirm inheritance choices, hooks, and extension behavior against official library docs.

Can nft-standards help with soulbound NFTs?

Yes. The source explicitly includes soulbound use cases. Still, you should ask the agent to explain how transfer blocking affects wallet support, marketplace assumptions, and user expectations, because “non-transferable NFT” implementations vary.

Is nft-standards enough for marketplace integration?

It helps with marketplace-aware design, especially metadata and royalty-related expectations, but it does not guarantee compatibility with every marketplace. You still need to test metadata rendering, royalty handling, approvals, and indexing behavior on your target platforms.

What if I only need a simple collection contract?

The skill can still help, but keep the prompt narrow. If you only want a standard fixed-supply collection, say so. Otherwise the agent may add optional features like royalties or advanced metadata patterns you do not need.

How to Improve nft-standards skill

Give nft-standards better product context

The fastest way to improve nft-standards output is to describe the asset system, not just the contract type. For example:

• “10,000 unique profile-picture NFTs with reveal metadata”
• “game items with stackable consumables and unique skins”
• “non-transferable completion badges”

That level of context leads to better standard selection and fewer irrelevant features.

Specify metadata rules early

Many bad outputs come from weak metadata instructions. Tell the skill:

• whether metadata is immutable or updateable
• whether URIs are per-token or templated
• whether images and attributes live on IPFS or elsewhere
• whether reveal or evolution is required

This changes both storage design and contract surface area.

Ask for tradeoffs, not just code

A stronger prompt is:

Use nft-standards to propose two designs, compare ERC-721 and ERC-1155, then recommend one.

This surfaces hidden decisions before the model commits to an implementation. It is especially useful for mixed collections, gaming assets, and dynamic NFTs.

Watch for common failure modes

Typical weak outputs include:

• using ERC-721 where batch-heavy ERC-1155 is a better fit
• ignoring metadata hosting assumptions
• treating royalties as universally enforceable
• adding enumerable extensions without discussing gas tradeoffs
• implementing soulbound restrictions without ecosystem caveats

If you see these, ask for a revised design with explicit constraints and tradeoff discussion.

Request iteration after the first draft

After the first answer, refine with one targeted follow-up:

• “Optimize for gas over convenience.”
• “Keep marketplace compatibility high.”
• “Remove all optional features not needed for launch.”
• “Separate unique and semi-fungible assets into different contracts.”
• “Explain security risks around minting and metadata updates.”

This is usually more effective than starting over.

Improve nft-standards with repo-local constraints

If you want code you can actually merge, include:

• Solidity version
• OpenZeppelin version
• upgradeable vs non-upgradeable preference
• existing access control model
• testing framework
• deployment environment

The nft-standards skill has no built-in repo awareness, so these constraints must come from you.

Use nft-standards as a decision layer

The best use of nft-standards is often before coding: have it validate the asset model, metadata plan, and transfer logic first. Once those decisions are sound, use a second prompt to produce implementation-ready code. This two-step approach consistently yields better Web3 results than asking for a full NFT contract in one shot.