# Scaffold

> Generate a new module, component, or screen with boilerplate, tests, and wiring.

- Skill: `coreindustries/scaffold` (Agent Skill)
- Install (CLI): `npx skillmds@latest add coreindustries/scaffold`
- Raw SKILL.md: https://api.skillmd.com/api/skills/coreindustries/scaffold/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Web & Frontend
- Author: coreindustries (https://skillmd.com/u/coreindustries)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/coreindustries/scaffold

---


# /scaffold

Generate a new module, component, or screen with boilerplate, tests, and wiring.

## Usage

```
/scaffold <type> <name> [--path <path>]
```

## Arguments

- `type`: What to generate — `module`, `component`, `screen`, `endpoint`, `model`, `service`
- `name`: Name of the thing to create (PascalCase or kebab-case)
- `--path`: Override default location

## Instructions

When this skill is invoked:

### Agent Behavior

**Autonomy:**
- Read `prd/00_technology.md` to determine stack and patterns
- Follow existing code conventions (read similar files first)
- Create all related files (implementation + tests + wiring)

**Quality:**
- Match existing code style exactly
- Include type annotations and docstrings
- Create test file with basic test cases
- Wire into existing routing/exports

### Scaffold Types

#### Module (`/scaffold module <name>`)

Create a complete backend module (service + model + route + tests):

```
src/{project}/{name}/
├── __init__.py          # or index.ts
├── service.py           # Business logic
├── models.py            # Request/response schemas
└── router.py            # API route handlers

tests/unit/
└── test_{name}_service.py

tests/integration/
└── test_{name}_api.py
```

**Steps:**
1. **Read existing modules** to match patterns
2. **Create service** with CRUD operations skeleton
3. **Create models** with validation schemas
4. **Create router** with standard endpoints
5. **Create unit test** for service layer
6. **Create integration test** for API endpoints
7. **Register router** in main app

#### Component (`/scaffold component <name>`)

Create a React/UI component (web or mobile):

```
src/components/{name}/
├── {name}.tsx           # Component implementation
├── {name}.test.tsx      # Tests
└── index.ts             # Re-export
```

**Steps:**
1. **Read existing components** to match patterns
2. **Create component** with props interface
3. **Create test** with render + interaction tests
4. **Add re-export** from index
5. **Add to component barrel export** if one exists

#### Screen (`/scaffold screen <name>`)

Create a full screen/page:

**Web (Next.js):**
```
src/app/{name}/
├── page.tsx             # Page component
├── layout.tsx           # Layout (if needed)
└── loading.tsx          # Loading state
```

**Mobile (React Native):**
```
src/screens/{name}/
├── {Name}Screen.tsx     # Screen component
├── {Name}Screen.test.tsx
└── index.ts
```

**iOS (SwiftUI):**
```
Sources/{Feature}/
├── {Name}View.swift
├── {Name}ViewModel.swift
└── {Name}ViewTests.swift
```

**Android (Compose):**
```
app/src/main/java/.../feature/{name}/
├── {Name}Screen.kt
├── {Name}ViewModel.kt
└── {Name}UiState.kt

app/src/test/java/.../feature/{name}/
└── {Name}ViewModelTest.kt
```

**Steps:**
1. **Read existing screens** to match patterns
2. **Create screen component** with standard layout
3. **Create view model / state** if pattern exists
4. **Create test file**
5. **Add to navigation** / router

#### Endpoint (`/scaffold endpoint <name>`)

Create a single API endpoint:

1. **Add route handler** in appropriate router file
2. **Add request/response models** with validation
3. **Add service method** for business logic
4. **Add tests** for happy path + error cases
5. **Register route** in app

#### Model (`/scaffold model <name>`)

Create a data model / database entity:

1. **Create schema definition** (Prisma, SQLAlchemy, SwiftData, Room)
2. **Create request/response DTOs**
3. **Generate migration** if database model
4. **Add basic CRUD queries**
5. **Create test fixtures**

#### Service (`/scaffold service <name>`)

Create a service layer class/module:

1. **Create service** with dependency injection
2. **Add interface/protocol** if pattern exists
3. **Create unit tests** with mocked dependencies
4. **Wire into DI container** if applicable

### Convention Detection

Before generating, read 2-3 existing files of the same type to detect:

- File naming convention (kebab-case, PascalCase, snake_case)
- Import style (relative, absolute, aliases)
- Export pattern (default, named, barrel)
- Test naming and structure
- Documentation style

### Scaffold Checklist

- [ ] Matches existing code conventions
- [ ] Type annotations complete
- [ ] Docstrings / documentation added
- [ ] Test file created with basic cases
- [ ] Wired into app (routes, navigation, exports)
- [ ] Linting passes on new files

## Example Output

```
$ /scaffold module notifications

Reading existing modules for patterns...
  Detected: Python + FastAPI + SQLAlchemy

Creating notification module...
  src/myapp/notifications/__init__.py
  src/myapp/notifications/service.py
    - NotificationService with create, get, list, mark_read
  src/myapp/notifications/models.py
    - CreateNotificationRequest, NotificationResponse
  src/myapp/notifications/router.py
    - POST /api/v1/notifications
    - GET  /api/v1/notifications
    - GET  /api/v1/notifications/{id}
    - PUT  /api/v1/notifications/{id}/read

  tests/unit/test_notifications_service.py (6 tests)
  tests/integration/test_notifications_api.py (4 tests)

Wiring...
  Updated src/myapp/main.py — registered notifications router

Verification...
  Lint: passing
  Tests: 10/10 passing

Module 'notifications' scaffolded successfully.
```