Skip to main content
skill CX Codex

scaffold · sethgammon — Claude Code skill for project-aware file generation

scaffold studies existing files before generating new ones, then connects them to registration points the project already uses. It fits codebases with established patterns.

MIT ★ 937 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add SethGammon/Citadel
/plugin install citadel@citadel-local
Open on GitHub

What scaffold does

The skill looks for comparable files and checks naming, locations, imports, exports, types, and tests. It uses the closest example to decide which files belong in the new set and shape their contents. It avoids empty stubs and file types the project does not already use.

After generating files, scaffold updates existing registration points, such as an index.ts or route configuration, when the project uses them. It runs a typecheck and fixes failures; if no typecheck is available, it reviews syntax and imports manually. With no suitable example, it asks which file to use rather than generating from memory. The description points to /refactor for edits to existing files and /marshal for generation without a project precedent.

Provide a file type and name; a description is optional. If the target already exists, scaffold asks before overwriting it. That matters because registration files can change too, so review the full set of edits.

What it helps with

  • create a component based on existing project examples
  • generate a module with the codebase's import and export patterns
  • add a route to an existing router configuration
  • create companion tests and types following local conventions
  • connect a new file through an existing barrel export

Example prompts for the agent

  • Create a UserProfile component based on similar files in this project.
  • Add a settings route using the existing route examples.
  • Generate an auth-service service and wire it in using the project's pattern.

How to install scaffold

1Plugin marketplace

/plugin marketplace add SethGammon/Citadel
/plugin install citadel@citadel-local

This installs the whole citadel plugin with all its skills

2Skills CLI (Vercel)

npx skills add SethGammon/Citadel --skill scaffold -a claude-code

3Manually: put the files in place

~/.claude/skills/scaffold/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/scaffold/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about scaffold

How do I install scaffold in Claude Code?

First add the marketplace with /plugin marketplace add SethGammon/Citadel, then install the plugin with /plugin install citadel@citadel-local.

What does scaffold do?

It studies similar project files, generates a matching set of files, and connects them to registration points already used by the codebase.

What should I provide for scaffold to generate a file?

Give it the file type and name; a description is optional. If it cannot find a suitable example, it asks which one to follow instead of guessing.

Source text

SKILL.md · MIT
---
name: scaffold
license: MIT
description: >-
  Project-aware file generation. Reads existing codebase conventions (naming,
  structure, imports, exports, test patterns) then generates new files that
  match exactly. Wires generated files into the project's registration points.
user-invocable: true
auto-trigger: false
trigger_keywords:
  - scaffold
  - generate component
  - generate module
  - generate service
  - new component
  - new module
  - new route
  - new service
  - create component
  - stub out
  - bootstrap
---

# /scaffold — Project-Aware File Generator

## Orientation

**Use when:** Creating a new component, module, service, route, hook, domain, or utility with existing examples in the project.

**Do NOT use when:** The file has no precedent (use `/marshal` for unconstrained generation), you're modifying existing files (use `/refactor`), or the project has no conventions yet.

**Needs:** target type, name, and optional description.

## Protocol

### Step 1: IDENTIFY THE TARGET

Parse the user's request into:
- **type**: component | module | service | route | hook | domain | utility | custom
- **name**: the name the user gave (e.g., "UserProfile", "auth-service", "settings route")
- **description**: what it does, if provided (otherwise leave blank for now)

If the type is ambiguous, ask ONE clarifying question. Do not ask more than one.

### Step 2: FIND EXEMPLARS

Search the codebase for 2-3 existing files of the same type.

**Search strategy by type:**

| Type | Search Pattern | What to Look For |
|---|---|---|
| component | `**/*.tsx` in the same directory or sibling directories | Functional components with similar complexity |
| module | Same directory as where new module will live | Registration pattern, exports, config shape |
| service | `**/services/**`, `**/lib/**` | Class vs function, singleton vs factory, error handling |
| route | Router config files, `**/routes.*`, `**/pages/**` | Route definition format, lazy loading, guards |
| hook | `**/hooks/**`, `**/use*.ts` | Naming, parameter patterns, return types, cleanup |
| domain | Top-level domain/feature directories | Manifest structure, entry point, internal layout |
| utility | `**/utils/**`, `**/helpers/**` | Pure function style, type signatures, JSDoc |

