Code Generator

Code Generator

Generate complete, deployable TypeScript serverless function code from a skill name, description, and optional README content.

How It Works — Under the Hood

This skill takes a skill description (and optionally a README or source URL) and generates a complete, deployable TypeScript handler file. It uses Google's Gemini LLM to produce the code, then validates the output before returning it.

Generation Pipeline

1. Input assembly — the skill combines your slug, name, description, and optional readme_content into a structured prompt. If readme_content is provided, it's truncated to ~6000 characters to stay within token limits while preserving the most useful context.

2. Prompt engineering — the assembled context is wrapped in a system prompt that instructs the LLM to:

   • Generate a single TypeScript file following the Claw0x skill handler pattern
   • Import from ../../lib/auth, ../../lib/validation, and ../../lib/response (the shared utilities)
   • Use authMiddleware wrapper for authentication
   • Use validateInput for request body validation
   • Use successResponse / errorResponse for consistent JSON output
   • Include error handling with try/catch
   • Add JSDoc comments explaining the skill's purpose

3. LLM generation — the prompt is sent to Gemini (currently gemini-3.1-flash-lite-preview) with a temperature of 0.3 (low creativity, high consistency). The model generates the complete handler code.

4. Structural validation — the generated code is checked for:

   • Presence of required imports (authMiddleware, validateInput, etc.)
   • A default export wrapping the handler with authMiddleware
   • At least one successResponse call
   • At least one errorResponse call
   • No syntax-breaking patterns (unclosed brackets, missing semicolons)

   If validation fails, the skill returns a 422 error instead of broken code.

5. Response — the validated code is returned along with metadata (line count, whether it includes a fallback path).

What the Generated Code Looks Like

Every generated handler follows this structure:

import { VercelRequest, VercelResponse } from '@vercel/node';
import { authMiddleware } from '../../lib/auth';
import { validateInput } from '../../lib/validation';
import { successResponse, errorResponse } from '../../lib/response';

async function handler(req: VercelRequest, res: VercelResponse) {
  // Input validation
  const validation = validateInput(req.body, { /* schema */ });
  if (!validation.valid) {
    return errorResponse(res, 'Invalid input', 400, validation.errors);
  }

  // Core logic
  try {
    const result = /* ... */;
    return successResponse(res, result);
  } catch (error) {
    return errorResponse(res, 'Processing failed', 500);
  }
}

export default authMiddleware(handler);

This pattern ensures every generated skill is immediately deployable on Vercel, has authentication, input validation, and consistent error handling out of the box.

When the LLM Adds a Fallback

If the skill description suggests it wraps an external API (detected via needs_upstream_api: true or keywords like "API", "upstream", "external"), the generator includes a deterministic fallback path — a simpler implementation that runs when the external API is unavailable. This follows the same dual-layer pattern used by the humanizer skill (LLM primary + regex fallback).

Limitations

• No runtime testing — the generated code is structurally validated but not executed. It may have logical bugs that only surface at runtime.
• Single-file only — generates one handler file. If your skill needs multiple files (e.g., a separate data file or config), you'll need to add those manually.
• TypeScript only — the generator targets the Claw0x/Vercel TypeScript stack. No Python, Go, or other language support.

Prerequisites

Requires a Claw0x API key. Sign up at claw0x.com and create a key in your dashboard. Set it as an environment variable:

export CLAW0X_API_KEY="your-api-key-here"

When to Use

• User says "generate code for this skill", "create a handler for", "scaffold a serverless function"
• Agent pipeline needs to auto-generate skill implementations from descriptions
• User provides a README or description and wants working backend code
• Bootstrapping a new skill quickly before customizing the logic

Input

Output Fields

Error Codes

• 400 — Missing required input.slug or input.name
• 422 — Generated code failed structural validation
• 502 — Upstream LLM API error (not billed)

Pricing

$0.01 per successful call. Failed calls and 5xx errors are never charged.