openapi-to-application-code

SKILL.md

Generate Application from OpenAPI Spec

Your goal is to generate a complete, working application from an OpenAPI specification using the active framework's conventions and best practices.

Input Requirements

OpenAPI Specification: Provide either:

A URL to the OpenAPI spec (e.g., https://api.example.com/openapi.json)

A local file path to the OpenAPI spec

The full OpenAPI specification content pasted directly

Project Details (if not in spec):

Project name and description

Target framework and version

Package/namespace naming conventions

Authentication method (if not specified in OpenAPI)

Generation Process
Step 1: Analyze the OpenAPI Specification

Validate the OpenAPI spec for completeness and correctness

Identify all endpoints, HTTP methods, request/response schemas

Extract authentication requirements and security schemes

Note data model relationships and constraints

Flag any ambiguities or incomplete definitions

Step 2: Design Application Architecture

Plan directory structure appropriate for the framework

Identify controller/handler grouping by resource or domain

Design service layer organization for business logic

Plan data models and entity relationships

Design configuration and initialization strategy

Step 3: Generate Application Code

Create project structure with build/package configuration files

Generate models/DTOs from OpenAPI schemas

Generate controllers/handlers with route mappings

Generate service layer with business logic

Generate repository/data access layer if applicable

Add error handling, validation, and logging

Generate configuration and startup code

Step 4: Add Supporting Files

Generate appropriate unit tests for services and controllers

Create README with setup and running instructions

Add .gitignore and environment configuration templates

Generate API documentation files

Create example requests/integration tests

Output Structure

The generated application will include:

project-name/
├── README.md                      # Setup and usage instructions
├── [build-config]                 # Framework-specific build files (pom.xml, build.gradle, package.json, etc.)
├── src/
│   ├── main/
│   │   ├── [language]/
│   │   │   ├── controllers/       # HTTP endpoint handlers
│   │   │   ├── services/          # Business logic
│   │   │   ├── models/            # Data models and DTOs
│   │   │   ├── repositories/      # Data access (if applicable)
│   │   │   └── config/            # Application configuration
│   │   └── resources/             # Configuration files
│   └── test/
│       ├── [language]/
│       │   ├── controllers/       # Controller tests
│       │   └── services/          # Service tests
│       └── resources/             # Test configuration
├── .gitignore
├── .env.example                   # Environment variables template
└── docker-compose.yml             # Optional: Docker setup (if applicable)

Best Practices Applied

Framework Conventions: Follows framework-specific naming, structure, and patterns

Separation of Concerns: Clear layers with controllers, services, and repositories

Error Handling: Comprehensive error handling with meaningful responses

Validation: Input validation and schema validation throughout

Logging: Structured logging for debugging and monitoring

Testing: Unit tests for services and controllers

Documentation: Inline code documentation and setup instructions

Security: Implements authentication/authorization from OpenAPI spec

Scalability: Design patterns support growth and maintenance

Next Steps

After generation:

Review the generated code structure and make customizations as needed

Install dependencies according to framework requirements

Configure environment variables and database connections

Run tests to verify generated code

Start the development server

Test endpoints using the provided examples

Questions to Ask if Needed

Should the application include database/ORM setup, or just in-memory/mock data?

Do you want Docker configuration for containerization?

Should authentication be JWT, OAuth2, API keys, or basic auth?

Do you need integration tests or just unit tests?

Any specific database technology preferences?

Should the API include pagination, filtering, and sorting examples?