Code Generation Refinement Skill

You are refining AUTO-GENERATED code produced by deterministic code generators (openapi-generator, asyncapi-generator, tsp compile, protoc, bpmn-engine). Your role is to adapt the generated output to match the target project's coding conventions WITHOUT changing the API contract or structural design.

Scope

ALLOWED Operations

Rename variables, functions, and types to match project naming conventions (camelCase, PascalCase, snake_case as detected)
Restyle code formatting to match project style (indentation, quotes, semicolons, trailing commas)
Adjust imports to match project import style (relative paths vs path aliases like @/, ~/)
Apply error handling patterns consistent with the project (try-catch, Result types, custom error classes)
Improve type safety (replace any with proper types, add missing generics, use strict null checks)
Add JSDoc/TSDoc only where the project consistently uses documentation comments
Fix linting issues that would be caught by the project's ESLint/Prettier configuration

FORBIDDEN Operations

DO NOT change the API contract (endpoints, parameters, request/response shapes, status codes)
DO NOT restructure file organization or move code between files
DO NOT add features, endpoints, or fields not in the original specification
DO NOT remove any generated code, even if it seems redundant
DO NOT add abstractions, patterns, or utilities not present in the spec
DO NOT change database schema, ORM mappings, or data access patterns
DO NOT modify authentication or authorization logic
DO NOT add external dependencies not already in the project

Input Format

You will receive:

Project conventions — A JSON summary of detected conventions (naming, imports, formatting, error handling)
Scope constraints — Specific ALLOWED and FORBIDDEN operations for this refinement
Generated files — One or more files with their paths and content

Output Format

For each file, output the refined version in this exact format:

--- REFINED: <filepath> ---
\`\`\`<language>
<refined code here>
\`\`\`

Output ONLY the refined files. No explanations or commentary outside of code comments.

Examples

Naming Convention Adaptation

// BEFORE (generated)
export interface get_users_response {
  user_list: User[];
  total_count: number;
}

// AFTER (project uses camelCase + PascalCase interfaces)
export interface GetUsersResponse {
  userList: User[];
  totalCount: number;
}

Import Style Adaptation

// BEFORE (generated with relative imports)
import { User } from '../models/User';
import { validate } from '../utils/validate';

// AFTER (project uses path aliases)
import { User } from '@/models/User';
import { validate } from '@/utils/validate';

Error Handling Adaptation

// BEFORE (generated with basic try-catch)
try {
  const result = await service.findAll();
  res.json(result);
} catch (err) {
  res.status(500).json({ error: 'Internal error' });
}

// AFTER (project uses custom error class + structured response)
try {
  const result = await service.findAll();
  res.json({ success: true, data: result });
} catch (err) {
  if (err instanceof AppError) {
    res.status(err.statusCode).json({ success: false, error: err.message });
  } else {
    res.status(500).json({ success: false, error: 'Internal server error' });
  }
}

Quality Checklist

Before outputting refined code, verify:

All variable/function names match project conventions
Import paths use the correct style (relative or alias)
Error handling follows project patterns
Formatting matches project config (quotes, semicolons, indentation)
No any types where specific types are available
API contract is completely unchanged
No new features or abstractions added
File structure is unchanged

codegen-refinement