Easy Create Executor

Execute creation of new project components including files, modules, services, and configurations with intelligent scaffolding based on existing project patterns.

When to Use This Command

Run this command when...

• You need to create a new component, service, module, or configuration file following project conventions
• You want to scaffold a complete feature structure including all required layers in one command
• A new API endpoint needs route, controller, service, model, and test files generated together
• You need to create configuration files for tools, CI/CD, or infrastructure that follow best practices
• You want to generate boilerplate code that matches the exact style and patterns of your existing codebase

Quick Start

Copy
# .claude/commands/easy-create-executor.md
---
name: Easy Create Executor
description: Create new project components with pattern-aware scaffolding
command: true
---
Create: $ARGUMENTS

1. Parse what needs to be created from arguments
2. Scan existing code for patterns and conventions
3. Generate files following detected conventions
4. Wire into project structure (imports, routes, configs)
5. Create corresponding test files

Copy
# Invoke the command
claude "/easy-create-executor React component UserProfile with tests and stories"

# Expected output
# > Detecting project conventions...
# >   Framework: React + TypeScript
# >   Component style: Functional with hooks
# >   Testing: React Testing Library + Jest
# >   Storybook: v7 with CSF3 format
# > Creating:
# >   src/components/UserProfile/UserProfile.tsx
# >   src/components/UserProfile/UserProfile.test.tsx
# >   src/components/UserProfile/UserProfile.stories.tsx
# >   src/components/UserProfile/UserProfile.module.css
# >   src/components/UserProfile/index.ts (barrel export)
# > Registered in: src/components/index.ts
# > Creation complete: 5 files created

Core Concepts

Concept	Description
Pattern Scanning	Reads existing components to learn file naming, directory structure, and code style
Type-Aware Generation	Generates different scaffolding for components, services, hooks, utilities, and configs
Convention Matching	Matches detected conventions for imports, exports, typing, and documentation style
Barrel Export	Creates and updates index files for clean import paths
Test Co-location	Places test files according to project convention (co-located or separate test directory)

Create Executor Pattern Detection
====================================

  Scan Existing Code
         |
  +------+------+------+------+
  |      |      |      |      |
  File   Code   Import Export  Test
  naming style  pattern pattern style
         |
  [Template Generation]
  Apply detected patterns to new files
         |
  +------+------+------+
  |      |      |      |
  Source  Test   Config  Barrel
  file   file   file    export

Configuration

Parameter	Description	Default	Example	Required
$ARGUMENTS	What to create with type and options	none	"React component Header"	Yes
component_type	Type of component to create	auto-detect	"service", "hook", "page"	No
include_tests	Generate test files alongside source	true	false	No
include_stories	Generate Storybook stories if Storybook is detected	true	false	No
target_dir	Directory to create the component in	convention-based	"src/features/auth"	No

Best Practices

1. Specify the component type explicitly -- "Create React component UserProfile" is clearer than "create UserProfile." The type determines the scaffolding structure.

2. Always include tests -- Keep include_tests: true to ensure every new component starts with at least a rendering test. Retrofitting tests later is more expensive.

3. Use existing components as implicit templates -- The executor scans your codebase for patterns. Ensure your existing components follow the conventions you want replicated.

4. Review generated code immediately -- Scaffolded code is a starting point, not a finished product. Review and customize the generated files before building on top of them.

5. Create one component per invocation -- Creating multiple unrelated components at once can lead to mixed conventions if the executor detects different patterns in different directories.

Common Issues

Wrong convention detected: If the codebase has mixed styles (class components and functional components), the executor may pick the wrong pattern. Specify the style explicitly or point to a reference file.

Barrel export conflicts: Updating a shared index.ts file can conflict with other developers. Coordinate barrel export updates or use auto-generated barrels as part of the build process.

Generated stories fail: Storybook configuration varies widely. Generated stories may use incorrect decorator syntax or missing providers. Verify the Storybook setup matches the detected version.