🔧 AI-Driven Design ToolsApril 19, 2026✅ Tests passing

UX Audit Generator

This automation tool uses the Claude Design API to perform automated audits of UI/UX prototypes. It evaluates designs for usability, accessibility, and aesthetic consistency based on well-known UX principles and generates a detailed audit report.

View on GitHub Download ZIP

Share:X / Twitter LinkedIn Reddit Hacker News

What It Does

Automated UX audit of prototypes using Claude Design API
Checks for accessibility compliance and usability best practices
Generates detailed, human-readable audit reports in HTML or Markdown

Installation

1. Clone the repository:

git clone https://github.com/your-repo/ux-audit-generator.git
   cd ux-audit-generator

2. Install the required dependencies:

pip install -r requirements.txt

Usage

Run the tool using the following command:

python ux_audit_generator.py --input prototype.json --output report.md --api-url https://api.claude.design/audit --api-key YOUR_API_KEY

Arguments

--input: Path to the prototype JSON file (required)
--output: Path to save the generated report (required)
--api-url: URL of the Claude Design API (required)
--api-key: API key for authentication (required)
--description: Optional text description of the prototype
--format: Output format, either html or md (default: md)

Example

python ux_audit_generator.py \
  --input example_prototype.json \
  --output audit_report.md \
  --api-url https://api.claude.design/audit \
  --api-key YOUR_API_KEY \
  --description "This is a prototype for a mobile app."

Source Code

import argparse
import json
import os
import requests
from jinja2 import Template

def fetch_audit_results(api_url, api_key, prototype_data, description):
    """
    Fetches audit results from the Claude Design API.

    :param api_url: URL of the Claude Design API
    :param api_key: API key for authentication
    :param prototype_data: JSON data of the prototype
    :param description: Optional text description of the prototype
    :return: Audit results as a dictionary
    """
    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
    payload = {"prototype_data": prototype_data, "description": description}

    try:
        response = requests.post(api_url, headers=headers, json=payload)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        raise RuntimeError(f"Error fetching audit results: {e}")

def generate_report(audit_results, output_format):
    """
    Generates an audit report in the specified format.

    :param audit_results: Audit results as a dictionary
    :param output_format: Either 'html' or 'md'
    :return: Rendered report as a string
    """
    template_str = """
    {% if output_format == 'html' %}
    <html>
    <head><title>UX Audit Report</title></head>
    <body>
        <h1>UX Audit Report</h1>
        <h2>Summary</h2>
        <p>{{ audit_results.summary }}</p>
        <h2>Details</h2>
        <ul>
        {% for issue in audit_results.issues %}
            <li><strong>{{ issue.title }}</strong>: {{ issue.description }}</li>
        {% endfor %}
        </ul>
    </body>
    </html>
    {% else %}
    # UX Audit Report

    ## Summary
    {{ audit_results.summary }}

    ## Details
    {% for issue in audit_results.issues %}
    - **{{ issue.title }}**: {{ issue.description }}
    {% endfor %}
    {% endif %}
    """
    template = Template(template_str)
    return template.render(audit_results=audit_results, output_format=output_format)

def main():
    parser = argparse.ArgumentParser(description="UX Audit Generator")
    parser.add_argument("--input", required=True, help="Path to the prototype JSON file")
    parser.add_argument("--output", required=True, help="Path to save the generated report")
    parser.add_argument("--api-url", required=True, help="Claude Design API URL")
    parser.add_argument("--api-key", required=True, help="Claude Design API Key")
    parser.add_argument("--description", help="Optional text description of the prototype")
    parser.add_argument("--format", choices=["html", "md"], default="md", help="Output format (html or md)")

    args = parser.parse_args()

    # Load prototype data
    if not os.path.exists(args.input):
        raise FileNotFoundError(f"Input file {args.input} does not exist.")

    with open(args.input, "r") as f:
        try:
            prototype_data = json.load(f)
        except json.JSONDecodeError:
            raise ValueError("Input file is not valid JSON.")

    # Fetch audit results
    audit_results = fetch_audit_results(args.api_url, args.api_key, prototype_data, args.description)

    # Generate report
    report = generate_report(audit_results, args.format)

    # Save report to file
    with open(args.output, "w") as f:
        f.write(report)

if __name__ == "__main__":
    main()

Community

Downloads

···

Rate this tool

No ratings yet — be the first!

Details

Tool Name: ux_audit_generator
Category: AI-Driven Design Tools
Generated: April 19, 2026
Tests: Passing ✅

Quick Install

Clone just this tool:

git clone --depth 1 --filter=blob:none --sparse \
  https://github.com/ptulin/autoaiforge.git
cd autoaiforge
git sparse-checkout set generated_tools/2026-04-19/ux_audit_generator
cd generated_tools/2026-04-19/ux_audit_generator
pip install -r requirements.txt 2>/dev/null || true
python ux_audit_generator.py

Links

View source on GitHub Raw README.md