Game design document creation from concept

Introduction

Creating a game design document (GDD) from a raw concept is one of those tasks that should be quick but almost never is. You start with an exciting idea, a handful of notes, maybe some rough sketches. Then you spend hours structuring those thoughts, organising narrative beats, defining mechanics, and generating visual references. By the time you've written the third draft, you've lost momentum and introduced inconsistencies.

What if instead of doing this manually, you could feed your concept into a chain of AI tools that analyses it, structures it, generates diagrams, and produces a polished GDD in minutes? That's exactly what this Alchemy workflow does. It takes your initial game concept and passes it through Bhava AI for narrative analysis, Diagram for visual architecture generation, and Ludo AI for mechanical design, orchestrating everything so the output of one tool becomes the precise input for the next.

This intermediate-level workflow demonstrates why tool combination matters more than individual tool capability. None of these tools alone produces a complete GDD; together, they eliminate manual handoff work and create something none could produce independently.

The Automated Workflow

We'll build this using n8n, which offers the best balance of flexibility and ease of setup for this particular workflow. The workflow runs in six stages: concept ingestion, narrative analysis, mechanical design, visual generation, document assembly, and export.

Architecture Overview

The flow looks like this:

1. User submits game concept (text prompt)
2. Bhava AI analyses the narrative and thematic elements
3. Ludo AI receives the concept and generates game mechanics
4. Diagram generates flowcharts and system diagrams from both outputs
5. Claude Code assembles everything into structured markdown
6. Output is saved to a file or sent to user

The orchestration happens in n8n. Data flows as structured JSON throughout, so each tool knows exactly what it's receiving and what to pass forward.

Step 1:

Setting Up the Webhook Trigger in n8n

Your workflow starts with a webhook that accepts the game concept. This is what you'll POST to with your initial idea.

Copy
POST https://your-n8n-instance.com/webhook/game-concept
Content-Type: application/json

{
  "concept": "A roguelike deck-builder set in a corrupted library where players steal books to regain lost memories",
  "tone": "dark fantasy",
  "target_audience": "adult gamers",
  "core_mechanic": "deck building with memory management"
}

In n8n, create a Webhook node with these settings:

• Authentication: None (or add API key if you want)
• HTTP method: POST
• Response mode: Last node output

This node passes the incoming JSON directly to the next step without transformation. The beauty of this approach is your webhook accepts anything; the subsequent tools handle validation.

Step 2:

Bhava AI for Narrative Analysis

Bhava AI specialises in story structure and thematic analysis. You'll use its API to analyse the narrative potential of your concept.

First, set up an HTTP Request node in n8n to call Bhava AI:

Copy
POST https://api.bhava.ai/v1/analyse-narrative
Headers:
  Authorization: Bearer YOUR_BHAVA_API_KEY
  Content-Type: application/json

Body:
{
  "concept": "{{ $json.concept }}",
  "tone": "{{ $json.tone }}",
  "analysis_type": "full_structure",
  "output_format": "json"
}

Bhava AI returns a structured response with narrative beats, character archetypes, thematic pillars, and story structure. Store this output in a variable called narrative_analysis.

Example response structure:

Copy{
  "narrative_beats": [
    {
      "act": 1,
      "beat": "Introduction to the corrupted library",
      "emotional_arc": "curiosity to dread"
    }
  ],
  "themes": ["memory", "corruption", "redemption"],
  "character_archetypes": ["The Seeker", "The Guardian"],
  "story_structure": "three_act"
}

Keep this response; you'll reference it in later steps.

Step 3:

Ludo AI for Mechanical Design

Whilst Bhava AI handles narrative, Ludo AI focuses on game mechanics. Create another HTTP Request node:

Copy
POST https://api.ludo.ai/v1/design-mechanics
Headers:
  Authorization: Bearer YOUR_LUDO_API_KEY
  Content-Type: application/json

Body:
{
  "concept": "{{ $json.concept }}",
  "core_mechanic": "{{ $json.core_mechanic }}",
  "themes": "{{ $json.narrative_analysis.themes.join(',') }}",
  "target_audience": "{{ $json.target_audience }}",
  "output_format": "json"
}

Ludo AI returns mechanics, progression systems, balance frameworks, and win conditions:

Copy{
  "core_loop": "steal book -> decode memories -> unlock ability -> approach boss",
  "mechanics": [
    {
      "name": "deck_building",
      "description": "Players construct a deck from acquired spell cards"
    },
    {
      "name": "memory_system",
      "description": "Each book stolen restores a memory fragment, unlocking narrative"
    }
  ],
  "progression": "non-linear, memory-gated",
  "difficulty_scaling": "adaptive based on deck power"
}

Store this as mechanical_design.

