# Neckr0ik Code Generator

> Generate boilerplate code for common patterns. Creates project scaffolds, CRUD operations, API clients, database models, tests. Use when you need to quickly scaffold code.

- Skill: `dvcrn/neckr0ik-code-generator` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add dvcrn/neckr0ik-code-generator`
- Raw SKILL.md: https://api.skillmd.com/api/skills/dvcrn/neckr0ik-code-generator/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Integrations & APIs
- Author: dvcrn (https://skillmd.com/u/dvcrn)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/dvcrn/neckr0ik-code-generator

---


# Code Generator

Generate production-ready boilerplate code instantly.

## What This Does

- **Project Scaffolds** — Python, Node.js, Go, Rust project structure
- **CRUD Operations** — Create, Read, Update, Delete boilerplate
- **API Clients** — REST and GraphQL client generators
- **Database Models** — SQLAlchemy, Prisma, TypeORM models
- **Test Templates** — Unit tests, integration tests, mocks
- **Config Files** — Docker, CI/CD, linting, formatting

## Quick Start

```bash
# Generate a new Python project
neckr0ik-code-generator scaffold python my-project

# Generate CRUD operations for a model
neckr0ik-code-generator crud User --fields "name,email,created_at"

# Generate an API client
neckr0ik-code-generator api-client --spec https://api.example.com/openapi.json

# Generate tests
neckr0ik-code-generator tests --source ./src --type unit
```

## Supported Languages

| Language | Scaffold | CRUD | API | Models | Tests |
|----------|----------|------|-----|--------|-------|
| Python | ✅ | ✅ | ✅ | ✅ SQLAlchemy | ✅ pytest |
| TypeScript | ✅ | ✅ | ✅ | ✅ Prisma/TypeORM | ✅ Jest |
| Go | ✅ | ✅ | ✅ | ✅ GORM | ✅ testing |
| Rust | ✅ | ✅ | ✅ | ✅ Diesel | ✅ cargo test |
| Node.js | ✅ | ✅ | ✅ | ✅ Mongoose | ✅ Jest |

## Commands

### scaffold

Create new project structure.

```bash
neckr0ik-code-generator scaffold <language> <name> [options]

Options:
  --template <name>    Template variant (api, web, cli, library)
  --features <list>    Comma-separated features (auth, database, tests, ci)
  --output <dir>       Output directory
```

### crud

Generate CRUD operations.

```bash
neckr0ik-code-generator crud <ModelName> [options]

Options:
  --fields <list>      Comma-separated field definitions (name:type)
  --language <lang>    Target language (default: python)
  --database <type>    Database type (sql, mongodb, postgresql)
  --output <dir>       Output directory
```

### api-client

Generate API client from spec.

```bash
neckr0ik-code-generator api-client [options]

Options:
  --spec <url>         OpenAPI spec URL or file
  --language <lang>    Target language (default: python)
  --output <dir>       Output directory
```

### model

Generate database model.

```bash
neckr0ik-code-generator model <ModelName> [options]

Options:
  --fields <list>      Comma-separated field definitions
  --orm <name>         ORM (sqlalchemy, prisma, typeorm, gorm)
  --migrations         Generate migration files
  --output <dir>       Output directory
```

### test

Generate test templates.

```bash
neckr0ik-code-generator test [options]

Options:
  --source <dir>       Source directory to analyze
  --type <type>        Test type (unit, integration, e2e)
  --framework <name>   Test framework (pytest, jest, testing)
  --output <dir>       Output directory
```

### config

Generate configuration files.

```bash
neckr0ik-code-generator config <type> [options]

Types:
  docker       Dockerfile and docker-compose
  ci           CI/CD pipeline (GitHub Actions, GitLab CI)
  lint         Linting config (eslint, ruff, golangci-lint)
  format       Formatting config (prettier, black, gofmt)

Options:
  --language <lang>   Target language
  --output <dir>       Output directory
```

## Generated Code Quality

- **Type-safe** — Full type annotations where supported
- **Documented** — Docstrings and comments
- **Tested** — Example tests included
- **Modern** — Latest patterns and best practices
- **Clean** — Readable, maintainable code

## Example: Python CRUD

```python
# Generated: user_crud.py

from typing import List, Optional
from sqlalchemy.orm import Session
from models import User
from schemas import UserCreate, UserUpdate

class UserCRUD:
    """CRUD operations for User model."""

    def create(self, db: Session, user: UserCreate) -> User:
        """Create a new user."""
        db_user = User(
            name=user.name,
            email=user.email,
        )
        db.add(db_user)
        db.commit()
        db.refresh(db_user)
        return db_user

    def get(self, db: Session, user_id: int) -> Optional[User]:
        """Get a user by ID."""
        return db.query(User).filter(User.id == user_id).first()

    def get_multi(self, db: Session, skip: int = 0, limit: int = 100) -> List[User]:
        """Get multiple users."""
        return db.query(User).offset(skip).limit(limit).all()

    def update(self, db: Session, user_id: int, user: UserUpdate) -> Optional[User]:
        """Update a user."""
        db_user = self.get(db, user_id)
        if db_user:
            for key, value in user.dict(exclude_unset=True).items():
                setattr(db_user, key, value)
            db.commit()
            db.refresh(db_user)
        return db_user

    def delete(self, db: Session, user_id: int) -> bool:
        """Delete a user."""
        db_user = self.get(db, user_id)
        if db_user:
            db.delete(db_user)
            db.commit()
            return True
        return False
```

## Use Cases

- **New Projects** — Start with production-ready structure
- **Rapid Prototyping** — Generate boilerplate, focus on logic
- **Code Reviews** — Generate consistent code patterns
- **Learning** — Study generated code for best practices

## Templates

Templates are stored in `references/templates/`:
- `python/api/` — Python FastAPI project
- `python/cli/` — Python CLI tool
- `typescript/api/` — Node.js Express API
- `typescript/web/` — React + TypeScript web app
- `go/api/` — Go REST API
- `rust/cli/` — Rust CLI tool

## See Also

- `references/templates/` — Code templates
- `scripts/generator.py` — Main generator