How the Developer Wizard Helps with API Integration: Setup Guide for the Exercises Dataset

The Developer Wizard in setup.html is a browser-based tool that generates ready-to-copy client code, live-updating API examples, and LLM prompts to instantly transform the static exercises dataset into a production-ready REST API.

The hasaneyldrm/exercises-dataset repository ships with a built-in Developer Wizard that eliminates the friction of integrating exercise data into your applications. Instead of manually parsing data/exercises.json and writing boilerplate request handlers, developers get a guided, interactive experience that produces working code in seven languages plus AI-generated backend scaffolding. This article breaks down exactly how the wizard accelerates API integration and what happens under the hood in setup.html.

Live-Updating Client Code Generation

The wizard's core feature is its real-time code block renderer. As you type your target API base URL into the input field, every snippet on the page instantly updates to reflect that endpoint.

This eliminates the copy-paste errors that plague static documentation. You see the exact request shape your client will execute — including proper query parameters for filtering by category, equipment, target, or language.

Supported Client Languages

The wizard emits idiomatic code for:

• JavaScript (browser fetch and Node.js)
• Python (requests library)
• C# (HttpClient)
• Java ( java.net.http.HttpRequest)
• PHP (curl and Guzzle variants)
• Go (net/http with encoding/json)
• cURL (direct shell commands)

Each block is wrapped with error handling patterns appropriate to that language, not bare HTTP calls.

Ready-to-Run Code Examples

Below are the exact snippets the wizard renders once you populate the base URL field. Replace https://your-api.example.com with the endpoint you configure in the wizard.

Python Integration

import requests

BASE_URL = "https://your-api.example.com"   # ← paste the URL entered in the wizard

response = requests.get(f"{BASE_URL}/exercises?category=chest")
data = response.json()

print(f"Found {len(data)} chest exercises")
for ex in data[:5]:
    print(f"- {ex['name']} ({ex['equipment']})")

The wizard includes .raise_for_status() calls and timeout defaults in production-ready variants.

JavaScript (Node.js) Integration

const fetch = require('node-fetch');

const BASE_URL = "https://your-api.example.com"; // set in the wizard
fetch(`${BASE_URL}/exercises?equipment=body%20weight`)
  .then(r => r.json())
  .then(exercises => {
    console.log(`Body-weight exercises: ${exercises.length}`);
    console.table(exercises.slice(0, 3).map(e => ({ name: e.name, target: e.target })));
  });

Browser versions omit the require and add AbortController for cancellation.

Direct cURL Testing

curl "https://your-api.example.com/exercises?language=en" \
     -H "Accept: application/json"

The wizard escapes query parameters automatically to prevent shell injection issues.

LLM-Ready Prompt Generation for Full Backend Scaffolding

Beyond client stubs, the wizard generates structured prompts for major language models (ChatGPT, Claude, Gemini, etc.). These prompts request complete, production-grade API implementations from the LLM.

Framework-Specific Backend Templates

Selecting your target framework in setup.html produces a prompt tuned for:

Framework	Target Use Case
Express.js	Node.js REST APIs with middleware patterns
FastAPI	Python async APIs with automatic OpenAPI docs
ASP.NET Core	C# enterprise APIs with Entity Framework

| Spring Boot | Java microservices with JPA/Hibernate | | Laravel | PHP APIs with Eloquent ORM integration | | Gin | High-performance Go APIs |

Each prompt includes:

• The complete JSON schema from data/exercises.schema.json
• Sample records from data/exercises.json
• Filter parameter specifications (category, equipment, target, language, offset, limit)
• Response pagination patterns
• Error handling requirements (404, 400, 500)

This reduces API integration time from hours of scaffolding to minutes of prompt engineering.

Key Files Powering the Wizard

The Developer Wizard's functionality depends on these repository assets:

• setup.html — The interactive wizard itself; contains all live-updating logic, language switchers, and LLM prompt generators.
• data/exercises.json — The 800+ record dataset served by your generated API; the wizard references this for sample data injection.
• data/exercises.schema.json — JSON Schema validation document; embedded into LLM prompts for type-safe code generation.
• index.html — Standalone browser explorer (separate from the wizard) for manual dataset inspection.

How API Integration Works End-to-End

1. Open setup.html in any modern browser (no build step required).
2. Enter your planned API base URL — the wizard immediately updates all code blocks.
3. Select your client language — copy the generated snippet into your application.
4. [Optional] Select backend framework — copy the LLM prompt, paste into your AI tool, and generate a complete server implementation.
5. Deploy and test — the generated client code connects to your new API without modification.

Summary

• The Developer Wizard (setup.html) provides seven language client stubs with live URL substitution.
• Real-time code updates guarantee examples match your actual endpoint, preventing integration bugs.
• LLM prompt generation auto-creates production backend code in six major frameworks.
• Source files data/exercises.json and data/exercises.schema.json power both the wizard and your generated API's data layer.
• The entire workflow requires zero installation — open setup.html and begin API integration immediately.

Frequently Asked Questions

What languages does the Developer Wizard support for client code?

The wizard generates client integration code for JavaScript, Python, C#, Java, PHP, Go, and cURL. Each snippet uses idiomatic patterns for that language — requests for Python, HttpClient for C#, net/http for Go — with proper error handling and query parameter escaping built in.

Can I use the wizard without installing anything?

Yes. The wizard is a standalone HTML file at setup.html. Open it directly in any modern browser; no Node, Python, or package manager required. The live-updating functionality runs entirely in client-side JavaScript.

How does the LLM prompt generation actually create a backend API?

When you select a framework in the wizard, it assembles a structured prompt containing: (1) the complete JSON schema from data/exercises.schema.json, (2) sample exercise records, and (3) endpoint specifications including filtering and pagination. Paste this prompt into ChatGPT, Claude, or Gemini, and the model outputs ready-to-run server code for Express.js, FastAPI, ASP.NET Core, Spring Boot, Laravel, or Gin — complete with route handlers and data models.

Where does the exercise data come from in my generated API?

The generated backends read from data/exercises.json, the 800+ record array shipped with the repository. The wizard's prompts instruct LLMs to load this file at startup or import it into a database, then expose filtered subsets via REST endpoints matching the query parameters shown in the client code examples.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}