**For each exemplar, extract:**
1. File naming convention (PascalCase, kebab-case, camelCase, snake_case)
2. Directory placement (co-located with component? separate `hooks/` dir?)
3. Import style (path aliases? relative? named imports? default exports?)
4. Export style (named exports? default? re-exported from barrel/index file?)
5. Internal patterns (how state is managed, how errors are handled, JSDoc or no)
6. Test co-location (`.test.ts` next to file? `__tests__/` directory? separate `tests/` tree?)
7. Types pattern (inline? separate `.types.ts`? shared types file?)

**Output a brief analysis** (3-5 lines) summarizing the conventions you found.

### Step 3: DETERMINE THE FILE SET

Based on the exemplars, determine which files to generate. Not every project
needs every file. Only generate what the project's conventions call for.

**Decision matrix:**

| File | Generate IF... |
|---|---|
| Main file | Always |
| Types file (`.types.ts`) | Project separates types into their own files (check exemplars) |
| Test file (`.test.ts`) | Project has co-located tests for this type of file |
| Barrel/index file | Project uses barrel exports AND this file's directory doesn't already have one |
| Barrel update | Project uses barrel exports AND the directory already has an index file |
| Style file (`.module.css`, `.styled.ts`) | Project uses co-located styles for this type |
| Storybook file (`.stories.tsx`) | Project has stories for this type of file |

**Do NOT generate:**
- Empty placeholder files with only a TODO comment
- Test files that only contain `describe('...', () => { it.todo('...') })`
- Types files that only re-export from elsewhere
- Any file type the project doesn't already use

### Step 4: GENERATE THE FILES

For each file in the set, generate content by adapting the closest exemplar.

**Rules:**
1. Match the exemplar's structure exactly — same section order, same patterns
2. Replace names and specific logic, keep structural patterns
3. Every generated file must be syntactically valid and importable
4. No placeholder comments (`// TODO: implement`, `// Add logic here`)
5. No empty function bodies unless the exemplar has them
6. Minimal but functional — renders something, has at least one real method, returns a typed value
7. Match the project's TypeScript strictness

Match the exemplar's props pattern, state management, utility imports, async patterns, and error handling exactly.

### Step 5: WIRE IT IN

Find every registration point the exemplars use and add the new file there.

**Common wiring points (check which ones the project uses):**

