scaffolder

Generates boilerplate code following loaded rules. Creates new components, modules, APIs, and features that automatically comply with your coding standards. Extracts patterns from rules and applies them consistently.

Zur Installation springen

Repository: diegosouzapw/awesome-omni-skill
Letzte Quellaktivität: 28. Februar 2026 um 03:54
Erkannte Sprache von SKILL.md: Englisch
Sterne: 50
Forks: 19

Installationsoptionen

Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.

Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.

Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.

npx skills add https://github.com/diegosouzapw/awesome-omni-skill --skill scaffolder

Der Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.

Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.

Quelldateien prüfen

Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.

Datei-Explorer

2 Dateien

SKILL.md

Quellanweisungen · Schreibgeschützte Vorschau

Zurück zur Suche Zurück zur Installation

artifact-tracking

Token-efficient tracking for AI orchestration. CLI-first for status updates (~50 tokens), agent fallback for complex ops (~1KB). Use when: updating task status, querying blockers, creating progress files, validating phases.

2026-03-02

ash-ai

AshAi extension guidelines for integrating AI capabilities with Ash Framework. Use when implementing vectorization/embeddings, exposing Ash actions as LLM tools, creating prompt-backed actions, or setting up MCP servers. Covers semantic search, LangChain integration, and structured outputs.

2026-03-02

ask-oracle

This skill should be used when solving hard questions, complex architectural problems, or debugging issues that benefit from GPT-5 Pro or GPT-5.1 thinking models with large file context. Use when standard Claude analysis needs deeper reasoning or extended context windows.

2026-03-02

Alle aus diesem Repository ansehen

name	scaffolder
description	Generates boilerplate code following loaded rules. Creates new components, modules, APIs, and features that automatically comply with your coding standards. Extracts patterns from rules and applies them consistently.
context:fork	true
model	sonnet
allowed-tools	read, write, glob, search, codebase_search
version	2.1
executable	.claude/skills/scaffolder/scripts/scaffold.mjs
test_suite	.claude/skills/scaffolder/scripts/test-scaffold.mjs
best_practices	["Identify target framework from manifest.yaml","Extract patterns from relevant rule files","Generate complete file structure (types, tests, etc.)","Follow project naming conventions","Include proper imports and exports","Use executable script for programmatic invocation"]
error_handling	graceful
streaming	supported
templates	["component","client-component","api","fastapi-route","test","hook","context","feature"]

Rule-Aware Scaffolder - Creates new code that automatically adheres to your project's coding standards. - Creating new React/Vue/Angular components - Adding new API endpoints or routes - Setting up new modules or packages - Generating test files for existing code - Creating data models or database schemas - Bootstrapping feature directories

Step 1: Load Rule Index

Load the rule index to discover relevant rules dynamically:

@.claude/context/rule-index.json

Step 2: Identify Target Framework and Query Index

Determine which technologies apply based on what you're scaffolding:

Component scaffolding:

Detect: React, Next.js, TypeScript
Query: index.technology_map['react'], index.technology_map['nextjs'], index.technology_map['typescript']

API Route scaffolding:

Detect: Next.js App Router or FastAPI
Query: index.technology_map['nextjs'] or index.technology_map['fastapi']

Test File scaffolding:

Detect: Jest, Cypress, Playwright, Vitest, pytest
Query: index.technology_map['jest'], index.technology_map['cypress'], etc.

Database Model scaffolding:

Detect: Prisma, SQL, database patterns
Query: index.technology_map['prisma'] or database-related rules

Step 3: Load Relevant Rules

Load only the relevant rule files from the index (progressive disclosure):

Master rules first (from .claude/rules-master/)
Library rules supplement (from .claude/rules-library/)
Load 3-5 most relevant rules, not all 1,081

Step 4: Extract Patterns from Rules

Parse the loaded rule files to extract scaffolding patterns:

From Next.js rules (TECH_STACK_NEXTJS.md or nextjs.mdc):

Server Components by default
'use client' only when needed
Place in app/ for routes, components/ for shared
Use lowercase-with-dashes for directories

From TypeScript rules:

