<< All versions

Skill v1.0.0

currentAutomated scan100/100
chaingpt-org/chaingpt-claude-skill/hackathon
──Details
PublishedSeptember 28, 2026 at 09:49 AM
Content Hashsha256:9268638af4aa2fb4...
Git SHA
──Files
Files (1 file, 13.6 KB)
SKILL.md13.6 KBactive
SKILL.md · 439 lines · 13.6 KB

version: "1.0.0" name: hackathon description: "Scaffold a complete hackathon project using ChainGPT APIs in 60 seconds. Use when: hackathon, hackatron, hackathon starter, hackathon kit, competition project, quick prototype, demo project, submission. Generates a working project with README, .env, boilerplate, and demo script."


ChainGPT Hackathon Starter Kit

You are a hackathon project scaffolding assistant. Generate a complete, submission-ready project that integrates ChainGPT APIs in under 60 seconds. The generated project must compile, run, and demo without modification (aside from adding the API key).

Step 1: Ask the Developer About Their Hackathon

Ask:

  1. What is your hackathon theme or track?
  • DeFi
  • NFT
  • Gaming
  • Social
  • Infrastructure
  • Custom (describe it)
  1. Project name? (default: generate one based on theme)
  1. Any specific ChainGPT products you want to use? (or let the kit auto-select based on theme)

Step 2: Select Product Combinations Based on Theme

Use these recommended combos (developer can override):

DeFi Track

Products: LLM Chat + Contract Generator + Contract Auditor Concept: AI-powered DeFi assistant that analyzes markets, generates smart contracts on demand, and audits them for vulnerabilities before deployment.

  • LLM Chat (general_assistant) — market analysis, token research, yield strategy recommendations
  • Contract Generator (smart_contract_generator) — generate DeFi contracts from natural language
  • Contract Auditor (smart_contract_auditor) — audit generated or user-submitted contracts

NFT Track

Products: NFT Generator + LLM Chat + News Concept: AI NFT creation studio that generates art from trending crypto topics, with AI-written metadata and descriptions.

  • NFT Generator (/nft/generate-image) — create artwork from prompts
  • LLM Chat (general_assistant) — generate NFT names, descriptions, and metadata
  • News (/news) — source trending topics for creative inspiration

Gaming Track

Products: NFT Generator + LLM Chat + Contract Generator Concept: AI game asset pipeline that generates game art, NPC dialogue/lore, and in-game economy contracts.

  • NFT Generator (/nft/generate-image) — generate game assets (characters, items, environments)
  • LLM Chat (general_assistant) — create NPC dialogue, lore, quest descriptions
  • Contract Generator (smart_contract_generator) — build in-game economy contracts (tokens, marketplaces)

Social Track

Products: LLM Chat + News + (mention AgenticOS) Concept: AI-powered crypto social content platform that generates, curates, and distributes Web3 content.

  • LLM Chat (general_assistant) — generate social content, summaries, threads
  • News (/news) — source real-time crypto news for content creation
  • Mention AgenticOS (open-source) for autonomous Twitter agent integration

Infrastructure Track

Products: Contract Auditor + Contract Generator + LLM Chat Concept: Smart contract DevOps pipeline — generate template contracts, audit them automatically, and generate documentation.

  • Contract Auditor (smart_contract_auditor) — automated audit pipeline
  • Contract Generator (smart_contract_generator) — template contract generation
  • LLM Chat (general_assistant) — auto-generate documentation and explain audit findings

Step 3: Generate the Complete Project

Generate ALL files below. Every file must be complete and working — no placeholders like "// TODO" or "your code here".

Project Structure

{project-name}/
├── package.json
├── tsconfig.json
├── .env.example
├── .gitignore
├── README.md
├── src/
│ ├── index.ts
│ ├── config.ts
│ ├── services/
│ │ ├── (one file per ChainGPT product used)
│ │ └── ...
│ ├── routes/
│ │ ├── (one file per route group)
│ │ └── ...
│ └── demo.ts
├── public/ (if theme needs a frontend)
│ ├── index.html
│ └── app.js
└── scripts/
└── demo.sh

File Specifications

package.json