Step 4:

Diagram for Visual Architecture

Now you've got narrative and mechanics. Diagram takes both and generates visual representations. Use another HTTP Request node:

Copy
POST https://api.diagram.ai/v1/generate-diagrams
Headers:
  Authorization: Bearer YOUR_DIAGRAM_API_KEY
  Content-Type: application/json

Body:
{
  "narrative_structure": {{ $json.narrative_analysis }},
  "game_mechanics": {{ $json.mechanical_design }},
  "diagram_types": ["flowchart", "state_diagram", "progression_tree"],
  "style": "dark",
  "output_format": "svg_and_json"
}

Diagram returns SVG files (embedded as data URIs) and JSON descriptions of each diagram:

Copy{
  "diagrams": [
    {
      "type": "flowchart",
      "name": "game_loop",
      "svg": "data:image/svg+xml;base64,...",
      "description": "Core gameplay loop showing deck building into exploration cycle"
    },
    {
      "type": "progression_tree",
      "name": "memory_unlock_tree",
      "svg": "data:image/svg+xml;base64,...",
      "description": "How stolen books unlock narrative branches"
    }
  ]
}

Store this as visual_assets.

Step 5:

Claude Code for Document Assembly

Now comes the assembly phase. You'll use Claude Code (either via the Claude API with code interpretation, or the n8n Claude node) to take all three outputs and produce a properly formatted, structured game design document.

Create an n8n node that calls Claude:

Copy
POST https://api.anthropic.com/v1/messages
Headers:
  x-api-key: YOUR_CLAUDE_API_KEY
  Content-Type: application/json

Body:
{
  "model": "claude-3-5-sonnet-20241022",
  "max_tokens": 4000,
  "messages": [
    {
      "role": "user",
      "content": "You are a professional game designer. Assemble a complete game design document using the following data. Format it as markdown with proper structure. Include executive summary, narrative section, mechanics section, progression documentation, and system diagrams.\n\nNarrative Analysis:\n{{ $json.narrative_analysis }}\n\nMechanical Design:\n{{ $json.mechanical_design }}\n\nVisual Assets:\n{{ $json.visual_assets }}\n\nProduce a GDD that is approximately 2000 words, well-structured, and ready for a development team."
    }
  ]
}

Claude processes all three outputs and produces a cohesive, professionally structured GDD in markdown. The response contains the full document text.

Step 6:

Export and Storage

Finally, save the output. Add a File Write node in n8n:

Copy
File Path: game_design_documents/{{ $json.concept.replace(/\s+/g, '_') }}_gdd_{{ $now.toFormat('yyyy-MM-dd-HHmmss') }}.md

Content: {{ $json.claude_response.content[0].text }}

Optionally, send this to Slack or email:

Copy
POST https://hooks.slack.com/services/YOUR/WEBHOOK/URL

Body:
{
  "text": "Game design document generated",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Concept:* {{ $json.concept }}\n*Status:* Complete\n*File:* game_gdd_{{ $now.format('yyyy-MM-dd') }}.md"
      }
    }
  ]
}

Full n8n Workflow JSON

Here's a simplified version of the complete workflow configuration:

