Skill Master

Overview

Analyze codebase to discover patterns and generate/update SKILL files in .claude/skills/. Supports multi-platform projects with stack-specific pattern detection.

Capabilities:

• Scan codebase for architectural patterns (ViewModel, Repository, Room, etc.)
• Compare detected patterns with existing skills
• Auto-generate SKILL files with real code examples
• Version tracking and smart updates

How the AI discovers and uses this skill

This skill triggers when user:

• Asks to analyze project for missing skills
• Requests skill generation from codebase patterns
• Wants to sync or update existing skills
• Mentions "skill discovery", "generate skills", or "skill-sync"

Detection signals:

• .claude/skills/ directory presence
• Project structure matching known patterns
• Build/config files indicating platform (see references)

Modes

Discover Mode

Analyze codebase and report missing skills.

Steps:

1. Detect platform via build/config files (see references)
2. Scan source roots for pattern indicators
3. Compare detected patterns with existing .claude/skills/
4. Output gap analysis report

Output format:

Detected Patterns: {count}
| Pattern | Files Found | Example Location |
|---------|-------------|------------------|
| {name}  | {count}     | {path}           |

Existing Skills: {count}
Missing Skills: {count}
- {skill-name}: {pattern}, {file-count} files found

Generate Mode

Create SKILL files from detected patterns.

Steps:

1. Run discovery to identify missing skills
2. For each missing skill:
   • Find 2-3 representative source files
   • Extract: imports, annotations, class structure, conventions
   • Extract rules from .ruler/*.md if present
3. Generate SKILL.md using template structure
4. Add version and source marker

Generated SKILL structure:

---
name: {pattern-name}
description: {Generated description with trigger keywords}
version: 1.0.0
---

# {Title}

## Overview
{Brief description from pattern analysis}

## File Structure
{Extracted from codebase}

## Implementation Pattern
{Real code examples - anonymized}

## Rules
### Do
{From .ruler/*.md + codebase conventions}

### Don't
{Anti-patterns found}

## File Location
{Actual paths from codebase}

Create Strategy

When target SKILL file does not exist:

1. Generate new file using template
2. Set version: 1.0.0 in frontmatter
3. Include all mandatory sections
4. Add source marker at end (see Marker Format)

Update Strategy

Marker check: Look for <!-- Generated by skill-master command at file end.

If marker present (subsequent run):

• Smart merge: preserve custom content, add missing sections
• Increment version: major (breaking) / minor (feature) / patch (fix)
• Update source list in marker

If marker absent (first run on existing file):

• Backup: SKILL.md → SKILL.md.bak
• Use backup as source, extract relevant content
• Generate fresh file with marker
• Set version: 1.0.0

Marker Format

Place at END of generated SKILL.md:

<!-- Generated by skill-master command
Version: {version}
Sources:
- path/to/source1.kt
- path/to/source2.md
- .ruler/rule-file.md
Last updated: {YYYY-MM-DD}
-->

Platform References

Read relevant reference when platform detected:

Platform	Detection Files	Reference
Android/Gradle	build.gradle, settings.gradle	references/android.md
iOS/Xcode	*.xcodeproj, Package.swift	references/ios.md
React (web)	package.json + react	references/react-web.md
React Native	package.json + react-native	references/react-native.md
Flutter/Dart	pubspec.yaml	references/flutter.md
Node.js	package.json	references/node.md
Python	pyproject.toml, requirements.txt	references/python.md
Java/JVM	pom.xml, build.gradle	references/java.md
.NET/C#	*.csproj, *.sln	references/dotnet.md
Go	go.mod	references/go.md
Rust	Cargo.toml	references/rust.md
PHP	composer.json	references/php.md
Ruby	Gemfile	references/ruby.md
Elixir	mix.exs	references/elixir.md
C/C++	CMakeLists.txt, Makefile	references/cpp.md
Unknown	-	references/generic.md

If multiple platforms detected, read multiple references.

Rules

Do

• Only extract patterns verified in codebase
• Use real code examples (anonymize business logic)
• Include trigger keywords in description
• Keep SKILL.md under 500 lines
• Reference external files for detailed content
• Preserve custom sections during updates
• Always backup before first modification

Don't

• Include secrets, tokens, or credentials
• Include business-specific logic details
• Generate placeholders without real content
• Overwrite user customizations without backup
• Create deep reference chains (max 1 level)
• Write outside .claude/skills/

Content Extraction Rules

From codebase:

• Extract: class structures, annotations, import patterns, file locations, naming conventions
• Never: hardcoded values, secrets, API keys, PII

From .ruler/*.md (if present):

• Extract: Do/Don't rules, architecture constraints, dependency rules

Output Report

After generation, print:

SKILL GENERATION REPORT

Skills Generated: {count}

{skill-name} [CREATED | UPDATED | BACKED_UP+CREATED]
├── Analyzed: {file-count} source files
├── Sources: {list of source files}
├── Rules from: {.ruler files if any}
└── Output: .claude/skills/{skill-name}/SKILL.md ({line-count} lines)

Validation:
✓ YAML frontmatter valid
✓ Description includes trigger keywords
✓ Content under 500 lines
✓ Has required sections

Safety Constraints

• Never write outside .claude/skills/
• Never delete content without backup
• Always backup before first-time modification
• Preserve user customizations
• Deterministic: same input → same output FILE:references/android.md

Android (Gradle/Kotlin)

Detection signals

• settings.gradle or settings.gradle.kts
• build.gradle or build.gradle.kts
• gradle.properties, gradle/libs.versions.toml
• gradlew, gradle/wrapper/gradle-wrapper.properties
• app/src/main/AndroidManifest.xml

Multi-module signals

• Multiple include(...) in settings.gradle*
• Multiple dirs with build.gradle* + src/
• Common roots: feature/, core/, library/, domain/, data/

Pre-generation sources

• settings.gradle* (module list)
• build.gradle* (root + modules)
• gradle/libs.versions.toml (dependencies)
• config/detekt/detekt.yml (if present)
• **/AndroidManifest.xml