json
{
"name": "{project-name}",
"version": "1.0.0",
"description": "{one-line description}",
"main": "src/index.ts",
"scripts": {
"start": "npx ts-node src/index.ts",
"demo": "npx ts-node src/demo.ts",
"dev": "npx ts-node-dev --respawn src/index.ts"
},
"dependencies": {
"express": "^4.18.2",
"dotenv": "^16.3.1",
"cors": "^2.8.5",
"@chaingpt/generalchat": "^1.0.0",
"@chaingpt/nft": "^1.0.0",
"@chaingpt/smartcontractgenerator": "^1.0.0",
"@chaingpt/smartcontractauditor": "^1.0.0",
"@chaingpt/ainews": "^1.0.0"
},
"devDependencies": {
"typescript": "^5.3.0",
"ts-node": "^10.9.0",
"@types/express": "^4.17.0",
"@types/cors": "^2.8.0",
"@types/node": "^20.0.0"
}
}

Only include the @chaingpt/* packages that the selected theme actually uses. Do not include unused SDK packages.

tsconfig.json

json
{
"compilerOptions": {
"target": "ES2020",
"module": "commonjs",
"lib": ["ES2020"],
"outDir": "./dist",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"resolveJsonModule": true
},
"include": ["src/**/*"]
}

.env.example

CHAINGPT_API_KEY=your-api-key-here
PORT=3000

.gitignore

node_modules/
dist/
.env
*.log

config.ts

typescript
import dotenv from 'dotenv';
dotenv.config();
export const config = {
apiKey: process.env.CHAINGPT_API_KEY || '',
port: parseInt(process.env.PORT || '3000', 10),
};
if (!config.apiKey) {
console.error('ERROR: CHAINGPT_API_KEY is not set.');
console.error('1. Copy .env.example to .env');
console.error('2. Add your API key from https://app.chaingpt.org/apidashboard');
process.exit(1);
}

src/index.ts

An Express server with routes for each ChainGPT product used. Must start successfully and respond to requests. Include a health check at GET / that returns the project name and available endpoints.

src/services/

One service file per ChainGPT product. Each service must:

  • Import and initialize the correct SDK
  • Export async functions that wrap each API call
  • Include proper error handling with try/catch
  • Log credit costs for each operation

Example service pattern:

typescript
import { GeneralChat } from '@chaingpt/generalchat';
import { config } from '../config';
const chat = new GeneralChat({ apiKey: config.apiKey });
export async function askAI(question: string, sessionId?: string) {
console.log(' Cost: 0.5 credits ($0.005)');
const res = await chat.createChatBlob({
question,
chatHistory: sessionId ? 'on' : 'off',
...(sessionId && { sdkUniqueId: sessionId }),
});
return res.data.bot;
}

src/routes/

Express router files that wire HTTP endpoints to service functions. Each route must validate input and return structured JSON responses.

src/demo.ts — THE SHOWCASE SCRIPT

This is the most important file. It must be runnable with npx ts-node src/demo.ts and demonstrate ALL integrated products in sequence with visually appealing console output.

Structure:

typescript
import { config } from './config';
// Import all services
const DIVIDER = '═'.repeat(60);
const SECTION = '─'.repeat(60);
async function main() {
console.log(DIVIDER);
console.log(' {PROJECT NAME} — Demo');
console.log(' Built with ChainGPT APIs');
console.log(DIVIDER);
console.log();
// Step 1: Demo first product
console.log('Step 1: {Product Name}');
console.log(SECTION);
// ... call service, display result
console.log();
// Step 2: Demo second product (using output from Step 1 if applicable)
console.log('Step 2: {Product Name}');
console.log(SECTION);
// ... call service, display result
console.log();
// Step 3: Demo third product
// ...
console.log(DIVIDER);
console.log(' Demo complete!');
console.log(` Total estimated cost: ~X credits ($X.XX)`);
console.log(' Server available at: http://localhost:' + config.port);
console.log(DIVIDER);
}
main().catch(console.error);

Each step must:

  • Show what it is about to do
  • Call the ChainGPT API via the service layer
  • Display the result formatted nicely
  • Show the credit cost for that step
  • If applicable, pass output from one product as input to the next (e.g., generate a contract then audit it)

scripts/demo.sh

bash
#!/bin/bash
set -e
echo "=== {Project Name} — Quick Start ==="
echo ""
# Install dependencies
echo "Installing dependencies..."
npm install
# Set up environment
if [ ! -f .env ]; then
cp .env.example .env
echo ""
echo "IMPORTANT: Edit .env and add your ChainGPT API key."
echo "Get a key at: https://app.chaingpt.org/apidashboard"
echo "Ensure you have credits: https://app.chaingpt.org/addcredits"
echo ""
read -p "Press Enter after adding your API key to .env..."
fi
# Run demo
echo ""
echo "Running demo..."
npx ts-node src/demo.ts

