Fashion lookbook generation from style guide specifications

Introduction

Fashion brands spend countless hours translating style guides into visual lookbooks. A designer receives a detailed specification document covering colour palettes, typography, silhouettes, and mood. They then manually brief a photographer or illustrator, coordinate shoots, edit assets, and compile everything into a presentable format. This process takes weeks and requires constant back-and-forth communication.

What if that entire workflow ran automatically? You could feed a style guide into a system, have it generate cohesive visual assets, and receive a finished lookbook without touching a single tool in between. This isn't science fiction. By combining Nsketch AI for design generation with Weryai for workflow orchestration, you can build a fully automated pipeline that turns specifications into production-ready lookbooks in hours instead of weeks.

This guide walks you through setting up that exact system. We'll use either Zapier, n8n, Make, or Claude Code as the glue, depending on your technical comfort level. By the end, you'll have a workflow that accepts style guide uploads and produces complete lookbooks automatically.

The Automated Workflow

Understanding the Flow

The workflow follows this sequence: style guide document arrives; text and specifications are extracted; Nsketch AI generates design variations based on those specs; Weryai applies branding consistency across all generated assets; final lookbook is compiled and exported. Each step feeds directly into the next with zero manual intervention.

Prerequisites you'll need:

• Nsketch AI API credentials (sign up at nsketch.ai)
• Weryai account with API access enabled (weryai.com)
• An orchestration platform (we'll cover multiple options)
• A storage system for source documents and outputs, such as Google Drive, Dropbox, or AWS S3

Using n8n for Full Control

If you want the most flexibility and don't mind self-hosting or paying for n8n Cloud, this is the strongest choice. n8n lets you build complex logic without writing much code.

Step 1: Trigger on Document Upload

Set up a webhook or use n8n's built-in Google Drive node to watch for new files in a specific folder. When a style guide PDF appears, the workflow activates.

Copy
Trigger: Google Drive - Watch for files
  - Folder: /Style Guides/Incoming
  - File type: PDF
  - Poll interval: 5 minutes

Step 2: Extract Text from the Style Guide

Use an OCR or PDF parsing tool within n8n. If the PDF is already digitised text, use the PDF node directly.

Copy{
  "node": "PDF",
  "operation": "Extract Text",
  "input": "{{ $json.data.webContentLink }}",
  "output": "extractedText"
}

Step 3: Structure the Specs with Claude

Before sending data to Nsketch, parse the unstructured style guide text using Claude via the n8n HTTP Request node. This creates a clean JSON specification that Nsketch can understand.

Copy
HTTP Request Node Configuration:
- URL: https://api.anthropic.com/v1/messages
- Method: POST
- Headers:
    Authorization: Bearer YOUR_CLAUDE_API_KEY
    Content-Type: application/json

Body:
{
  "model": "claude-3-5-sonnet-20241022",
  "max_tokens": 2000,
  "messages": [
    {
      "role": "user",
      "content": "Parse this style guide into JSON format with these fields: colour_palette (array of hex codes), primary_font, secondary_font, silhouette_types (array), mood_keywords (array), target_demographic. Here's the guide: {{ $json.extractedText }}"
    }
  ]
}

n8n will return structured JSON that looks like this:

Copy{
  "colour_palette": ["#2C3E50", "#E74C3C", "#ECF0F1"],
  "primary_font": "Helvetica Neue",
  "secondary_font": "Georgia",
  "silhouette_types": ["fitted", "oversized", "A-line"],
  "mood_keywords": ["minimalist", "modern", "professional"],
  "target_demographic": "Women 25-40"
}

Step 4: Call Nsketch AI for Design Generation

With specifications structured, you're ready to generate designs. Nsketch AI's endpoint accepts parameters and returns image URLs.

Copy
HTTP Request Node:
- URL: https://api.nsketch.ai/v1/generate
- Method: POST
- Headers:
    Authorization: Bearer YOUR_NSKETCH_API_KEY
    Content-Type: application/json

Body:
{
  "prompt": "Fashion lookbook design. Primary colours: {{ $json.colour_palette[0] }}, {{ $json.colour_palette[1] }}, {{ $json.colour_palette[2] }}. Style: {{ $json.mood_keywords.join(', ') }}. Silhouettes: {{ $json.silhouette_types.join(', ') }}. Typography style: {{ $json.primary_font }}. Target audience: {{ $json.target_demographic }}.",
  "style": "fashion_lookbook",
  "num_variations": 6,
  "resolution": "2048x2048",
  "batch_id": "{{ $json.fileId }}"
}

Nsketch returns an array of image objects:

Copy{
  "status": "success",
  "images": [
    {
      "url": "https://cdn.nsketch.ai/images/abc123.png",
      "variation_id": "var_1",
      "metadata": {
        "colours_used": ["#2C3E50", "#E74C3C"],
        "dominant_style": "minimalist"
      }
    },
    {
      "url": "https://cdn.nsketch.ai/images/abc124.png",
      "variation_id": "var_2",
      "metadata": {
        "colours_used": ["#ECF0F1", "#2C3E50"],
        "dominant_style": "modern"
      }
    }
  ],
  "batch_id": "{{ $json.batch_id }}"
}

Step 5: Apply Branding Consistency with Weryai

Now pass all generated images to Weryai, which analyses them for consistency against your brand specifications and can apply adjustments or filters.

Copy
HTTP Request Node:
- URL: https://api.weryai.com/v2/batch/analyse
- Method: POST
- Headers:
    Authorization: Bearer YOUR_WERYAI_API_KEY
    Content-Type: application/json

Body:
{
  "images": [
    {
      "url": "{{ $json.images[0].url }}",
      "id": "{{ $json.images[0].variation_id }}"
    },
    {
      "url": "{{ $json.images[1].url }}",
      "id": "{{ $json.images[1].variation_id }}"
    }
  ],
  "brand_guidelines": {
    "colour_palette": {{ JSON.stringify($json.colour_palette) }},
    "typography": "{{ $json.primary_font }}",
    "consistency_threshold": 0.85
  },
  "output_format": "lookbook_page"
}

Weryai returns consistency scores and can apply automatic adjustments:

Copy{
  "status": "complete",
  "analysed_images": [
    {
      "original_id": "var_1",
      "consistency_score": 0.92,
      "colour_match": 0.94,
      "style_match": 0.89,
      "adjusted_url": "https://cdn.weryai.com/output/abc123_adjusted.png",
      "warnings": []
    },
    {
      "original_id": "var_2",
      "consistency_score": 0.87,
      "colour_match": 0.88,
      "style_match": 0.86,
      "adjusted_url": "https://cdn.weryai.com/output/abc124_adjusted.png",
      "warnings": ["secondary_colour_saturation_low"]
    }
  ]
}

Step 6: Compile into Lookbook Format

Use n8n's Google Docs or similar node to create a formatted lookbook document, inserting the adjusted images and metadata automatically.

Copy
Google Docs Node:
- Create new document
- Insert title: "{{ $json.brand_name }} - Season {{ $json.season }} Lookbook"
- For each image:
  - Insert heading: "Design Variation {{ $index + 1 }}"
  - Insert image: {{ $json.analysed_images[$index].adjusted_url }}
  - Insert text: "Consistency Score: {{ $json.analysed_images[$index].consistency_score }}"
  - Insert colour palette used
- Save to: /Lookbooks/Complete/{{ timestamp }}

Step 7: Notify and Archive

Send a notification that the lookbook is ready and archive the source document.

Copy
Slack Node:
- Channel: #design-output
- Message: "✓ Lookbook generated for {{ $json.brand_name }}. Consistency: {{ avg(analysed_images.consistency_score) }}. View: {{ $json.lookbook_doc_url }}"

Google Drive Node:
- Move source file to: /Style Guides/Processed/{{ timestamp }}

Using Make (Integromat) for Quick Setup

If you prefer a visual interface without self-hosting, Make is simpler to set up. The logic remains identical, but the UI is more beginner-friendly.

In Make, you'll build the same steps as above, but through their drag-and-drop interface:

1. Google Drive trigger watches for PDFs.
2. Text extraction via their HTTP module calling an OCR API.
3. Claude parsing via HTTP request.
4. Nsketch generation via HTTP request.
5. Weryai analysis via HTTP request.
6. Google Docs creation to compile output.
7. Slack notification.

Make's advantage is that configuration is visible and shareable; anyone can review the workflow. The disadvantage is less flexibility for complex conditional logic, though you can add JavaScript code modules if needed.

Using Zapier for Simplicity

Zapier works best if the tools have pre-built integrations. Nsketch and Weryai may not have native Zapier apps, so you'll rely heavily on the Webhooks by Zapier action. This adds extra steps but is still manageable.

The workflow would be: Google Drive trigger, Code by Zapier step to call Nsketch API, Code by Zapier step to call Weryai API, Google Docs action to create lookbook, Slack notification.

Zapier is the most accessible for non-technical users, though it becomes expensive quickly if you run hundreds of workflows monthly.

Using Claude Code for Custom Logic

If none of the above feels right, Claude Code lets you write a Python script that orchestrates everything. You'd deploy this as a scheduled function or webhook, and it handles the entire pipeline.

Copyimport requests
import json
import time
from datetime import datetime

NSKETCH_API_KEY = "your_key"
WERYAI_API_KEY = "your_key"
CLAUDE_API_KEY = "your_key"

def process_style_guide(pdf_path, brand_name):
    # Step 1: Extract text from PDF
    extracted_text = extract_pdf_text(pdf_path)
    
    # Step 2: Parse with Claude
    specs = parse_with_claude(extracted_text)
    
    # Step 3: Generate designs with Nsketch
    designs = generate_designs_nsketch(specs)
    
    # Step 4: Analyse with Weryai
    analysed = analyse_with_weryai(designs, specs)
    
    # Step 5: Compile lookbook
    lookbook_url = compile_lookbook(analysed, specs, brand_name)
    
    return lookbook_url

def parse_with_claude(text):
    response = requests.post(
        "https://api.anthropic.com/v1/messages",
        headers={"Authorization": f"Bearer {CLAUDE_API_KEY}"},
        json={
            "model": "claude-3-5-sonnet-20241022",
            "max_tokens": 2000,
            "messages": [{
                "role": "user",
                "content": f"Parse style guide into JSON with colour_palette, primary_font, silhouette_types, mood_keywords, target_demographic. Guide: {text}"
            }]
        }
    )
    return json.loads(response.json()["content"][0]["text"])

def generate_designs_nsketch(specs):
    prompt = f"""Fashion lookbook. 
    Colours: {', '.join(specs['colour_palette'])}. 
    Style: {', '.join(specs['mood_keywords'])}. 
    Silhouettes: {', '.join(specs['silhouette_types'])}. 
    Font: {specs['primary_font']}. 
    Audience: {specs['target_demographic']}."""
    
    response = requests.post(
        "https://api.nsketch.ai/v1/generate",
        headers={"Authorization": f"Bearer {NSKETCH_API_KEY}"},
        json={
            "prompt": prompt,
            "style": "fashion_lookbook",
            "num_variations": 6,
            "resolution": "2048x2048"
        }
    )
    return response.json()["images"]

def analyse_with_weryai(images, specs):
    payload = {
        "images": [{"url": img["url"], "id": img["variation_id"]} for img in images],
        "brand_guidelines": {
            "colour_palette": specs["colour_palette"],
            "typography": specs["primary_font"],
            "consistency_threshold": 0.85
        },
        "output_format": "lookbook_page"
    }
    
    response = requests.post(
        "https://api.weryai.com/v2/batch/analyse",
        headers={"Authorization": f"Bearer {WERYAI_API_KEY}"},
        json=payload
    )
    return response.json()["analysed_images"]

if __name__ == "__main__":
    lookbook = process_style_guide("style_guide.pdf", "Brand Name")
    print(f"Lookbook created: {lookbook}")

Deploy this to AWS Lambda, Google Cloud Functions, or a simple server, and trigger it via webhook whenever a style guide is uploaded.

The Manual Alternative

You might want manual oversight at certain stages, particularly for brand-sensitive work. A hybrid approach keeps the workflow efficient while adding quality control.

After Weryai analyses images, instead of automatically compiling the lookbook, pause the workflow and send the results to a human reviewer. They approve or request adjustments within 30 minutes. Once approved, the workflow resumes and completes the lookbook compilation.

In n8n, this is a "Wait for Webhook" node. In Make, it's a "Wait" action followed by approval logic. This adds maybe 30 minutes to the overall timeline but ensures no off-brand designs slip through.

Alternatively, run the automation nightly, review results the next morning, and manually publish approved lookbooks. This is slower but feels safer for conservative brands.

Pro Tips

Rate Limiting and Costs: Both Nsketch and Weryai have API rate limits. Nsketch typically allows 100 requests per minute on paid plans, while Weryai varies by tier. If you're generating lookbooks for multiple brands simultaneously, queue the requests rather than running them in parallel. Use a delay of 1-2 seconds between API calls to avoid hitting limits.

Copy
In n8n, add a "Wait" node between API calls:
- Time in milliseconds: 2000

Error Handling is Critical: Style guides vary wildly in format and quality. Some are detailed PDFs; others are scanned images. If OCR fails, the workflow stalls. Build in a fallback: if text extraction yields fewer than 100 characters, send a Slack message asking for manual clarification and pause. Don't let the workflow fail silently.

Cost Optimisation: Nsketch charges per image generated. Requesting 6 variations per brand can add up. Start with 3 variations and see if consistency scores are acceptable. If they drop below 0.80, increase to 6. This cuts costs by roughly 50% on average.

Test with a Dummy Guide First: Before automating a real brand, run the workflow with a test style guide containing intentionally unusual colours and styles. This reveals quirks in how Claude interprets specs and how Nsketch handles edge cases.

Archive Everything: Store the original extracted text, Claude's parsed JSON, Nsketch's raw images, and Weryai's adjusted versions. If a brand disputes the lookbook later, you have the full audit trail showing exactly how each decision was made.

Cost Breakdown

This workflow typically pays for itself after completing 3-4 lookbooks, given the labour it saves. A single lookbook would normally cost £500-£2000 to produce manually.