# Hackathon

> 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.

- Skill: `jiayaoqijia/hackathon` (Agent Skill, multi-file: 4 files)
- Install (CLI): `npx skillmds@latest add jiayaoqijia/hackathon`
- Raw SKILL.md: https://api.skillmd.com/api/skills/jiayaoqijia/hackathon/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: jiayaoqijia (https://skillmd.com/u/jiayaoqijia)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/jiayaoqijia/hackathon

---


# 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)

2. **Project name?** (default: generate one based on theme)

3. **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

| Method | Path | Description |
|--------|------|-------------|
{Table of all endpoints the server exposes}

## What's Next

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

## Team

| Name | Role | GitHub |
|------|------|--------|
| {Name} | {Role} | @{handle} |

---

Built with [ChainGPT](https://www.chaingpt.org) AI APIs

Apply for the [$1M Web3 AI Grant Program](https://www.chaingpt.org/web3-ai-grant) — 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.