DEV Community: Traft

I Built a Full Game Studio Inside OpenCode — 48 AI Agents, 100% Free

Traft — Thu, 26 Mar 2026 20:54:02 +0000

TL;DR: I made a config pack that turns OpenCode into a structured game development studio with 48 specialized agents and 37 workflow skills — all running on Big Pickle (free). Drop it in your ~/.config/opencode/ and your next game gets a full team.

The Problem With AI-Assisted Game Dev

Solo game dev with AI is genuinely powerful. But there's a fundamental issue nobody talks about: a single AI session has no structure.

Nothing stops you from hardcoding magic numbers at 2am. Nobody's checking whether your inventory system actually fits the game's vision. There's no QA pass, no architecture review, no one asking "wait, does this mechanic even make sense?"

You end up with a chat assistant, not a team.

What I Built

OpenCode Game Studios is a drop-in configuration for OpenCode that transforms it into a proper studio hierarchy:

Tier 1 — Directors (Strategic)
  creative-director · technical-director · producer

Tier 2 — Department Leads
  game-designer · lead-programmer · art-director
  audio-director · narrative-director · qa-lead · release-manager

Tier 3 — Specialists (22 agents)
  gameplay-programmer · engine-programmer · ai-programmer
  level-designer · systems-designer · sound-designer · writer
  performance-analyst · qa-tester · accessibility-specialist ...

Plus dedicated engine specialists for Godot, Unity, and Unreal — 5 agents per engine covering shaders, scripting, DOTS, GAS, blueprints, replication, UI systems.

48 agents total.

How It Works

Every agent knows its role in the studio. The creative-director guards the vision. The lead-programmer owns architecture decisions. The qa-tester finds edge cases. You call whoever you need:

@game-designer "Design a combat system for my roguelike"
@lead-programmer "Review this ECS architecture"
@godot-shader-specialist "Write a 2D water shader with refraction"
@qa-tester "What are the edge cases in this save system?"

And there are 37 workflow skills via slash commands:

/start           — Kick off a new game project with proper setup
/sprint-plan     — Plan your week with task breakdown
/code-review     — Full architectural review
/balance-check   — Game economy and difficulty audit
/brainstorm      — Structured creative session
/release-checklist — Pre-launch verification
/patch-notes     — Auto-generate from your git history

The Collaboration Protocol

Every task follows a mandatory flow: Question → Options → Decision → Draft → Approval

Agents must ask "May I write this to [filepath]?" before touching your code. They show drafts before requesting approval. Multi-file changes need explicit sign-off for the entire changeset.

You make all final decisions. The agents provide expertise, not autonomy. This single constraint has made the difference between sessions that produce focused output and sessions that spin forever.

100% Free

Everything runs on OpenCode's Big Pickle model. No API keys, no tokens burning, no credit card. The config defaults every agent to opencode/big-pickle. You can override specific agents to premium models if you want, but the whole setup works out of the box for free.

Getting Started

# Install OpenCode
npm install -g opencode

# Clone the studio config
git clone https://github.com/TraftG/opencode-game-studio
cd opencode-game-studio

# Apply globally
cp -r .opencode/* ~/.config/opencode/

# Start your studio
opencode

That's it. Open a session, type @creative-director and describe your game idea. Watch it ask you the right questions instead of just vibing.

Why I Made This

I kept running into the same wall: the AI was capable, but sessions had no memory of earlier decisions and no consistent "voice" keeping the project coherent. A creative director who remembers that this is a horror game, not an action game. A QA lead who always checks for save corruption. A technical director who enforces the performance budget you set on day one.

Structured agents with clear roles solved this better than any amount of prompt tweaking.

What's Next

I'm actively using this on my own projects. If you build something with it or have ideas for new agents/skills, PRs are very welcome.

⭐ github.com/TraftG/opencode-game-studio

Built by @TraftG — reach out on Telegram if you have questions about the setup.

VK Music Bot API: Open Source Backend for VK Music in Telegram

Traft — Mon, 05 Jan 2026 20:29:50 +0000

Hi! I’m Traft, and I want to share my new open-source project — VK Music Bot API.

The goal of this project is simple: provide a clean backend to access VK music inside Telegram Mini Apps or bots, without mixing UI, bot logic, and VK API calls.

Repository: TraftG/vk-music-bot-api

Why I Built It

Many people want to play VK music without opening the app or browser.
Most bots and scripts out there are fragile, hard to maintain, or mix everything in one place.

I wanted a solution that is:

scalable

production-ready

easy to integrate into Telegram

clean and maintainable

Features

VK Music Bot API currently supports:

Track search — by title, artist, or album, with metadata and cover images

MP3 download — direct from VK, supports FFmpeg processing

History tracking — store listened tracks and build personal recommendations

Secure auth — via Telegram WebApp InitData, no passwords needed

Recommendations — basic algorithms based on listening history

Tech Stack

Backend: FastAPI, Uvicorn, Pydantic, Motor (MongoDB async driver)

Integrations: VKPyMusic, Aiogram, yt-dlp, FFmpeg

Database: MongoDB (NoSQL)

Async: Entire project uses async/await for high throughput

Project Structure

music-bot/
├── app/
│   ├── core/       # config & DB connection
│   ├── models/     # Pydantic schemas
│   ├── routers/    # API endpoints
│   ├── services/   # business logic
│   └── main.py     # FastAPI entry point
├── .env.example
└── requirements.txt

Separation of concerns makes the project:

easier to maintain

easy to scale

easier to test

readable for new contributors

API Endpoints

Authentication:

POST /api/auth/login       # via Telegram InitData
POST /api/auth/history     # add track to history

Music:


GET /api/music/search?q=query        # search tracks
GET /api/music/download/{track_id}  # download MP3
GET /api/music/recommendations      # get recommendations

Docs:

Swagger: /docs

ReDoc: /redoc

Quick Start

git clone https://github.com/TraftG/vk-music-bot-api.git
cd vk-music-bot-api
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
cp .env.example .env
docker run -d -p 27017:27017 mongo
uvicorn app.main:app --reload

API will be available at http://localhost:8000.

Why Async and asynccontextmanager

The whole project is async using async/await and @asynccontextmanager for lifecycle management:

@asynccontextmanager
async def lifespan(app: FastAPI):
    await connect_to_mongo()
    yield
    await close_mongo_connection()

app = FastAPI(lifespan=lifespan)

This pattern is clean, modern, and allows:

safe startup/shutdown of resources

high throughput

testable, maintainable code

Performance

Track search: < 500 ms

Recommendations: < 200 ms

Authorization: < 100 ms

Scales horizontally with multiple workers:

uvicorn app.main:app --workers 4

Deployment

Docker-ready:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

Runs on:

VPS, Docker, Kubernetes

Railway / Render / Heroku

AWS, GCP

Open Source Contribution

MIT-licensed. Feel free to:

fix bugs

add new features

improve documentation

add tests

Process: fork → feature branch → PR.

Conclusion

VK Music Bot API is a production-ready backend for VK music, easy to integrate into Telegram apps or bots.

Quick start in 5 minutes

Clean and async architecture

Fully Open Source
Github Link ⭐