GameDesignOS by Paranoia - AI-native game design operating system for evidence, experiments, proposals, and workflow governance

AI-native game design, concept validation, and prototyping system by Paranoia
游戏设计操作系统 / 游思考 GameDesignOS

GameDesignOS turns expert game-design methods, evidence, experiments, proposals, and human decisions into reusable skills, stable contracts, and workspace-backed operating procedures. It helps game projects move from idea to validation without losing context between agent calls, documents, and milestones.

简体中文 · English · Runtime Foundation · Workspace · Workflows · Roadmap · Skills · Cases · License

Skills Version Runtime Domain Agent Ready Method

License: skill documents and tooling are released under the MIT License. The Paranoia name, logos, visual identity, and project branding are not licensed as trademarks.

GameDesignOS is the public-facing system name. Paranoia is the author identity and brand signature; the current installable modules remain packaged as Markdown skills.

v0.8.0 adds the optional project layer that turns the existing skill packages into a workspace-backed operating system.

Start a private workspace:

cp -R runtime/workspace-template ../my-game-designos
cd ../my-game-designos

Then edit game.designos.yaml. Existing skill folders remain independently installable; the workspace layer is additive and backward compatible.

Read the product architecture, v0.8.0 MVP boundary, workflow routes, and roadmap.

Decision-first research prompt:

Use $paranoia-ai-system-evolver to audit this research or AI workflow with a Decision Object, current default action, decision boundary, EVPI/EVSI, signal-to-action map, the smallest high-VOI probe, and a stop rule.

GameDesignOS is an AI-native workflow system for game design, concept validation, and prototype planning. Its public base now consists of a Skill Kernel, Contract Layer, Project Workspace, and Runtime Interface.

The skills provide bounded expert behavior. Contracts make outputs interoperable. The workspace preserves project context. The runtime layer defines how a host agent or future CLI reads, routes, writes, validates, and stops at Human Gates.

It is not a scattered skill list or a prompt dump. It is closer to a compact operating system for serious game design work, with contracts that let skills hand work to each other instead of producing isolated prose:

media evidence -> evidence index -> issue cards -> ED handoff -> weekly experiments
one-line idea -> player-promise contract -> validation plan -> later media diagnosis
concept/evidence/production notes -> decision-ready proposal -> pitch or milestone gate
workflow change -> WOOP Task Card -> VOI/OODA probe -> eval -> Human Gate -> rollback
books and sources -> structured knowledge assets -> better references for future work

• Evidence-first: judgments point back to sources, screenshots, timestamps, sample evidence, or validation metrics.
• Contract-driven: concept briefs, evidence indexes, issue cards, ED handoffs, and validation plans can move across skills.
• Workspace-native: concepts, evidence, analysis, experiments, proposals, decisions, and retrospectives remain connected inside one project.
• Human-gated: agents can propose and structure work, but commitment-changing decisions are recorded by people.
• Decision-first information: before broad research, the system names the decision, current default action, decision boundary, signal-to-action map, information costs, and stop rule.
• Concept-to-validation: a promising idea becomes a seed, a player promise, a core loop, a scope gate, and a prototype test.
• Workflow-governed: useful behavior is written into SKILL.md, references/, templates/, evals, Human Gates, and rollback paths.
• Agent portable: Codex, Claude Code, OpenCode, or any Markdown-skill-capable agent can adapt the packages.
• Public/private safe: public examples stay synthetic, public, cleared, or marked needs_review; real projects stay in your own environment.

Use $game-experience-analyzer to diagnose this PV or gameplay recording into sample boundary, timestamped evidence, Hook/Loop/Link/Surprise diagnosis, issue cards, and validation recommendations.

Use $game-concept-architect to turn this one-line game idea into concept seed extraction, design nucleus options, player promise contract, core loop, scope gate, and prototype validation plan.

Use $game-design-proposal-writer to turn this concept brief, validation plan, evidence notes, and production constraints into a decision-ready commercial proposal, indie dossier, publisher pitch, or vertical-slice document.

Use $paranoia-ai-system-evolver to upgrade this workflow with a WOOP Task Card, VOI, OODA, eval checks, Human Gate, and rollback.

Use $game-experience-density-optimizer to turn this first-session retention, pacing, or experience density problem into an ED diagnosis, CLP/SF/EB/AR/MD-min levers, a weekly A/B plan, instrumentation, dashboard fields, decision rules, and rollback gates.