Copy{
  "nodes": [
    {
      "parameters": {
        "path": "game-concept",
        "httpMethod": "POST"
      },
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "position": [250, 300]
    },
    {
      "parameters": {
        "url": "https://api.bhava.ai/v1/analyse-narrative",
        "authentication": "bearerToken",
        "nodeCredentialType": "httpBearer",
        "sendBody": true,
        "bodyParametersUi": "json",
        "body": "{\n  \"concept\": \"{{ $json.concept }}\",\n  \"tone\": \"{{ $json.tone }}\",\n  \"analysis_type\": \"full_structure\"\n}"
      },
      "name": "Bhava AI Narrative",
      "type": "n8n-nodes-base.httpRequest",
      "position": [450, 200]
    },
    {
      "parameters": {
        "url": "https://api.ludo.ai/v1/design-mechanics",
        "authentication": "bearerToken",
        "nodeCredentialType": "httpBearer",
        "sendBody": true,
        "bodyParametersUi": "json",
        "body": "{\n  \"concept\": \"{{ $json.concept }}\",\n  \"themes\": \"{{ $json.narrative_analysis.themes }}\"\n}"
      },
      "name": "Ludo AI Mechanics",
      "type": "n8n-nodes-base.httpRequest",
      "position": [450, 400]
    },
    {
      "parameters": {
        "url": "https://api.diagram.ai/v1/generate-diagrams",
        "authentication": "bearerToken",
        "nodeCredentialType": "httpBearer",
        "sendBody": true,
        "bodyParametersUi": "json",
        "body": "{\n  \"narrative_structure\": {{ $json.narrative_analysis }},\n  \"game_mechanics\": {{ $json.mechanical_design }}\n}"
      },
      "name": "Diagram Generation",
      "type": "n8n-nodes-base.httpRequest",
      "position": [650, 300]
    },
    {
      "parameters": {
        "url": "https://api.anthropic.com/v1/messages",
        "authentication": "bearerToken",
        "nodeCredentialType": "httpBearer",
        "sendBody": true,
        "bodyParametersUi": "json",
        "body": "{\n  \"model\": \"claude-3-5-sonnet-20241022\",\n  \"max_tokens\": 4000,\n  \"messages\": [{\"role\": \"user\", \"content\": \"Assemble a GDD from this data...\"}]\n}"
      },
      "name": "Claude Assembly",
      "type": "n8n-nodes-base.httpRequest",
      "position": [850, 300]
    },
    {
      "parameters": {
        "fileName": "game_gdd_{{ $now.format('yyyy-MM-dd') }}.md",
        "fileContent": "{{ $json.content }}"
      },
      "name": "Save to File",
      "type": "n8n-nodes-base.executeCommand",
      "position": [1050, 300]
    }
  ],
  "connections": {
    "Webhook": {
      "main": [
        [
          {"node": "Bhava AI Narrative", "index": 0},
          {"node": "Ludo AI Mechanics", "index": 0}
        ]
      ]
    },
    "Bhava AI Narrative": {
      "main": [[{"node": "Diagram Generation", "index": 0}]]
    },
    "Ludo AI Mechanics": {
      "main": [[{"node": "Diagram Generation", "index": 0}]]
    },
    "Diagram Generation": {
      "main": [[{"node": "Claude Assembly", "index": 0}]]
    },
    "Claude Assembly": {
      "main": [[{"node": "Save to File", "index": 0}]]
    }
  }
}

The Manual Alternative

If you prefer more control over each stage, you can run the tools individually and review outputs between steps. This takes longer but lets you tweak parameters and steer the results.

Submit your concept to Bhava AI directly via their web interface, review the narrative structure output, then manually copy relevant sections into a document. Next, go to Ludo AI, feed it the concept plus your narrative notes, and review the mechanics. Generate diagrams manually in Diagram by copying and pasting the JSON outputs. Finally, write or edit the GDD yourself using Claude in a conversation, pasting in each section as you go.

This approach works well if you want to learn how the tools work individually or if you need significant creative input at each stage. It's slower but gives you veto power over every decision.

Pro Tips

1. Rate Limiting and Batching

Bhava AI and Ludo AI have rate limits of 100 requests per minute on most plans. If you're running multiple workflows, add delays between tool calls. In n8n, use a Wait node set to 500ms between the Bhava and Ludo calls. This prevents throttling errors and keeps your workflow stable.

2. Error Handling and Retries

Add an Error Handling node after each HTTP Request. Configure it to retry failed requests twice with exponential backoff. Diagram's API occasionally returns timeouts on complex diagrams; retrying once usually succeeds.

Copy
Retry Configuration:
- Max retries: 2
- Wait between retries: 5 seconds for first retry, 10 for second
- Continue on error: enabled for optional steps like diagram generation

3. Cost Optimisation

Claude's API costs scale with token usage. The assembled GDD typically uses 3,000-4,000 tokens. If you're generating 10+ documents per month, you'll spend £12-20 on Claude alone. Consider using Claude 3 Haiku (cheaper) for the assembly step if you don't need the highest quality, then upgrade to Sonnet only for complex projects.

4. Testing Incrementally

Don't try to run the full workflow on your first attempt. Test each tool individually:

• Run just the webhook and Bhava AI, save the output
• Verify the JSON structure before moving to the next tool
• Test Ludo AI with a copy of the Bhava output
• Work through diagram generation separately

This isolates problems and lets you fix issues before they compound.

5. Customising the GDD Format

Different studios use different GDD templates. Instead of having Claude generate a generic structure, provide a template in the Claude prompt:

Copy
Use this structure:
1. Executive Summary (200 words)
2. High Concept (one sentence)
3. Target Audience
4. Platform and Technical Requirements
5. Narrative Overview
6. Core Gameplay Loop
7. Progression System
8. Asset Requirements
9. Schedule Estimate

Fill each section based on the data provided, keeping narrative and mechanics aligned.

Cost Breakdown

If you run this workflow once weekly (52 documents per year), your cost is roughly £100/month. Running it once daily would push you toward the upper limits, at which point you'd want to negotiate volume pricing with the tool providers.

This workflow shifts game design from a three-day manual process to a fifteen-minute automated one, freeing your team to focus on creative iteration rather than documentation grunt work.