I built the PCC collection — 420 Pizza Connection game artifacts — using Claude for the contract work, the deployment pipeline, and the metadata structure. Not as a vibe exercise. As a real deployment on Polygon with real ownership, OpenSea visibility, and public contract addresses anyone can inspect.
Then we kept going.
The tokens are not sitting in a folder pretending to be a roadmap. The verified PCC token now has a live vending contract on Polygon. The site reads the contract before it lets a wallet buy. The MDRN book NFTs are linked from the ecosystem instead of floating around like forgotten JPEGs in a basement with better lighting. The point is not to cosplay finance. The point is to make the machine visible.
You can touch the thing:
- Buy MDRN Network tokens at pcc.quest
- Browse the MDRN book NFT collection on OpenSea
- Browse the Pizza Connection artifact NFTs on OpenSea
- Verify the PCC vending contract on PolygonScan:
0xf1c994a4d6F4aFa3BAA1Eff1b1DcE26142E72e64
Most crypto talks like a whitepaper trying to pick up a date at a hotel bar. This is stranger and better: books, game characters, tokens, vending, metadata, public receipts, and a living site tying it together.
That matters.
Not because a token magically makes art valuable. It does not. The chain is a receipt, not a soul. But in the pop art sense, the site is the work too. The machine, the catalog, the tokens, the books, the characters, the vending interface, the fact that it all runs in public — that is the artifact. Warhol had soup cans. We have Polygon receipts and a vending machine that looks like it escaped an arcade with a finance degree.
The Receipts
The contracts are live and verifiable.
- Pizza Connection Artifact NFTs:
0x6774225402abEF5Aa34e80B8e7cbd99B61d8dd80 - MDRN Artifact NFTs:
0xFA106d55623bffB99d7469C1216B741fC9146633 - PCC Token:
0x592ae6258b1d8cC066375330Aa563B6681BBc5f1 - PCC Vending Contract:
0xf1c994a4d6F4aFa3BAA1Eff1b1DcE26142E72e64 - GHST Token:
0x81FAC24Af743F29Cd511b7f31D53b49b4f284E4e
The first public PCC vending contract was funded with 500,001 verified PCC. The current public setting is simple: 1 POL buys 1 PCC, minimum 1, maximum 50,000, while the vending contract is active.
That is the part I care about: simple enough to explain out loud, public enough to verify, small enough to test without pretending every click is the birth of a new civilization.
What AI Is Good For
The scaffolding is where AI compresses time dramatically.
Give Claude a clear spec — ERC-721, fixed supply, mint price, owner withdrawal, Polygon mainnet — and it produces a working Solidity contract fast. Not a toy. A real contract with inheritance, mint functions, supply caps, events, deployment scripts, and the boilerplate you would otherwise spend an afternoon copying from docs you half-understand.
The same is true for the deployment loop. Config file, RPC endpoint, gas settings, Polygonscan verification, failure messages, redeploy. When the deployment errors out because the endpoint is wrong or the compiler setting is off, you paste the error back in and it diagnoses the shape of the problem. That loop — write, deploy, fail, paste error, fix, redeploy — runs fast when the model is doing the interpretation work.
Metadata was the other clear win. ERC-721 metadata has a specific JSON shape OpenSea expects. Trait formatting, image URI patterns, naming conventions — AI can generate the boring structure correctly when the human gives it clean rules.
The metadata should look plain. Plain is good here.
{
"name": "Mistress Savannah",
"description": "A collectible digital edition connected to the Ghost in the Prompt catalog.",
"image": "https://ghostintheprompt.com/covers/Mistress_Savannah.jpg",
"external_url": "https://ghostintheprompt.com/books/mistress-savannah",
"attributes": [
{ "trait_type": "Collection", "value": "MDRN Artifacts" },
{ "trait_type": "Chain", "value": "Polygon" }
]
}
No fog machine. No "unlock the future of decentralized storytelling." Just name, image, page, traits. The magic works better when the wires are labeled.
The Vending Machine Is The Turn
Minting is one thing. Selling cleanly is another.
A wallet holding tokens is not a vending machine. That was the first adult lesson. If buyers are going to swap POL for PCC on a site, the site needs a contract that owns inventory, enforces price, emits events, and lets the owner withdraw collected POL later.
The core logic is not mystical. That is why it is useful.
function buyTokens(uint256 tokenAmount) external payable nonReentrant {
require(active, "Vending inactive");
require(tokenAmount >= minPurchase, "Below minimum");
require(tokenAmount <= maxPurchase, "Above maximum");
uint256 cost = (tokenAmount * pricePerToken) / 1e18;
require(msg.value >= cost, "Insufficient POL");
require(token.balanceOf(address(this)) >= tokenAmount, "Insufficient inventory");
require(token.transfer(msg.sender, tokenAmount), "Transfer failed");
uint256 refund = msg.value - cost;
if (refund > 0) {
(bool refundSuccess, ) = payable(msg.sender).call{value: refund}("");
require(refundSuccess, "POL refund failed");
}
emit TokensPurchased(msg.sender, tokenAmount, cost);
}
That is the whole poem in machine language:
Is the machine active? Is the amount allowed? Did the buyer send enough POL? Does the contract have inventory? Transfer the PCC. Refund any extra. Emit the receipt.
This is where crypto becomes less abstract. A person clicks a button. MetaMask asks for approval. Polygon records the transaction. The vending contract moves verified PCC. The site does not need to ask anyone to believe a story. The story is sitting on-chain with a transaction hash.
The Site Reads The Contract
The website is not allowed to hallucinate the sale terms. It reads them from the vending contract.
const [pricePerTokenWei, minPurchaseWei, maxPurchaseWei, active] =
await Promise.all([
contract.pricePerToken(),
contract.minPurchase(),
contract.maxPurchase(),
contract.active(),
]);
That sounds small. It is not.
The failed 1 MDRNDME test proved why it matters. The wallet path worked. Polygon worked. The contract rejected the amount because the live minimum was higher than the stale UI assumption. That was annoying for about five minutes, then useful forever. The contract is the source of truth. The interface should obey it.
This is the difference between "crypto site" as costume and crypto site as machinery.
Where It Would Have Burned Me
AI writes contracts with confidence whether or not the contract is secure.
The first draft can look correct and still hide problems. Reentrancy. Bad ownership assumptions. Unclear withdrawal paths. Stale OpenZeppelin imports. Mainnet gas settings copied from old testnet lore. The model will help you build the bridge and then cheerfully let you drive across it before anyone checked the bolts.
So you ask directly.
What are the vulnerabilities? Where does money enter? Where does money leave? Who can withdraw? What happens if the token transfer fails? What happens if a buyer sends too much? What happens if the vending contract runs out of inventory? What happens if the owner wallet is compromised?
AI will answer when questioned like a suspect. Do not treat it like a priest.
The other real concern is custody. Your deployment wallet owns the contract. If that wallet is compromised, the contract is compromised — withdrawal functions, ownership transfers, inventory recovery, all of it. AI has nothing magical to say about operational security. That is discipline, not promptcraft.