Codebase scan patterns

Source roots

• */src/main/java/, */src/main/kotlin/

Layer/folder patterns (record if present)

features/, core/, common/, data/, domain/, presentation/, ui/, di/, navigation/, network/

Pattern indicators

Pattern	Detection Criteria	Skill Name
ViewModel	@HiltViewModel, ViewModel(), MVI<	viewmodel-mvi
Repository	*Repository, *RepositoryImpl	data-repository
UseCase	operator fun invoke, *UseCase	domain-usecase
Room Entity	@Entity, @PrimaryKey, @ColumnInfo	room-entity
Room DAO	@Dao, @Query, @Insert, @Update	room-dao
Migration	Migration(, @Database(version=	room-migration
Type Converter	@TypeConverter, @TypeConverters	type-converter
DTO	@SerializedName, *Request, *Response	network-dto
Compose Screen	@Composable, NavGraphBuilder.	compose-screen
Bottom Sheet	ModalBottomSheet, *BottomSheet(	bottomsheet-screen
Navigation	@Route, NavGraphBuilder., composable(	navigation-route
Hilt Module	@Module, @Provides, @Binds, @InstallIn	hilt-module
Worker	@HiltWorker, CoroutineWorker, WorkManager	worker-task
DataStore	DataStore<Preferences>, preferencesDataStore	datastore-preference
Retrofit API	@GET, @POST, @PUT, @DELETE	retrofit-api
Mapper	*.toModel(), *.toEntity(), *.toDto()	data-mapper
Interceptor	Interceptor, intercept()	network-interceptor
Paging	PagingSource, Pager(, PagingData	paging-source
Broadcast Receiver	BroadcastReceiver, onReceive(	broadcast-receiver
Android Service	: Service(), ForegroundService	android-service
Notification	NotificationCompat, NotificationChannel	notification-builder
Analytics	FirebaseAnalytics, logEvent	analytics-event
Feature Flag	RemoteConfig, FeatureFlag	feature-flag
App Widget	AppWidgetProvider, GlanceAppWidget	app-widget
Unit Test	@Test, MockK, mockk(, every {	unit-test

Mandatory output sections

Include if detected (list actual names found):

• Features inventory: dirs under feature/
• Core modules: dirs under core/, library/
• Navigation graphs: *Graph.kt, *Navigator*.kt
• Hilt modules: @Module classes, di/ contents
• Retrofit APIs: *Api.kt interfaces
• Room databases: @Database classes
• Workers: @HiltWorker classes
• Proguard: proguard-rules.pro if present

Command sources

• README/docs invoking ./gradlew
• CI workflows with Gradle commands
• Common: ./gradlew assemble, ./gradlew test, ./gradlew lint
• Only include commands present in repo

Key paths

• app/src/main/, app/src/main/res/
• app/src/main/java/, app/src/main/kotlin/
• app/src/test/, app/src/androidTest/
• library/database/migration/ (Room migrations) FILE:README.md

FILE:references/cpp.md

C/C++

Detection signals

• CMakeLists.txt
• Makefile, makefile
• *.cpp, *.c, *.h, *.hpp
• conanfile.txt, conanfile.py (Conan)
• vcpkg.json (vcpkg)

Multi-module signals

• Multiple CMakeLists.txt with add_subdirectory
• Multiple Makefile in subdirs
• lib/, src/, modules/ directories

Pre-generation sources

• CMakeLists.txt (dependencies, targets)
• conanfile.* (dependencies)
• vcpkg.json (dependencies)
• Makefile (build targets)

Codebase scan patterns

Source roots

• src/, lib/, include/

Layer/folder patterns (record if present)

core/, utils/, network/, storage/, ui/, tests/

Pattern indicators

Pattern	Detection Criteria	Skill Name
Class	class *, public:, private:	cpp-class
Header	*.h, *.hpp, #pragma once	header-file
Template	template<, typename T	cpp-template
Smart Pointer	std::unique_ptr, std::shared_ptr	smart-pointer
RAII	destructor pattern, ~*()	raii-pattern
Singleton	static *& instance()	singleton
Factory	create*(), make*()	factory-pattern
Observer	subscribe, notify, callback pattern	observer-pattern
Thread	std::thread, std::async, pthread	threading
Mutex	std::mutex, std::lock_guard	synchronization
Network	socket, asio::, boost::asio	network-cpp
Serialization	nlohmann::json, protobuf	serialization
Unit Test	TEST(, TEST_F(, gtest	gtest
Catch2 Test	TEST_CASE(, REQUIRE(	catch2-test

Mandatory output sections

Include if detected:

• Core modules: main functionality
• Libraries: internal libraries
• Headers: public API
• Tests: test organization
• Build targets: executables, libraries

Command sources

• CMakeLists.txt custom targets
• Makefile targets
• README/docs, CI
• Common: cmake, make, ctest
• Only include commands present in repo

Key paths

• src/, include/
• lib/, libs/
• tests/, test/
• build/ (out-of-source) FILE:references/dotnet.md

.NET (C#/F#)

Detection signals

• *.csproj, *.fsproj
• *.sln
• global.json
• appsettings.json
• Program.cs, Startup.cs

Multi-module signals

• Multiple *.csproj files
• Solution with multiple projects
• src/, tests/ directories with projects

Pre-generation sources

• *.csproj (dependencies, SDK)
• *.sln (project structure)
• appsettings.json (config)
• global.json (SDK version)

Codebase scan patterns

Source roots

• src/, */ (per project)

Layer/folder patterns (record if present)

Controllers/, Services/, Repositories/, Models/, Entities/, DTOs/, Middleware/, Extensions/

Pattern indicators

Pattern	Detection Criteria	Skill Name
Controller	[ApiController], ControllerBase, [HttpGet]	aspnet-controller
Service	I*Service, class *Service	dotnet-service
Repository	I*Repository, class *Repository	dotnet-repository
Entity	class *Entity, [Table], [Key]	ef-entity
DTO	class *Dto, class *Request, class *Response	dto-pattern
DbContext	: DbContext, DbSet<	ef-dbcontext
Middleware	IMiddleware, RequestDelegate	aspnet-middleware
Background Service	BackgroundService, IHostedService	background-service
MediatR Handler	IRequestHandler<, INotificationHandler<	mediatr-handler
SignalR Hub	: Hub, [HubName]	signalr-hub
Minimal API	app.MapGet(, app.MapPost(	minimal-api
gRPC Service	*.proto, : *Base	grpc-service
EF Migration	Migrations/, AddMigration	ef-migration
Unit Test	[Fact], [Theory], xUnit	xunit-test
Integration Test	WebApplicationFactory, IClassFixture	integration-test

Mandatory output sections

Include if detected:

• Controllers: API endpoints
• Services: business logic
• Repositories: data access (EF Core)
• Entities/DTOs: data models
• Middleware: request pipeline
• Background services: hosted services

Command sources

• *.csproj targets
• README/docs, CI
• Common: dotnet build, dotnet test, dotnet run
• Only include commands present in repo

Key paths

• src/*/, project directories
• tests/
• Migrations/
• Properties/ FILE:references/elixir.md

Elixir/Erlang

Detection signals

• mix.exs
• mix.lock
• config/config.exs
• lib/, test/ directories

Multi-module signals

• Umbrella app (apps/ directory)
• Multiple mix.exs in subdirs
• rel/ for releases

Pre-generation sources

• mix.exs (dependencies, config)
• config/*.exs (configuration)
• rel/config.exs (releases)

Codebase scan patterns

Source roots

• lib/, apps/*/lib/

Layer/folder patterns (record if present)

controllers/, views/, channels/, contexts/, schemas/, workers/

Pattern indicators

Pattern	Detection Criteria	Skill Name
Phoenix Controller	use *Web, :controller, def index	phoenix-controller
Phoenix LiveView	use *Web, :live_view, mount/3	phoenix-liveview
Phoenix Channel	use *Web, :channel, join/3	phoenix-channel
Ecto Schema	use Ecto.Schema, schema "	ecto-schema
Ecto Migration	use Ecto.Migration, create table	ecto-migration
Ecto Changeset	cast/4, validate_required	ecto-changeset
Context	defmodule *Context, def list_*	phoenix-context
GenServer	use GenServer, handle_call	genserver
Supervisor	use Supervisor, start_link	supervisor
Task	Task.async, Task.Supervisor	elixir-task
Oban Worker	use Oban.Worker, perform/1	oban-worker
Absinthe	use Absinthe.Schema, field :	graphql-schema
ExUnit Test	use ExUnit.Case, test "	exunit-test

Mandatory output sections

Include if detected:

• Controllers/LiveViews: HTTP/WebSocket handlers
• Contexts: business logic
• Schemas: Ecto models
• Channels: real-time handlers
• Workers: background jobs

Command sources

• mix.exs aliases
• README/docs, CI
• Common: mix deps.get, mix test, mix phx.server
• Only include commands present in repo

Key paths

• lib/*/, lib/*_web/
• priv/repo/migrations/
• test/
• config/ FILE:references/flutter.md

Flutter/Dart

Detection signals

• pubspec.yaml
• lib/main.dart
• android/, ios/, web/ directories
• .dart_tool/
• analysis_options.yaml

Multi-module signals

• melos.yaml (monorepo)
• Multiple pubspec.yaml in subdirs
• packages/ directory

Pre-generation sources

• pubspec.yaml (dependencies)
• analysis_options.yaml
• build.yaml (if using build_runner)
• lib/main.dart (entry point)

Codebase scan patterns

Source roots

• lib/, test/

Layer/folder patterns (record if present)

screens/, widgets/, models/, services/, providers/, repositories/, utils/, constants/, bloc/, cubit/

Pattern indicators

Pattern	Detection Criteria	Skill Name
Screen/Page	*Screen, *Page, extends StatefulWidget	flutter-screen
Widget	extends StatelessWidget, extends StatefulWidget	flutter-widget
BLoC	extends Bloc<, extends Cubit<	bloc-pattern
Provider	ChangeNotifier, Provider.of<, context.read<	provider-pattern
Riverpod	@riverpod, ref.watch, ConsumerWidget	riverpod-provider
GetX	GetxController, Get.put, Obx(	getx-controller
Repository	*Repository, abstract class *Repository	data-repository
Service	*Service	service-layer
Model	fromJson, toJson, @JsonSerializable	json-model
Freezed	@freezed, part '*.freezed.dart'	freezed-model
API Client	Dio, http.Client, Retrofit	api-client
Navigation	Navigator, GoRouter, auto_route	flutter-navigation
Localization	AppLocalizations, l10n, intl	flutter-l10n
Testing	testWidgets, WidgetTester, flutter_test	widget-test
Integration Test	integration_test, IntegrationTestWidgetsFlutterBinding	integration-test

Mandatory output sections

Include if detected:

• Screens inventory: dirs under screens/, pages/
• State management: BLoC, Provider, Riverpod, GetX
• Navigation setup: GoRouter, auto_route, Navigator
• DI approach: get_it, injectable, manual
• API layer: Dio, http, Retrofit
• Models: Freezed, json_serializable

Command sources

• pubspec.yaml scripts (if using melos)
• README/docs
• Common: flutter run, flutter test, flutter build
• Only include commands present in repo

Key paths

• lib/, test/
• lib/screens/, lib/widgets/
• lib/bloc/, lib/providers/
• assets/ FILE:references/generic.md

Generic/Unknown Stack

Fallback reference when no specific platform is detected.

Detection signals

• No specific build/config files found
• Mixed technology stack
• Documentation-only repository

Multi-module signals

• Multiple directories with separate concerns
• packages/, modules/, libs/ directories
• Monorepo structure without specific tooling

Pre-generation sources

• README.md (project overview)
• docs/* (documentation)
• .env.example (environment vars)
• docker-compose.yml (services)
• CI files (.github/workflows/, etc.)

Codebase scan patterns

Source roots

• src/, lib/, app/

Layer/folder patterns (record if present)

api/, core/, utils/, services/, models/, config/, scripts/

Generic pattern indicators

Pattern	Detection Criteria	Skill Name
Entry Point	main.*, index.*, app.*	entry-point
Config	config.*, settings.*	config-file
API Client	api/, client/, HTTP calls	api-client
Model	model/, types/, data structures	data-model
Service	service/, business logic	service-layer
Utility	utils/, helpers/, common/	utility-module
Test	test/, tests/, *_test.*, *.test.*	test-file
Script	scripts/, bin/	script-file
Documentation	docs/, *.md	documentation

Mandatory output sections

Include if detected:

• Project structure: main directories
• Entry points: main files
• Configuration: config files
• Dependencies: any package manager
• Build/Run commands: from README/scripts

Command sources

• README.md (look for code blocks)
• Makefile, Taskfile.yml
• scripts/ directory
• CI workflows
• Only include commands present in repo

Key paths

• src/, lib/
• docs/
• scripts/
• config/

Notes

When using this generic reference:

1. Scan for any recognizable patterns
2. Document actual project structure found
3. Extract commands from README if available
4. Note any technologies mentioned in docs
5. Keep output minimal and factual FILE:references/go.md

Go

Detection signals

• go.mod
• go.sum
• main.go
• cmd/, internal/, pkg/ directories

Multi-module signals

• go.work (workspace)
• Multiple go.mod files
• cmd/*/main.go (multiple binaries)

Pre-generation sources

• go.mod (dependencies)
• Makefile (build commands)
• config/*.yaml or *.toml

Codebase scan patterns

Source roots

• cmd/, internal/, pkg/

Layer/folder patterns (record if present)

handler/, service/, repository/, model/, middleware/, config/, util/

Pattern indicators

Pattern	Detection Criteria	Skill Name
HTTP Handler	http.Handler, http.HandlerFunc, gin.Context	http-handler
Gin Route	gin.Engine, r.GET(, r.POST(	gin-route
Echo Route	echo.Echo, e.GET(, e.POST(	echo-route
Fiber Route	fiber.App, app.Get(, app.Post(	fiber-route
gRPC Service	*.proto, pb.*Server	grpc-service
Repository	type *Repository interface, *Repository	data-repository
Service	type *Service interface, *Service	service-layer
GORM Model	gorm.Model, *gorm.DB	gorm-model
sqlx	sqlx.DB, sqlx.NamedExec	sqlx-usage
Migration	goose, golang-migrate	db-migration
Middleware	func(*Context), middleware.*	go-middleware
Worker	go func(), sync.WaitGroup, errgroup	worker-goroutine
Config	viper, envconfig, cleanenv	config-loader
Unit Test	*_test.go, func Test*(t *testing.T)	go-test
Mock	mockgen, *_mock.go	go-mock

Mandatory output sections

Include if detected:

• HTTP handlers: API endpoints
• Services: business logic
• Repositories: data access
• Models: data structures
• Middleware: request interceptors
• Migrations: database migrations

Command sources

• Makefile targets
• README/docs, CI
• Common: go build, go test, go run
• Only include commands present in repo

Key paths

• cmd/, internal/, pkg/
• api/, handler/
• migrations/
• config/ FILE:references/ios.md

iOS (Xcode/Swift)

Detection signals

• *.xcodeproj, *.xcworkspace
• Package.swift (SPM)
• Podfile, Podfile.lock (CocoaPods)
• Cartfile (Carthage)
• *.pbxproj
• Info.plist

Multi-module signals

• Multiple targets in *.xcodeproj
• Multiple Package.swift files
• Workspace with multiple projects
• Modules/, Packages/, Features/ directories

Pre-generation sources

• *.xcodeproj/project.pbxproj (target list)
• Package.swift (dependencies, targets)
• Podfile (dependencies)
• *.xcconfig (build configs)
• Info.plist files

Codebase scan patterns

Source roots

• */Sources/, */Source/
• */App/, */Core/, */Features/

Layer/folder patterns (record if present)

Models/, Views/, ViewModels/, Services/, Networking/, Utilities/, Extensions/, Coordinators/

Pattern indicators

Pattern	Detection Criteria	Skill Name
SwiftUI View	struct *: View, var body: some View	swiftui-view
UIKit VC	UIViewController, viewDidLoad()	uikit-viewcontroller
ViewModel	@Observable, ObservableObject, @Published	viewmodel-observable
Coordinator	Coordinator, *Coordinator	coordinator-pattern
Repository	*Repository, protocol *Repository	data-repository
Service	*Service, protocol *Service	service-layer
Core Data	NSManagedObject, @NSManaged, .xcdatamodeld	coredata-entity
Realm	Object, @Persisted	realm-model
Network	URLSession, Alamofire, Moya	network-client
Dependency	@Inject, Container, Swinject	di-container
Navigation	NavigationStack, NavigationPath	navigation-swiftui
Combine	Publisher, AnyPublisher, sink	combine-publisher
Async/Await	async, await, Task {	async-await
Unit Test	XCTestCase, func test*()	xctest
UI Test	XCUIApplication, XCUIElement	xcuitest

Mandatory output sections

Include if detected:

• Targets inventory: list from pbxproj
• Modules/Packages: SPM packages, Pods
• View architecture: SwiftUI vs UIKit
• State management: Combine, Observable, etc.
• Networking layer: URLSession, Alamofire, etc.
• Persistence: Core Data, Realm, UserDefaults
• DI setup: Swinject, manual injection

Command sources

• README/docs with xcodebuild commands
• fastlane/Fastfile lanes
• CI workflows (.github/workflows/, .gitlab-ci.yml)
• Common: xcodebuild test, fastlane test
• Only include commands present in repo

Key paths

• */Sources/, */Tests/
• *.xcodeproj/, *.xcworkspace/
• Pods/ (if CocoaPods)
• Packages/ (if SPM local packages) FILE:references/java.md

Java/JVM (Spring, etc.)

Detection signals

• pom.xml (Maven)
• build.gradle, build.gradle.kts (Gradle)
• settings.gradle (multi-module)
• src/main/java/, src/main/kotlin/
• application.properties, application.yml

Multi-module signals

• Multiple pom.xml with <modules>
• Multiple build.gradle with include()
• modules/, services/ directories

Pre-generation sources

• pom.xml or build.gradle* (dependencies)
• application.properties/yml (config)
• settings.gradle (modules)
• docker-compose.yml (services)

Codebase scan patterns

Source roots

• src/main/java/, src/main/kotlin/
• src/test/java/, src/test/kotlin/

Layer/folder patterns (record if present)

controller/, service/, repository/, model/, entity/, dto/, config/, exception/, util/

Pattern indicators

Pattern	Detection Criteria	Skill Name
REST Controller	@RestController, @GetMapping, @PostMapping	spring-controller
Service	@Service, class *Service	spring-service
Repository	@Repository, JpaRepository, CrudRepository	spring-repository
Entity	@Entity, @Table, @Id	jpa-entity
DTO	class *DTO, class *Request, class *Response	dto-pattern
Config	@Configuration, @Bean	spring-config
Component	@Component, @Autowired	spring-component
Security	@EnableWebSecurity, SecurityFilterChain	spring-security
Validation	@Valid, @NotNull, @Size	validation-pattern
Exception Handler	@ControllerAdvice, @ExceptionHandler	exception-handler
Scheduler	@Scheduled, @EnableScheduling	scheduled-task
Event	ApplicationEvent, @EventListener	event-listener
Flyway Migration	V*__*.sql, flyway	flyway-migration
Liquibase	changelog*.xml, liquibase	liquibase-migration
Unit Test	@Test, @SpringBootTest, MockMvc	spring-test
Integration Test	@DataJpaTest, @WebMvcTest	integration-test

Mandatory output sections

Include if detected:

• Controllers: REST endpoints
• Services: business logic
• Repositories: data access (JPA, JDBC)
• Entities/DTOs: data models
• Configuration: Spring beans, profiles
• Security: auth config

Command sources

• pom.xml plugins, build.gradle tasks
• README/docs, CI
• Common: ./mvnw, ./gradlew, mvn test, gradle test
• Only include commands present in repo

Key paths

• src/main/java/, src/main/kotlin/
• src/main/resources/
• src/test/
• db/migration/ (Flyway) FILE:references/node.md

Node.js

Detection signals

• package.json (without react/react-native)
• tsconfig.json
• node_modules/
• *.js, *.ts, *.mjs, *.cjs entry files

Multi-module signals

• pnpm-workspace.yaml, lerna.json
• nx.json, turbo.json
• Multiple package.json in subdirs
• packages/, apps/ directories

Pre-generation sources

• package.json (dependencies, scripts)
• tsconfig.json (paths, compiler options)
• .env.example (env vars)
• docker-compose.yml (services)

Codebase scan patterns

Source roots

• src/, lib/, app/

Layer/folder patterns (record if present)

controllers/, services/, models/, routes/, middleware/, utils/, config/, types/, repositories/

Pattern indicators

Pattern	Detection Criteria	Skill Name
Express Route	app.get(, app.post(, Router()	express-route
Express Middleware	(req, res, next), app.use(	express-middleware
NestJS Controller	@Controller, @Get, @Post	nestjs-controller
NestJS Service	@Injectable, @Service	nestjs-service
NestJS Module	@Module, imports:, providers:	nestjs-module
Fastify Route	fastify.get(, fastify.post(	fastify-route
GraphQL Resolver	@Resolver, @Query, @Mutation	graphql-resolver
TypeORM Entity	@Entity, @Column, @PrimaryGeneratedColumn	typeorm-entity
Prisma Model	prisma.*.create, prisma.*.findMany	prisma-usage
Mongoose Model	mongoose.Schema, mongoose.model(	mongoose-model
Sequelize Model	Model.init, DataTypes	sequelize-model
Queue Worker	Bull, BullMQ, process(	queue-worker
Cron Job	@Cron, node-cron, cron.schedule	cron-job
WebSocket	ws, socket.io, io.on(	websocket-handler
Unit Test	describe(, it(, expect(, jest	jest-test
E2E Test	supertest, request(app)	e2e-test

Mandatory output sections

Include if detected:

• Routes/controllers: API endpoints
• Services layer: business logic
• Database: ORM/ODM usage (TypeORM, Prisma, Mongoose)
• Middleware: auth, validation, error handling
• Background jobs: queues, cron jobs
• WebSocket handlers: real-time features

Command sources

• package.json scripts section
• README/docs
• CI workflows
• Common: npm run dev, npm run build, npm test
• Only include commands present in repo

Key paths

• src/, lib/
• src/routes/, src/controllers/
• src/services/, src/models/
• prisma/, migrations/ FILE:references/php.md

PHP

Detection signals

• composer.json, composer.lock
• public/index.php
• artisan (Laravel)
• spark (CodeIgniter 4)
• bin/console (Symfony)
• app/Config/App.php (CodeIgniter 4)
• ext-phalcon in composer.json (Phalcon)
• phalcon/devtools (Phalcon)

Multi-module signals

• packages/ directory
• Laravel modules (app/Modules/)
• CodeIgniter modules (app/Modules/, modules/)
• Phalcon multi-app (apps/*/)
• Multiple composer.json in subdirs

Pre-generation sources

• composer.json (dependencies)
• .env.example (env vars)
• config/*.php (Laravel/Symfony)
• routes/*.php (Laravel)
• app/Config/* (CodeIgniter 4)
• apps/*/config/ (Phalcon)

Codebase scan patterns

Source roots

• app/, src/, apps/

Layer/folder patterns (record if present)

Controllers/, Services/, Repositories/, Models/, Entities/, Http/, Providers/, Console/

Framework-specific structures

Laravel (record if present):

• app/Http/Controllers, app/Models, database/migrations
• routes/*.php, resources/views

Symfony (record if present):

• src/Controller, src/Entity, config/packages, templates

CodeIgniter 4 (record if present):

• app/Controllers, app/Models, app/Views
• app/Config/Routes.php, app/Database/Migrations

Phalcon (record if present):

• apps/*/controllers/, apps/*/Module.php
• models/, views/

Pattern indicators

Pattern	Detection Criteria	Skill Name
Laravel Controller	extends Controller, public function index	laravel-controller
Laravel Model	extends Model, protected $fillable	laravel-model
Laravel Migration	extends Migration, Schema::create	laravel-migration
Laravel Service	class *Service, app/Services/	laravel-service
Laravel Repository	*Repository, interface *Repository	laravel-repository
Laravel Job	implements ShouldQueue, dispatch(	laravel-job
Laravel Event	extends Event, event(	laravel-event
Symfony Controller	#[Route], AbstractController	symfony-controller
Symfony Service	#[AsService], services.yaml	symfony-service
Doctrine Entity	#[ORM\Entity], #[ORM\Column]	doctrine-entity
Doctrine Migration	AbstractMigration, $this->addSql	doctrine-migration
CI4 Controller	extends BaseController, app/Controllers/	ci4-controller
CI4 Model	extends Model, protected $table	ci4-model
CI4 Migration	extends Migration, $this->forge->	ci4-migration
CI4 Entity	extends Entity, app/Entities/	ci4-entity
Phalcon Controller	extends Controller, Phalcon\Mvc\Controller	phalcon-controller
Phalcon Model	extends Model, Phalcon\Mvc\Model	phalcon-model
Phalcon Migration	Phalcon\Migrations, morphTable	phalcon-migration
API Resource	extends JsonResource, toArray	api-resource
Form Request	extends FormRequest, rules()	form-request
Middleware	implements Middleware, handle(	php-middleware
Unit Test	extends TestCase, test*(), PHPUnit	phpunit-test
Feature Test	extends TestCase, $this->get(, $this->post(	feature-test

Mandatory output sections

Include if detected:

• Controllers: HTTP endpoints
• Models/Entities: data layer
• Services: business logic
• Repositories: data access
• Migrations: database changes
• Jobs/Events: async processing
• Business modules: top modules by size

Command sources

• composer.json scripts
• php artisan (Laravel)
• php spark (CodeIgniter 4)
• bin/console (Symfony)
• phalcon devtools commands
• README/docs, CI
• Only include commands present in repo

Key paths

Laravel:

• app/, routes/, database/migrations/
• resources/views/, tests/

Symfony:

• src/, config/, templates/
• migrations/, tests/

CodeIgniter 4:

• app/Controllers/, app/Models/, app/Views/
• app/Database/Migrations/, tests/

Phalcon:

• apps/*/controllers/, apps/*/models/
• apps/*/views/, migrations/ FILE:references/python.md

Python

Detection signals

• pyproject.toml
• requirements.txt, requirements-dev.txt
• Pipfile, poetry.lock
• setup.py, setup.cfg
• manage.py (Django)

Multi-module signals

• Multiple pyproject.toml in subdirs
• packages/, apps/ directories
• Django-style apps/ with apps.py

Pre-generation sources

• pyproject.toml or setup.py
• requirements*.txt, Pipfile
• tox.ini, pytest.ini
• manage.py, settings.py (Django)

Codebase scan patterns

Source roots

• src/, app/, packages/, tests/

Layer/folder patterns (record if present)

api/, routers/, views/, services/, repositories/, models/, schemas/, utils/, config/

Pattern indicators

Pattern	Detection Criteria	Skill Name
FastAPI Router	APIRouter, @router.get, @router.post	fastapi-router
FastAPI Dependency	Depends(, def get_*():	fastapi-dependency
Django View	View, APIView, def get(self, request)	django-view
Django Model	models.Model, class Meta:	django-model
Django Serializer	serializers.Serializer, ModelSerializer	drf-serializer
Flask Route	@app.route, Blueprint	flask-route
Pydantic Model	BaseModel, Field(, model_validator	pydantic-model
SQLAlchemy Model	Base, Column(, relationship(	sqlalchemy-model
Alembic Migration	alembic/versions/, op.create_table	alembic-migration
Repository	*Repository, class *Repository	data-repository
Service	*Service, class *Service	service-layer
Celery Task	@celery.task, @shared_task	celery-task
CLI Command	@click.command, typer.Typer	cli-command
Unit Test	pytest, def test_*():, unittest	pytest-test
Fixture	@pytest.fixture, conftest.py	pytest-fixture

Mandatory output sections

Include if detected:

• Routers/views: API endpoints
• Models/schemas: data models (Pydantic, SQLAlchemy, Django)
• Services: business logic layer
• Repositories: data access layer
• Migrations: Alembic, Django migrations
• Tasks: Celery, background jobs

Command sources

• pyproject.toml tool sections
• README/docs, CI
• Common: python manage.py, pytest, uvicorn, flask run
• Only include commands present in repo

Key paths

• src/, app/
• tests/
• alembic/, migrations/
• templates/, static/ (if web) FILE:references/react-native.md

React Native

Detection signals

• package.json with react-native
• metro.config.js
• app.json or app.config.js (Expo)
• android/, ios/ directories
• babel.config.js with metro preset

Multi-module signals

• Monorepo with packages/
• Multiple app.json files
• Nx workspace with React Native

Pre-generation sources

• package.json (dependencies, scripts)
• app.json or app.config.js
• metro.config.js
• babel.config.js
• tsconfig.json

Codebase scan patterns

Source roots

• src/, app/

Layer/folder patterns (record if present)

screens/, components/, navigation/, services/, hooks/, store/, api/, utils/, assets/

Pattern indicators

Pattern	Detection Criteria	Skill Name
Screen	*Screen, export function *Screen	rn-screen
Component	export function *(), StyleSheet.create	rn-component
Navigation	createNativeStackNavigator, NavigationContainer	rn-navigation
Hook	use*, export function use*()	rn-hook
Redux	createSlice, configureStore	redux-slice
Zustand	create(, useStore	zustand-store
React Query	useQuery, useMutation	react-query
Native Module	NativeModules, TurboModule	native-module
Async Storage	AsyncStorage, @react-native-async-storage	async-storage
SQLite	expo-sqlite, react-native-sqlite-storage	sqlite-storage
Push Notification	@react-native-firebase/messaging, expo-notifications	push-notification
Deep Link	Linking, useURL, expo-linking	deep-link
Animation	Animated, react-native-reanimated	rn-animation
Gesture	react-native-gesture-handler, Gesture	rn-gesture
Testing	@testing-library/react-native, render	rntl-test

Mandatory output sections

Include if detected:

• Screens inventory: dirs under screens/
• Navigation structure: stack, tab, drawer navigators
• State management: Redux, Zustand, Context
• Native modules: custom native code
• Storage layer: AsyncStorage, SQLite, MMKV
• Platform-specific: *.android.tsx, *.ios.tsx

Command sources

• package.json scripts
• README/docs
• Common: npm run android, npm run ios, npx expo start
• Only include commands present in repo

Key paths

• src/screens/, src/components/
• src/navigation/, src/store/
• android/app/, ios/*/
• assets/ FILE:references/react-web.md

React (Web)

Detection signals

• package.json with react, react-dom
• vite.config.ts, next.config.js, craco.config.js
• tsconfig.json or jsconfig.json
• src/App.tsx or src/App.jsx
• public/index.html (CRA)

Multi-module signals

• pnpm-workspace.yaml, lerna.json
• Multiple package.json in subdirs
• packages/, apps/ directories
• Nx workspace (nx.json)

Pre-generation sources

• package.json (dependencies, scripts)
• tsconfig.json (paths, compiler options)
• vite.config.*, next.config.*, webpack.config.*
• .env.example (env vars)

Codebase scan patterns

Source roots

• src/, app/, pages/

Layer/folder patterns (record if present)

components/, hooks/, services/, utils/, store/, api/, types/, contexts/, features/, layouts/

Pattern indicators

Pattern	Detection Criteria	Skill Name
Component	export function *(), export const * = with JSX	react-component
Hook	use*, export function use*()	custom-hook
Context	createContext, useContext, *Provider	react-context
Redux	createSlice, configureStore, useSelector	redux-slice
Zustand	create(, useStore	zustand-store
React Query	useQuery, useMutation, QueryClient	react-query
Form	useForm, react-hook-form, Formik	form-handling
Router	createBrowserRouter, Route, useNavigate	react-router
API Client	axios, fetch, ky	api-client
Testing	@testing-library/react, render, screen	rtl-test
Storybook	*.stories.tsx, Meta, StoryObj	storybook
Styled	styled-components, @emotion, styled(	styled-component
Tailwind	className="*", tailwind.config.js	tailwind-usage
i18n	useTranslation, i18next, t()	i18n-usage
Auth	useAuth, AuthProvider, PrivateRoute	auth-pattern

Mandatory output sections

Include if detected:

• Components inventory: dirs under components/
• Features/pages: dirs under features/, pages/
• State management: Redux, Zustand, Context
• Routing setup: React Router, Next.js pages
• API layer: axios instances, fetch wrappers
• Styling approach: CSS modules, Tailwind, styled-components
• Form handling: react-hook-form, Formik

Command sources

• package.json scripts section
• README/docs
• CI workflows
• Common: npm run dev, npm run build, npm test
• Only include commands present in repo

Key paths

• src/components/, src/hooks/
• src/pages/, src/features/
• src/store/, src/api/
• public/, dist/, build/ FILE:references/ruby.md

Ruby/Rails

Detection signals

• Gemfile
• Gemfile.lock
• config.ru
• Rakefile
• config/application.rb (Rails)

Multi-module signals

• Multiple Gemfile in subdirs
• engines/ directory (Rails engines)
• gems/ directory (monorepo)

Pre-generation sources

• Gemfile (dependencies)
• config/database.yml
• config/routes.rb (Rails)
• .env.example

Codebase scan patterns

Source roots

• app/, lib/

Layer/folder patterns (record if present)

controllers/, models/, services/, jobs/, mailers/, channels/, helpers/, concerns/

Pattern indicators

Pattern	Detection Criteria	Skill Name
Rails Controller	< ApplicationController, def index	rails-controller
Rails Model	< ApplicationRecord, has_many, belongs_to	rails-model
Rails Migration	< ActiveRecord::Migration, create_table	rails-migration
Service Object	class *Service, def call	service-object
Rails Job	< ApplicationJob, perform_later	rails-job
Mailer	< ApplicationMailer, mail(	rails-mailer
Channel	< ApplicationCable::Channel	action-cable
Serializer	< ActiveModel::Serializer, attributes	serializer
Concern	extend ActiveSupport::Concern	rails-concern
Sidekiq Worker	include Sidekiq::Worker, perform_async	sidekiq-worker
Grape API	Grape::API, resource :	grape-api
RSpec Test	RSpec.describe, it "	rspec-test
Factory	FactoryBot.define, factory :	factory-bot
Rake Task	task :, namespace :	rake-task

Mandatory output sections

Include if detected:

• Controllers: HTTP endpoints
• Models: ActiveRecord associations
• Services: business logic
• Jobs: background processing
• Migrations: database schema

Command sources

• Gemfile scripts
• Rakefile tasks
• bin/rails, bin/rake
• README/docs, CI
• Only include commands present in repo

Key paths

• app/controllers/, app/models/
• app/services/, app/jobs/
• db/migrate/
• spec/, test/
• lib/ FILE:references/rust.md

Rust

Detection signals

• Cargo.toml
• Cargo.lock
• src/main.rs or src/lib.rs
• target/ directory

Multi-module signals

• [workspace] in Cargo.toml
• Multiple Cargo.toml in subdirs
• crates/, packages/ directories

Pre-generation sources

• Cargo.toml (dependencies, features)
• build.rs (build script)
• rust-toolchain.toml (toolchain)

Codebase scan patterns

Source roots

• src/, crates/*/src/

Layer/folder patterns (record if present)

handlers/, services/, models/, db/, api/, utils/, error/, config/

Pattern indicators

Pattern	Detection Criteria	Skill Name
Axum Handler	axum::, Router, async fn handler	axum-handler
Actix Route	actix_web::, #[get], #[post]	actix-route
Rocket Route	rocket::, #[get], #[post]	rocket-route
Service	impl *Service, pub struct *Service	rust-service
Repository	*Repository, trait *Repository	rust-repository
Diesel Model	diesel::, Queryable, Insertable	diesel-model
SQLx	sqlx::, FromRow, query_as!	sqlx-model
SeaORM	sea_orm::, Entity, ActiveModel	seaorm-entity
Error Type	thiserror, anyhow, #[derive(Error)]	error-type
CLI	clap, #[derive(Parser)]	cli-app
Async Task	tokio::spawn, async fn	async-task
Trait	pub trait *, impl * for	rust-trait
Unit Test	#[cfg(test)], #[test]	rust-test
Integration Test	tests/, #[tokio::test]	integration-test

Mandatory output sections

Include if detected:

• Handlers/routes: API endpoints
• Services: business logic
• Models/entities: data structures
• Error types: custom errors
• Migrations: diesel/sqlx migrations

Command sources

• Cargo.toml scripts/aliases
• Makefile, README/docs
• Common: cargo build, cargo test, cargo run
• Only include commands present in repo

Key paths

• src/, crates/
• tests/
• migrations/
• examples/