For the full onboarding path, see Try It in 10 Minutes. Star this repo if you want more public game-analysis examples and portable agent-skill templates; more stars help prioritize better public demos, adapters, and reusable skill templates.

Start with one screenshot, gameplay recording, trailer/PV, or video link. Ask the skill for an evidence-linked report:

60-second demo: Game Experience Analyzer turns PV input into an evidence-linked report

Use $game-experience-analyzer to analyze this gameplay recording into timestamped evidence, feature exposure/unlock/first-use ledger, Hook/Loop/Link/Surprise diagnosis, and actionable fixes.

For concrete proof paths, continue to the cases below. The demo above shows the fast interaction pattern; the cases show reviewable outputs and their evidence boundaries.

If you are browsing on GitHub, start with these two cases. The first shows a single gameplay recording turning into a Game Experience Analyzer report; the second shows how public video evidence flows into an Experience Density experiment package.

For ongoing work, start a project workspace so context persists. For a one-off task, you can still call a skill directly.

cp -R runtime/workspace-template ../my-game-designos
cd ../my-game-designos

Edit game.designos.yaml, keep private material outside this public repository, and use the workflow guides to decide which assets should be created next.

Call a skill directly in an agent environment that supports skill loading:

Use $game-experience-analyzer to analyze this gameplay recording into timestamped evidence, design lenses, heat potential, foresight windows, Go/No-Go, and validation recommendations.

Use $game-experience-analyzer to dissect this game into player verbs, action-goal alignment, uncertainty sources, system dynamics, content flow, audience desire, transfer boundaries, and validation recommendations.

Use $paranoia-ai-system-evolver to upgrade this prompt/workflow/schema with a WOOP Task Card, VOI, OODA, evals, Human Gate, and rollback.

Use $game-design-book-translator to translate and polish this game design chapter into professional Chinese, including terminology and figure captions.

Use $game-design-source-curator to review these game design sources and turn accepted items into a maintainable local knowledge base.

Use $game-concept-architect to turn this one-line game idea into a concept seed, player verbs, action-goal alignment, player promise, core loop, scope gate, production feasibility check, and prototype validation plan.

Use $game-design-proposal-writer to assemble this research, concept brief, evidence index, validation plan, and team constraints into a publisher pitch outline with proof of play, scope gate, budget assumptions, risks, and decision request.

Use $game-experience-density-optimizer to turn this first-session experience density problem into CLP/SF/EB/AR/MD-min diagnosis, rollbackable weekly variants, telemetry events, dashboard fields, and pre-registered decision rules.

If your tool supports local skills, copy the target folder into that tool's skill directory:

game-experience-analyzer/
paranoia-ai-system-evolver/
game-design-book-translator/
game-design-source-curator/
game-concept-architect/
game-experience-density-optimizer/
game-design-proposal-writer/

After installation, check that the SKILL.md frontmatter name matches the folder name, and that relative links inside references/, templates/, and examples/ still resolve.

Seven visible entry points cover the full GameDesignOS path: concept, evidence, proposal, experience-density iteration, workflow governance, and durable knowledge assets.

For the compact proof-path list, see the showcase index.

GameDesignOS v0.8.0 is organized as four product layers plus cross-cutting governance:

• Skill Kernel
  • game-concept-architect/: one-line idea -> verifiable design blueprint.
  • game-experience-analyzer/: media/sample -> evidence-linked diagnosis.
  • game-experience-density-optimizer/: bounded experience problem -> weekly experiment.
  • game-design-proposal-writer/: concept/evidence/constraints -> decision-ready proposal.
  • paranoia-ai-system-evolver/: workflow/schema/eval change -> controlled evolution.
  • game-design-book-translator/: design texts -> professional Chinese design writing.
  • game-design-source-curator/: scattered sources -> durable knowledge base.
• Contract Layer
  • contracts/: routing, skill handoffs, project manifests, asset indexes, and decision logs.
• Project Workspace
  • runtime/workspace-template/: project identity, lifecycle directories, asset registry, and Human Gates.
• Runtime Interface
  • runtime/ and adapters/: workspace lifecycle, host integration, and planned CLI contracts.
• Governance
  • evidence boundaries, public/private separation, evals, Human Gates, and rollback apply across every layer.

Private overlays, real project data, client examples, credentials, and local studio rules should live outside this public repository. Users may still run any skill directly without adopting a workspace.