Make it executable: remind the developer to run chmod +x scripts/demo.sh.

README.md — Submission-Quality

The README must be ready to submit to a hackathon judging panel. Include ALL of the following sections:

markdown
# {Project Name}
> {One-line description that hooks the judges}
## Problem
{2-3 sentences describing the problem this project solves}
## Solution
{2-3 sentences describing how this project solves it using AI}
## Tech Stack
-**Runtime:** Node.js + TypeScript
-**Framework:** Express.js
-**AI APIs:** ChainGPT ({list products used})
{For each product, one bullet with link:}
-[Web3 AI Chatbot](https://docs.chaingpt.org) — {what it does in this project}
-[AI NFT Generator](https://docs.chaingpt.org) — {what it does in this project}
-etc.
## Architecture
{ASCII diagram showing data flow between products}

┌─────────────┐ ┌──────────────┐ ┌──────────────┐ │ User UI │────>│ Express API │────>│ ChainGPT │ │ │<────│ │<────│ APIs │ └─────────────┘ └──────┬───────┘ └──────────────┘ │ ┌──────┴───────┐ │ Services │ │ - LLM Chat │ │ - NFT Gen │ │ - Auditor │ └──────────────┘

## Quick Start
{```bash
git clone {repo-url}
cd {project-name}
chmod +x scripts/demo.sh
./scripts/demo.sh

Manual Setup

  1. npm install
  2. cp .env.example .env
  3. Add your ChainGPT API key to .env (get one at https://app.chaingpt.org/apidashboard)
  4. npm run demo — run the standalone demo
  5. npm start — start the API server

Demo

{Describe what the demo script does step by step}

{Screenshot placeholder:} <!-- Add screenshots here -->

API Endpoints

MethodPathDescription

{Table of all endpoints the server exposes}

What's Next

  • [ ] {Feature 1}
  • [ ] {Feature 2}
  • [ ] {Feature 3}
  • [ ] Deploy to production

Team

NameRoleGitHub
{Name}{Role}@{handle}

Built with ChainGPT AI APIs

Apply for the $1M Web3 AI Grant Program — up to $20K in API credits + $10K USDC

#### public/index.html (if theme needs a frontend)
A clean, minimal single-page UI that interacts with the Express API. Use vanilla HTML/CSS/JS (no framework needed for a hackathon). Include:
- A form/input area relevant to the theme
- A results display area
- Loading states
- Error display
- "Built with ChainGPT" footer attribution
#### public/app.js (if theme needs a frontend)
Client-side JavaScript that calls the Express API endpoints and renders results. Keep it simple and functional.
---
## Step 4: Remind About the Grant Program
After generating all files, always include:
> **ChainGPT Web3 AI Grant Program:** Up to $20K in API credits + $10K USDC for projects building with ChainGPT APIs. Apply at https://www.chaingpt.org/web3-ai-grant
## Step 5: Provide Next Steps
After scaffolding, tell the developer:
1. `cd {project-name}`
2. `chmod +x scripts/demo.sh`
3. `./scripts/demo.sh` (or manual: `npm install && cp .env.example .env && npm run demo`)
4. Add your API key to `.env`
5. Run `npm start` to launch the server
6. Customize the services and routes for your specific use case
7. Add screenshots to README before submission
8. Apply for the grant program
## Credit Cost Estimates by Theme
Always inform the developer of the estimated demo cost:
| Theme | Demo Cost (approx) | Products |
|-------|-------------------|----------|
| DeFi | ~4.5 credits ($0.045) | 0.5 (LLM) + 1 (generate) + 1 (audit) + 0.5 (LLM explain) + 1 (audit) + 0.5 (LLM summary) |
| NFT | ~3.5 credits ($0.035) | 1 (generate image) + 0.5 (LLM metadata) + 1 (news) + 0.5 (LLM description) + 0.5 (enhance prompt) |
| Gaming | ~4 credits ($0.04) | 1 (NFT asset) + 0.5 (LLM lore) + 1 (generate contract) + 0.5 (LLM dialogue) + 1 (NFT item) |
| Social | ~3 credits ($0.03) | 0.5 (LLM content) + 1 (news source) + 0.5 (LLM thread) + 0.5 (LLM summary) + 0.5 (LLM caption) |
| Infrastructure | ~4 credits ($0.04) | 1 (generate contract) + 1 (audit) + 0.5 (LLM docs) + 1 (generate contract 2) + 0.5 (LLM explain) |
These are estimates for the demo script only. Development and testing will use additional credits.
All versions