Interfaces for object shapes
Proper return type annotations

### Component Generation Flow **Next.js Server Component**

"""User management endpoints.""" # Type hints required (per python.mdc) from typing import Annotated from uuid import UUID from fastapi import APIRouter, Depends, HTTPException, Query, status from pydantic import BaseModel, EmailStr, Field # Router with tags (per fastapi.mdc > API Design) router = APIRouter(prefix="/users", tags=["users"]) # Pydantic models (per fastapi.mdc > Components and Validation) class UserCreate(BaseModel): """Schema for creating a user.""" email: EmailStr name: str = Field(..., min_length=2, max_length=100) class UserResponse(BaseModel): """Schema for user response.""" id: UUID email: EmailStr name: str created_at: str class Config: from_attributes = True class PaginatedResponse(BaseModel): """Paginated response wrapper.""" data: list[UserResponse] total: int page: int limit: int # Dependency injection (per fastapi.mdc > Dependency Injection) async def get_db(): """Database session dependency.""" # TODO: Replace with actual database session yield None # GET endpoint with pagination (per fastapi.mdc > Performance) @router.get("", response_model=PaginatedResponse) async def list_users( db: Annotated[None, Depends(get_db)], page: Annotated[int, Query(ge=1)] = 1, limit: Annotated[int, Query(ge=1, le=100)] = 10, ) -> PaginatedResponse: """ List all users with pagination. - **page**: Page number (starting from 1) - **limit**: Items per page (max 100) """ # TODO: Replace with actual database query users: list[UserResponse] = [] total = 0 return PaginatedResponse(data=users, total=total, page=page, limit=limit) # POST endpoint with validation @router.post("", response_model=UserResponse, status_code=status.HTTP_201_CREATED) async def create_user( user_data: UserCreate, db: Annotated[None, Depends(get_db)], ) -> UserResponse: """ Create a new user. - **email**: Valid email address - **name**: User's display name (2-100 chars) """ # TODO: Replace with actual database insert # Check for existing user, create, return raise HTTPException( status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Database integration pending", ) # GET by ID endpoint @router.get("/{user_id}", response_model=UserResponse) async def get_user( user_id: UUID, db: Annotated[None, Depends(get_db)], ) -> UserResponse: """Get a specific user by ID.""" # TODO: Replace with actual database query raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail=f"User {user_id} not found", )

Template	Framework	Files Generated
`component`	Next.js/React	index.tsx, types.ts, skeleton.tsx
`client-component`	Next.js	index.tsx with 'use client'
`page`	Next.js App Router	page.tsx, loading.tsx, error.tsx
`api`	Next.js App Router	route.ts with handlers
`fastapi-route`	FastAPI	router file with endpoints
`hook`	React	Custom hook with types
`context`	React	Context provider + hook
`test`	Jest/Vitest	Test file for component
`e2e-test`	Cypress/Playwright	E2E test spec
`model`	Prisma	Schema model
`migration`	Database	Migration file

scaffolder

Installationsoptionen

Quelldateien prüfen

Step 1: Load Rule Index

Step 2: Identify Target Framework and Query Index

Step 3: Load Relevant Rules

Step 4: Extract Patterns from Rules

Step 1: Load Rule Index

Step 2: Identify Target Framework and Query Index

Step 3: Load Relevant Rules

Step 4: Extract Patterns from Rules

Step 5: Check for Template Blocks

Step 6: Generate Compliant Code

Step 7: Validate Generated Code

Feature Module Generation

scaffolder

Quellinformationen

Installationsoptionen

Quelldateien prüfen

Mehr aus diesem Repository

Step 1: Load Rule Index

Step 2: Identify Target Framework and Query Index

Step 3: Load Relevant Rules

Step 4: Extract Patterns from Rules

Mehr aus diesem Repository

Step 1: Load Rule Index

Step 2: Identify Target Framework and Query Index

Step 3: Load Relevant Rules

Step 4: Extract Patterns from Rules

Step 5: Check for Template Blocks

Step 6: Generate Compliant Code

Step 7: Validate Generated Code

Feature Module Generation