• Competitor experience review: turn a gameplay recording into a timeline, feature ledger, loop diagnosis, issue priority, and concrete fixes.
• Game dissection and mechanic transfer: break a sample into player verbs, goal layers, uncertainty, system dynamics, content flow, audience desire, playable theme, and transfer boundaries.
• Trailer heat prediction: evaluate first seconds, one-line value proposition, proof of play, channel fit, conversion path, and validation plan.
• Foresight opportunity: judge whether a genre, theme, or mechanic still has a window; casual/light defaults to 1-3 months, micro/midcore-heavy defaults to 3-6 months.
• Source curation: turn articles, videos, creators, columns, and websites into searchable, citable, experiment-ready design knowledge.
• Professional translation: translate game design books or essays while preserving terminology, argument structure, and figure context.
• Workflow evolution: promote useful agent behavior into candidate rules with evals, Human Gate, and rollback.
• Cross-skill handoff: move from concept promise to media diagnosis to ED experiment through shared contracts instead of rewriting context by hand.
• Concept feasibility: turn a one-line idea into concept seed extraction, player verbs, action-goal alignment, player promises, core loop design, scope gate, production feasibility, and prototype validation.
• Proposal assembly: turn validated concepts, source notes, evidence, risks, and production constraints into reviewable commercial proposals, indie dossiers, pitch outlines, or vertical-slice documents.
• Experience density experiments: turn first-session, pacing, feedback, embodiment, atmosphere, or cognitive-load issues into weekly ED experiments with metrics and rollback gates.

Read the repository as a GameDesignOS public base rather than a normal asset folder.

Most skills follow this structure:

SKILL.md -> agent entrypoint, triggers, workflow, boundaries
references/ -> methods, scoring rules, routers, gates, validation playbooks
templates/ -> reusable forms and output structures
examples/ -> reviewable example outputs
agents/ -> metadata for agent environments that support it
evals/ -> regression prompts and expected behavior

GameDesignOS supports two compatible modes.

Copy the workspace template outside this public repository, edit game.designos.yaml, and use the workflow guides to route work and save durable project assets.

cp -R runtime/workspace-template ../my-game-designos

1. Copy or sync a skill folder into your agent skill directory.
2. Confirm the SKILL.md frontmatter name matches the folder name.
3. Trigger the skill by $skill-name or natural language.
4. Validate JSON/YAML, reference paths, and examples according to the skill README or SKILL.md.

The workspace layer does not prevent direct skill use.

Run these commands from the repository root:

python scripts/validate_repo.py
python scripts/validate_skill.py game-experience-analyzer
python scripts/validate_skill.py game-concept-architect
python scripts/validate_skill.py game-experience-density-optimizer
python scripts/validate_skill.py game-design-proposal-writer

• v0.8.0 — Runtime Foundation: workspace template, workspace contracts, product architecture, workflow routes, and validation.
• v0.9.0 — Local Runtime Prototype: initialize, inspect, route, create, validate, and pack local workspaces.
• v1.0.0 — Project-Ready GameDesignOS: asset graph, Human Gate queue, project dashboard, private overlays, and end-to-end cases.

See the capability-gated product roadmap.

Skill documents and tooling in this repository are released under the MIT License.

The Paranoia name, logos, visual identity, and project branding are not licensed as trademarks. Examples may have their own source_status, case_type, or source metadata; check each example's frontmatter before reuse.

Each skill is an independently installable package. Keep SKILL.md as the runtime entrypoint, put durable methods in references/, reusable forms in templates/, examples in examples/, and regression checks in evals/.

Public examples, evals, assets, showcases, and release notes must use synthetic, public, or explicitly cleared material. See CONTRIBUTING.md before submitting repository-facing content.

Evidence before opinion.
Feasibility before scope.
Workflow before one-off prompts.
VOI before research.
Eval before promotion.
Rollback before confidence.

Depending on feedback and maturity, future additions may include AI + indie game production packages such as:

• indie-game-production-master: full-cycle indie production from idea validation, GDD/Gates, prototyping, playtesting, AI asset pipelines, Steam/release strategy, and postmortem writeback.
• godot-ai-game-production: Godot + AI production covering project scaffolding, design truth, data contracts, asset pipelines, headless/keyshot validation, Demo/Release Gates, and engineering retrospectives.