File to Code

Generate production-ready code from file specifications, data schemas, and requirements documents.

Overview

This skill reads structured input files -- CSV data, JSON schemas, SQL DDL statements, protobuf definitions, OpenAPI specs, or plain-text requirements -- and generates complete, production-ready code to process, serve, or transform that data. Instead of manually writing boilerplate models, validation logic, and CRUD endpoints, this skill analyzes the input structure and produces well-typed code with proper error handling, input validation, and test coverage.

The skill supports multiple output languages and frameworks. It infers types from data samples, respects constraints defined in schemas, and follows best practices for the target framework. When generating API endpoints, it includes request validation, error responses, and OpenAPI documentation. When generating data processing pipelines, it includes type coercion, null handling, and logging.

Instructions

1. Point to the input file or paste its contents:

   • "Read

     data/users.csv

     and generate a REST API for it"
   • "Here's my JSON schema:

     { ... }

     -- generate TypeScript types and a validator"
   • "Create a data pipeline from

     schema.sql

     "

2. Specify the target language and framework (optional -- the skill will infer reasonable defaults):

   • Language: TypeScript, Python, Go, Rust, Java
   • Framework: Express, FastAPI, Gin, Actix, Spring Boot
   • If unspecified, defaults to TypeScript with Express for APIs, or Python for data processing

3. Indicate the scope of what you want generated:

   • "Just the types" -- generates type definitions and interfaces only
   • "Full CRUD API" -- generates routes, controllers, models, validation, and tests
   • "Parser only" -- generates a file reader/parser with error handling
   • "Everything" -- generates the full stack: types, API, tests, and documentation

4. Review the generated code. The skill creates files in your project directory following standard conventions (e.g.,

   src/models/

   ,

   src/routes/

   ,

   tests/

   ). Inspect the output and request adjustments if needed.

Output

Depending on the input and requested scope, the skill generates:

• Type Definitions: Interfaces, types, or structs matching the input schema with proper nullability and constraints.
• Validation Logic: Input validation using libraries appropriate to the target framework (Zod for TypeScript, Pydantic for Python, etc.).
• API Endpoints: RESTful routes with CRUD operations, request/response typing, error handling, and pagination support.
• Data Processors: File readers, parsers, and transformation pipelines with type coercion and error recovery.
• Test Suites: Unit tests covering happy paths, edge cases, and error conditions using the project's test framework.
• OpenAPI Spec: Auto-generated API documentation in OpenAPI 3.0 format when generating API endpoints.

Examples

Example 1: CSV to REST API

User: "Read

data/products.csv

and generate a FastAPI app to serve this data."

The skill will:

1. Read the CSV file and analyze column names, data types, and sample values.
2. Generate a Pydantic model (

   Product

   ) with fields inferred from the CSV headers.
3. Create FastAPI routes:

   GET /products

   ,

   GET /products/{id}

   ,

   POST /products

   ,

   PUT /products/{id}

   ,

   DELETE /products/{id}

   .
4. Add CSV ingestion logic to seed an SQLite database on startup.
5. Generate pytest tests for each endpoint.

Example 2: JSON Schema to TypeScript

User: "Here's my API response schema. Generate TypeScript types and a Zod validator."

The skill will:

1. Parse the JSON Schema, resolving

   $ref

   references and nested objects.
2. Generate TypeScript interfaces for each schema definition.
3. Create corresponding Zod schemas that enforce the same constraints (required fields, string patterns, numeric ranges).
4. Export a

   validate

   function that returns typed, validated data or a structured error.

Example 3: SQL DDL to Go Models

User: "Read

migrations/001_create_tables.sql

and generate Go structs with sqlc-compatible annotations."

The skill will:

1. Parse CREATE TABLE statements to extract table names, columns, types, and constraints.
2. Map SQL types to Go types (e.g.,

   VARCHAR

   to

   string

   ,

   TIMESTAMP

   to

   time.Time

   ,

   BOOLEAN

   to

   bool

   ).
3. Generate Go struct definitions with

   db

   and

   json

   tags.
4. Create a

   queries.sql

   file with standard CRUD queries for sqlc to process.

Error Handling

• Unrecognized file format: Prompts the user to specify the format or provide a sample of the expected structure.
• Ambiguous types: When column types cannot be inferred from data alone, asks the user to clarify (e.g., "Is

  status

  an enum or a free-text string?").
• Missing dependencies: Lists required packages (e.g.,

  pip install fastapi uvicorn

  ) and offers to generate a

  requirements.txt

  or

  package.json

  .
• Large files: For files with many columns or tables, generates code incrementally and confirms scope before proceeding.

Prerequisites

• Input file accessible on disk (CSV, JSON Schema, SQL DDL, protobuf, or OpenAPI spec)
• Target language runtime installed (Node.js, Python, Go, etc.)
• Package manager available (

  npm

  or

  pip

  ) for installing generated dependencies

Resources

• JSON Schema specification — schema definition reference
• OpenAPI 3.0 specification — API description format
• Zod documentation — TypeScript-first schema validation