Quick Create Operator

Quickly operate project creation tasks by generating boilerplate code, configuration files, and project scaffolding from concise, high-level descriptions.

When to Use This Command

Run this command when...

• You need to rapidly scaffold a new file, module, or configuration from a brief description without detailed specifications
• Time pressure demands fast creation over thorough convention analysis
• You want a lightweight alternative to full-featured create commands for simple scaffolding tasks
• A quick prototype or proof of concept needs basic structure created immediately
• You need to generate configuration files for common tools (ESLint, Prettier, Docker) with sensible defaults

Quick Start

Copy
# .claude/commands/quick-create-operator.md
---
name: Quick Create Operator
description: Rapid creation of files and configurations from brief descriptions
command: true
---
Quick create: $ARGUMENTS

Fast-path creation:
1. Parse what to create from brief description
2. Apply sensible defaults and common patterns
3. Generate files immediately
4. Report what was created

Copy
# Invoke the command
claude "/quick-create-operator Dockerfile for Node.js 20 with pnpm"

# Expected output
# > Creating Dockerfile...
# >   Base: node:20-alpine
# >   Package manager: pnpm
# >   Multi-stage build: yes (builder + runner)
# >   Health check: included
# > Created: Dockerfile (42 lines)
# >   Stage 1: Install dependencies with pnpm
# >   Stage 2: Production runtime (119MB image)
# > Also created: .dockerignore (12 entries)

Core Concepts

Concept	Description
Brief Parsing	Extracts creation intent from minimal natural language input
Sensible Defaults	Applies industry best practices when specifics are not provided
Speed Priority	Optimizes for fast creation over exhaustive convention analysis
Common Templates	Maintains templates for frequently created files like Dockerfiles, CI configs, and configs
Minimal Output	Creates only what is explicitly requested without adding unnecessary extras

Quick Create Decision Tree
============================

  Input: "Dockerfile for Node.js 20"
       |
  [Parse Intent]
  What: Dockerfile
  Tech: Node.js 20
  Extras: none specified
       |
  [Apply Defaults]
  Alpine base (size)
  Multi-stage (security)
  Non-root user (security)
  Health check (ops)
       |
  [Generate]
  Dockerfile + .dockerignore
       |
  [Report]
  Created 2 files, 54 lines total

Configuration

Parameter	Description	Default	Example	Required
$ARGUMENTS	Brief description of what to create	none	"Dockerfile for Python 3.12"	Yes
style	Code style preference	project default	"minimal", "verbose"	No
overwrite	Overwrite existing files if they exist	false	true	No
add_comments	Include explanatory comments in generated files	true	false	No
output_dir	Directory to create files in	current directory	"config/"	No

Best Practices

1. Include the technology and version -- "Dockerfile for Node.js 20" produces better results than just "Dockerfile." Version specifics help generate accurate base images and commands.

2. Use for one-off configuration files -- Quick create excels at Dockerfiles, CI configs, linting configs, and similar files that follow well-known patterns.

3. Review and customize generated files -- Quick create uses sensible defaults but your project may need adjustments. Treat output as a strong starting point, not a final deliverable.

4. Prefer full create commands for application code -- For services, components, and modules that must match codebase conventions, use the Easy Create Executor or similar convention-aware commands.

5. Specify constraints when they matter -- "Dockerfile for Node.js 20 with pnpm, no dev dependencies in production" gives the operator constraints to apply rather than relying on defaults.

Common Issues

Defaults do not match project conventions: The quick create operator uses general best practices that may conflict with your team standards. Review generated files and adjust to match your conventions.

Overwriting existing files: Without overwrite: true, the operator refuses to replace existing files. This prevents accidental loss but may frustrate iterative creation. Use overwrite explicitly when iterating.

Missing project-specific settings: Quick create does not scan the codebase for patterns. For files that must integrate with existing configuration (e.g., ESLint extending a shared config), manual adjustments are usually needed.