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

> Learn how the developer wizard simplifies API integration. Generate client code, live API examples, and LLM prompts to make the exercises dataset production-ready instantly.

- Repository: [Hasan Emir Yıldırım/exercises-dataset](https://github.com/hasaneyldrm/exercises-dataset)
- Tags: how-to-guide
- Published: 2026-08-01

---

**The Developer Wizard in [`setup.html`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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](https://github.com/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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

```python
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

```js
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

```bash
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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json)
- Sample records from [`data/exercises.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/setup.html)** — The interactive wizard itself; contains all live-updating logic, language switchers, and LLM prompt generators.
- **[`data/exercises.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json)** — The 800+ record dataset served by your generated API; the wizard references this for sample data injection.
- **[`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json)** — JSON Schema validation document; embedded into LLM prompts for type-safe code generation.
- **[`index.html`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/index.html)** — Standalone browser explorer (separate from the wizard) for manual dataset inspection.

## How API Integration Works End-to-End

1. **Open [`setup.html`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json)** and **[`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json)** power both the wizard and your generated API's data layer.
- The entire workflow requires zero installation — open [`setup.html`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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.