| Wiring Point | How to Find It | What to Add |
|---|---|---|
| Barrel exports | `index.ts` in the same or parent directory | `export { NewThing } from './NewThing'` |
| Route registration | Router config file (search for exemplar's route) | New route entry matching the pattern |
| Module registry | Bootstrap/registration file | New registration call |
| Navigation/sidebar | Nav config array | New nav entry if appropriate |
| Lazy loading map | Dynamic import map | New lazy import entry |
| Type unions | Discriminated unions that list all variants | New variant if this is a new "type" of thing |

**Rules:**
1. Only wire into registration points that the exemplars actually use
2. Match the exact format — same spacing, same trailing commas, same comments
3. If a registration point uses alphabetical ordering, maintain it
4. Never create new registration points — only add to existing ones

### Step 6: VERIFY

Run typecheck — every generated file must pass. Fix failures before exiting. If typecheck is unavailable, do a manual read-through for syntax and import correctness.

## Fringe Cases

- **Target directory or file already exists**: Do not silently overwrite. Confirm with the user before proceeding. Output: "A file at `{path}` already exists. Overwrite it?" and wait for confirmation.
- **Template or exemplar not found**: List the available file types in the codebase and ask which one to use as the exemplar. Never scaffold from memory if no exemplar exists.
- **Language or framework not detected**: Ask the user directly rather than guessing. One question: "What type of file should this be? (e.g., React component, Express route, utility function)"
- **Typecheck fails after generation**: Fix the issue before exiting — do not leave the user with broken generated files.
- **No wiring point found**: Note the missing registration explicitly in the exit summary rather than silently leaving the file unwired.

## Contextual Gates

**Reversibility:** Amber — creates new files and modifies registration points; `git checkout` to undo.
**Cost:** No cost actions — file generation only; no agents spawned, no confirmation needed.
**Trust:** No gates — safe at all trust levels; overwrite confirmation is in Fringe Cases.

## Quality Gates

All of these must be true before the skill exits:

- [ ] Found 2+ exemplar files of the same type in the project
- [ ] Generated files match the project's naming convention exactly
- [ ] Generated files match the project's import/export style exactly
- [ ] No placeholder comments, TODO stubs, or empty function bodies
- [ ] Every generated file is syntactically valid TypeScript/JavaScript
- [ ] Main file is wired into the project (barrel export, route, registry, etc.)
- [ ] Test file exists IF AND ONLY IF the project co-locates tests for this type
- [ ] Types file exists IF AND ONLY IF the project separates types for this type
- [ ] Typecheck passes (or manual verification if typecheck unavailable)

## Exit Protocol

Output a summary in this format:

```
SCAFFOLD COMPLETE

Created:
  - path/to/MainFile.tsx (component)
  - path/to/MainFile.test.tsx (test)
  - path/to/MainFile.types.ts (types)

Wired into:
  - path/to/index.ts (barrel export)
  - path/to/routes.ts (route registration)

Conventions matched from:
  - path/to/ExemplarA.tsx
  - path/to/ExemplarB.tsx

Typecheck: PASS
```

```
---HANDOFF---
- Scaffolded: {name} ({type})
- Created: {N} files, wired into {N} registration points
- Conventions matched from: {exemplar names}
- Reversibility: green -- new files only, delete to undo
---
```

© SethGammon · MIT · SethGammon/Citadel

Similar skills

All skills for Agent setup: memory, context, orchestration →

scaffold by other authors comes first.

scaffold codewithmukesh scaffold generates a full feature slice for .NET 10 projects: endpoint, handler, validator, DTOs, EF configuration and integration tests. CX Codex +1 3,900installs scaffold therealharpaljadeja scaffold walks an app from idea to deploy on a fixed checklist: architecture, contracts, explorer verification, frontend. CX Codex +1 256installs power-apps-code-app-scaffold official github power-apps-code-app-scaffold scaffolds a Power Apps Code App using React and TypeScript. Use it to start a project with a Power Platform connector. CX Codex +1 8,700installs svelte-scaffold davila7 svelte-scaffold is a Claude Code command that scaffolds SvelteKit projects, modules, or component libraries. Run it to create a project structure or add a feature. CX Codex +1 127installs component-scaffold-generator patricio0312rev component-scaffold-generator builds the skeleton of a React or Vue component: typed props, variants, a test file, a Storybook story and JSDoc with an example. It asks for a name and props, then writes the files. CX Codex +1 272installs typescript-scaffold Seth Hobson typescript-scaffold generates a TypeScript project skeleton on pnpm: Next.js, React with Vite, Node.js API or a library, with tests and build tooling. CX Codex +1 ★ 42,780repo stars webflow-code-component:component-scaffold webflow webflow-code-component:component-scaffold is a Claude Code skill that scaffolds Webflow Code Components with a React 18+ file and .webflow.tsx definition. It checks project dependencies before generating code. CX Codex +1 1,000installs scaffold-nextjs mblode scaffold-nextjs scaffolds a complete Next.js Turborepo monorepo with Blode UI, Ultracite, workspace hooks, and Vercel deployment. CX Codex +1 817installs

From the same set55

The whole set →
refactor Multi-file refactoring with automated Git rollback, typechecking, and test baseline verification across edits. CX Codex +1 ★ 937repo stars review This skill reviews code in five passes, covering correctness, security, performance, readability, and consistency. Use it on a file, directory, or Git diff. CX Codex +1 ★ 937repo stars schedule Schedules recurring and one-off agent runs: by default it writes a native Task Scheduler or cron entry instead of spending routine quota. CX Codex +1 ★ 937repo stars qa qa launches a real Chromium browser, clicks UI elements, tests frontend user flows, and writes a report with screenshots. CX Codex +1 ★ 937repo stars houseclean houseclean audits every attached drive for abandoned git worktrees, bloated AI-tool caches, and rebuildable build artifacts, then lays out a cleanup plan. CX Codex +1 ★ 937repo stars pr-watch pr-watch monitors pull request CI status in the terminal, inspects failure logs, applies code fixes, and prompts to merge. CX Codex +1 ★ 937repo stars ascii-diagram The ascii-diagram skill plans and renders aligned text diagrams with boxes and arrows. Use it when a diagram needs to live in Markdown, a code comment, or plain text. CX Codex +1 ★ 937repo stars triage triage — a skill for investigating GitHub issues and reviewing PRs. Reads open issues, classifies them, searches the codebase for root cause, proposes fixes with file:line references, and optionally implements them. CX Codex +1 ★ 937repo stars

Project sponsors

Companies that keep this analytics open