claude-code-starter 0.2.0 → 0.4.0

package/dist/cli.js

@@ -163,6 +163,62 @@ function detectFrameworks(packageJson, files, rootDir) {
       if (cargo.includes("axum")) add("axum");
       if (cargo.includes("rocket")) add("rocket");
     }
+    const packageSwiftPath = path.join(rootDir, "Package.swift");
+    const xcodeprojExists = files.some((f) => f.endsWith(".xcodeproj")) || files.some((f) => f.endsWith(".xcworkspace"));
+    if (fs.existsSync(packageSwiftPath)) {
+      const packageSwift = fs.readFileSync(packageSwiftPath, "utf-8").toLowerCase();
+      if (packageSwift.includes("vapor")) add("vapor");
+    }
+    if (xcodeprojExists || files.some((f) => f.endsWith(".swift"))) {
+      const srcFiles = listSourceFilesShallow(rootDir, [".swift"]);
+      const hasSwiftUI = srcFiles.some(
+        (f) => f.includes("ContentView") || f.includes("App.swift") || f.includes("@main struct")
+      );
+      const hasUIKit = srcFiles.some(
+        (f) => f.includes("ViewController") || f.includes("AppDelegate") || f.includes("SceneDelegate")
+      );
+      if (hasSwiftUI) add("swiftui");
+      if (hasUIKit) add("uikit");
+      for (const file of srcFiles.slice(0, 10)) {
+        try {
+          const content = fs.readFileSync(file, "utf-8");
+          if (content.includes("import SwiftData") || content.includes("@Model")) add("swiftdata");
+          if (content.includes("import Combine") || content.includes("PassthroughSubject"))
+            add("combine");
+        } catch {
+        }
+      }
+    }
+    const gradlePath = path.join(rootDir, "build.gradle");
+    const gradleKtsPath = path.join(rootDir, "build.gradle.kts");
+    const appGradlePath = path.join(rootDir, "app", "build.gradle");
+    const appGradleKtsPath = path.join(rootDir, "app", "build.gradle.kts");
+    let gradleContent = "";
+    for (const gPath of [gradlePath, gradleKtsPath, appGradlePath, appGradleKtsPath]) {
+      if (fs.existsSync(gPath)) {
+        gradleContent += fs.readFileSync(gPath, "utf-8").toLowerCase();
+      }
+    }
+    if (gradleContent) {
+      if (gradleContent.includes("com.android") || gradleContent.includes("android {")) {
+        if (gradleContent.includes("compose") || gradleContent.includes("androidx.compose") || gradleContent.includes("composeoptions")) {
+          add("jetpack-compose");
+        } else {
+          add("android-views");
+        }
+        if (gradleContent.includes("room") || gradleContent.includes("androidx.room")) {
+          add("room");
+        }
+        if (gradleContent.includes("hilt") || gradleContent.includes("dagger.hilt")) {
+          add("hilt");
+        }
+        if (gradleContent.includes("ktor")) {
+          add("ktor-android");
+        }
+      }
+      if (gradleContent.includes("spring")) add("spring");
+      if (gradleContent.includes("quarkus")) add("quarkus");
+    }
     return frameworks;
   }
   const allDeps = {
@@ -356,6 +412,27 @@ function hasDevDep(packageJson, dep) {
   const deps = packageJson.dependencies || {};
   return dep in devDeps || dep in deps;
 }
+function listSourceFilesShallow(rootDir, extensions) {
+  const files = [];
+  const ignoreDirs = ["node_modules", ".git", "build", "dist", "Pods", ".build", "DerivedData"];
+  function scan(dir, depth) {
+    if (depth > 2) return;
+    try {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (ignoreDirs.includes(entry.name)) continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          scan(fullPath, depth + 1);
+        } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  scan(rootDir, 0);
+  return files;
+}
 function countSourceFiles(rootDir, _languages) {
   const extensions = [
     // JavaScript/TypeScript
@@ -539,6 +616,7 @@ function generateClaudeMd(projectInfo) {
   sections.push("| `/status` | Show current task state |");
   sections.push("| `/done` | Mark current task complete |");
   sections.push("| `/analyze <area>` | Deep-dive into specific code |");
+  sections.push("| `/code-review` | Review changes for quality and security |");
   sections.push("");
   sections.push("## Common Operations");
   sections.push("");
@@ -553,6 +631,18 @@ function generateClaudeMd(projectInfo) {
   sections.push("3. **Test Before Done** - Run tests before marking complete");
   sections.push("4. **Update State** - Keep task.md current as you work");
   sections.push("5. **Match Patterns** - Follow existing code conventions");
+  sections.push("6. **TDD Workflow** - Write failing tests first, then implement");
+  sections.push("");
+  sections.push("## Quality Gates");
+  sections.push("");
+  sections.push("Enforced constraints for code quality:");
+  sections.push("");
+  sections.push("| Constraint | Limit | Action |");
+  sections.push("|------------|-------|--------|");
+  sections.push("| Lines per function | 20 max | Decompose immediately |");
+  sections.push("| Parameters per function | 3 max | Use options object |");
+  sections.push("| Lines per file | 200 max | Split by responsibility |");
+  sections.push("| Test coverage | 80% min | Add tests before merge |");
   sections.push("");
   sections.push("## Skills");
   sections.push("");
@@ -757,9 +847,16 @@ function generateSettings(stack) {
 }
 function getSkillsForStack(stack) {
   const skills = [
+    // Core methodology skills
     { name: "pattern-discovery", description: "Finding codebase patterns" },
     { name: "systematic-debugging", description: "Debugging approach" },
-    { name: "testing-methodology", description: "Testing strategy" }
+    { name: "testing-methodology", description: "Testing strategy" },
+    // Process discipline skills
+    { name: "iterative-development", description: "TDD loops until tests pass" },
+    { name: "commit-hygiene", description: "Atomic commits and PR size limits" },
+    { name: "code-deduplication", description: "Prevent semantic code duplication" },
+    { name: "simplicity-rules", description: "Code complexity constraints" },
+    { name: "security", description: "Security patterns and secrets management" }
   ];
   if (stack.frameworks.includes("nextjs")) {
     skills.push({ name: "nextjs-patterns", description: "Next.js App Router patterns" });
@@ -776,6 +873,21 @@ function getSkillsForStack(stack) {
   if (stack.frameworks.includes("prisma") || stack.frameworks.includes("drizzle")) {
     skills.push({ name: "database-patterns", description: "Database and ORM patterns" });
   }
+  if (stack.frameworks.includes("swiftui")) {
+    skills.push({ name: "swiftui-patterns", description: "SwiftUI declarative UI patterns" });
+  }
+  if (stack.frameworks.includes("uikit")) {
+    skills.push({ name: "uikit-patterns", description: "UIKit view controller patterns" });
+  }
+  if (stack.frameworks.includes("vapor")) {
+    skills.push({ name: "vapor-patterns", description: "Vapor server-side Swift patterns" });
+  }
+  if (stack.frameworks.includes("jetpack-compose")) {
+    skills.push({ name: "compose-patterns", description: "Jetpack Compose UI patterns" });
+  }
+  if (stack.frameworks.includes("android-views")) {
+    skills.push({ name: "android-views-patterns", description: "Android XML views patterns" });
+  }
   return skills;
 }
 function generateSkills(stack) {
@@ -783,6 +895,11 @@ function generateSkills(stack) {
   artifacts.push(generatePatternDiscoverySkill());
   artifacts.push(generateSystematicDebuggingSkill());
   artifacts.push(generateTestingMethodologySkill(stack));
+  artifacts.push(generateIterativeDevelopmentSkill(stack));
+  artifacts.push(generateCommitHygieneSkill());
+  artifacts.push(generateCodeDeduplicationSkill());
+  artifacts.push(generateSimplicityRulesSkill());
+  artifacts.push(generateSecuritySkill(stack));
   if (stack.frameworks.includes("nextjs")) {
     artifacts.push(generateNextJsSkill());
   }
@@ -795,6 +912,21 @@ function generateSkills(stack) {
   if (stack.frameworks.includes("nestjs")) {
     artifacts.push(generateNestJSSkill());
   }
+  if (stack.frameworks.includes("swiftui")) {
+    artifacts.push(generateSwiftUISkill());
+  }
+  if (stack.frameworks.includes("uikit")) {
+    artifacts.push(generateUIKitSkill());
+  }
+  if (stack.frameworks.includes("vapor")) {
+    artifacts.push(generateVaporSkill());
+  }
+  if (stack.frameworks.includes("jetpack-compose")) {
+    artifacts.push(generateJetpackComposeSkill());
+  }
+  if (stack.frameworks.includes("android-views")) {
+    artifacts.push(generateAndroidViewsSkill());
+  }
   return artifacts;
 }
 function generatePatternDiscoverySkill() {
@@ -1634,236 +1766,1773 @@ describe('UsersService', () => {
     isNew: true
   };
 }
-function getAgentsForStack(stack) {
-  const agents = [
-    { name: "code-reviewer", description: "Reviews code for quality and security" },
-    { name: "test-writer", description: "Generates tests for code" }
-  ];
-  if (stack.hasDocker) {
-    agents.push({ name: "docker-helper", description: "Helps with Docker and containerization" });
-  }
-  return agents;
-}
-function generateAgents(stack) {
-  const artifacts = [];
-  artifacts.push(generateCodeReviewerAgent(stack));
-  artifacts.push(generateTestWriterAgent(stack));
-  return artifacts;
-}
-function generateCodeReviewerAgent(stack) {
-  const lintCommand = getLintCommand(stack);
+function generateSwiftUISkill() {
   return {
-    type: "agent",
-    path: ".claude/agents/code-reviewer.md",
+    type: "skill",
+    path: ".claude/skills/swiftui-patterns.md",
     content: `---
-name: code-reviewer
-description: Reviews code for quality, security issues, and best practices
-tools: Read, Grep, Glob${lintCommand ? `, Bash(${lintCommand})` : ""}
-disallowedTools: Write, Edit
-model: sonnet
+name: swiftui-patterns
+description: SwiftUI declarative UI patterns and best practices
+globs:
+  - "**/*.swift"
 ---
 
-You are a senior code reviewer with expertise in security and performance.
+# SwiftUI Patterns
 
-## Code Style Reference
+## View Structure
 
-Read these files to understand project conventions:
-${stack.linter === "eslint" ? "- `eslint.config.js` or `.eslintrc.*`" : ""}
-${stack.formatter === "prettier" ? "- `.prettierrc`" : ""}
-${stack.languages.includes("typescript") ? "- `tsconfig.json`" : ""}
-${stack.languages.includes("python") ? "- `pyproject.toml` or `setup.cfg`" : ""}
+\`\`\`swift
+import SwiftUI
 
-${lintCommand ? `Run \`${lintCommand}\` to check violations programmatically.` : ""}
+struct ContentView: View {
+    @State private var count = 0
+    @StateObject private var viewModel = ContentViewModel()
 
-## Review Process
+    var body: some View {
+        VStack(spacing: 16) {
+            Text("Count: \\(count)")
+                .font(.title)
 
-1. Run \`git diff\` to identify changed files
-2. Analyze each change for:
-   - Security vulnerabilities (OWASP Top 10)
-   - Performance issues
-   - Code style violations
-   - Missing error handling
-   - Test coverage gaps
+            Button("Increment") {
+                count += 1
+            }
+            .buttonStyle(.borderedProminent)
+        }
+        .padding()
+    }
+}
 
-## Output Format
+#Preview {
+    ContentView()
+}
+\`\`\`
 
-For each finding:
+## Property Wrappers
 
-- **Critical**: Must fix before merge
-- **Warning**: Should address
-- **Suggestion**: Consider improving
+| Wrapper | Use Case |
+|---------|----------|
+| \`@State\` | Simple value types owned by view |
+| \`@Binding\` | Two-way connection to parent's state |
+| \`@StateObject\` | Reference type owned by view (create once) |
+| \`@ObservedObject\` | Reference type passed from parent |
+| \`@EnvironmentObject\` | Shared data through view hierarchy |
+| \`@Environment\` | System environment values |
 
-Include file:line references for each issue.
-`,
-    isNew: true
-  };
-}
-function generateTestWriterAgent(stack) {
-  const testCommand = getTestCommand(stack);
-  return {
-    type: "agent",
-    path: ".claude/agents/test-writer.md",
-    content: `---
-name: test-writer
-description: Generates comprehensive tests for code
-tools: Read, Grep, Glob, Write, Edit, Bash(${testCommand})
-model: sonnet
----
+## MVVM Pattern
 
-You are a testing expert who writes thorough, maintainable tests.
+\`\`\`swift
+// ViewModel
+@MainActor
+class UserViewModel: ObservableObject {
+    @Published var users: [User] = []
+    @Published var isLoading = false
+    @Published var error: Error?
 
-## Testing Framework
+    private let service: UserService
 
-This project uses: **${stack.testingFramework || "unknown"}**
+    init(service: UserService = .shared) {
+        self.service = service
+    }
 
-## Your Process
+    func fetchUsers() async {
+        isLoading = true
+        defer { isLoading = false }
 
-1. Read the code to be tested
-2. Identify test cases:
-   - Happy path scenarios
-   - Edge cases
-   - Error conditions
-   - Boundary values
-3. Write tests following project patterns
-4. Run tests to verify they pass
+        do {
+            users = try await service.getUsers()
+        } catch {
+            self.error = error
+        }
+    }
+}
 
-## Test Structure
+// View
+struct UsersView: View {
+    @StateObject private var viewModel = UserViewModel()
 
-Follow the AAA pattern:
-- **Arrange**: Set up test data
-- **Act**: Execute the code
-- **Assert**: Verify results
+    var body: some View {
+        List(viewModel.users) { user in
+            UserRow(user: user)
+        }
+        .overlay {
+            if viewModel.isLoading {
+                ProgressView()
+            }
+        }
+        .task {
+            await viewModel.fetchUsers()
+        }
+    }
+}
+\`\`\`
 
-## Guidelines
+## Navigation (iOS 16+)
+
+\`\`\`swift
+struct AppNavigation: View {
+    @State private var path = NavigationPath()
+
+    var body: some View {
+        NavigationStack(path: $path) {
+            HomeView()
+                .navigationDestination(for: User.self) { user in
+                    UserDetailView(user: user)
+                }
+                .navigationDestination(for: Settings.self) { settings in
+                    SettingsView(settings: settings)
+                }
+        }
+    }
+}
+\`\`\`
 
-- One assertion focus per test
-- Descriptive test names
-- Mock external dependencies
-- Don't test implementation details
-- Aim for behavior coverage
+## Async/Await Patterns
 
-## Run Tests
+\`\`\`swift
+// Task modifier for view lifecycle
+.task {
+    await loadData()
+}
 
-\`\`\`bash
-${testCommand}
+// Task with cancellation
+.task(id: searchText) {
+    try? await Task.sleep(for: .milliseconds(300))
+    await search(searchText)
+}
+
+// Refreshable
+.refreshable {
+    await viewModel.refresh()
+}
 \`\`\`
+
+## Best Practices
+
+1. **Keep views small** - Extract subviews for reusability
+2. **Use \`@MainActor\`** - For ViewModels updating UI
+3. **Prefer value types** - Structs over classes when possible
+4. **Use \`.task\`** - Instead of \`.onAppear\` for async work
+5. **Preview extensively** - Use #Preview for rapid iteration
 `,
     isNew: true
   };
 }
-function getLintCommand(stack) {
-  switch (stack.linter) {
-    case "eslint":
-      return `${stack.packageManager === "bun" ? "bun" : "npx"} eslint .`;
-    case "biome":
-      return `${stack.packageManager === "bun" ? "bun" : "npx"} biome check .`;
-    case "ruff":
-      return "ruff check .";
-    default:
-      return "";
-  }
-}
-function getTestCommand(stack) {
-  switch (stack.testingFramework) {
-    case "vitest":
-      return `${stack.packageManager || "npm"} ${stack.packageManager === "npm" ? "run " : ""}test`;
-    case "jest":
-      return `${stack.packageManager || "npm"} ${stack.packageManager === "npm" ? "run " : ""}test`;
-    case "bun-test":
-      return "bun test";
-    case "pytest":
-      return "pytest";
-    case "go-test":
-      return "go test ./...";
-    case "rust-test":
-      return "cargo test";
-    default:
-      return `${stack.packageManager || "npm"} test`;
-  }
-}
-function generateRules(stack) {
-  const artifacts = [];
-  if (stack.languages.includes("typescript")) {
-    artifacts.push(generateTypeScriptRules());
-  }
-  if (stack.languages.includes("python")) {
-    artifacts.push(generatePythonRules());
-  }
-  artifacts.push(generateCodeStyleRule(stack));
-  return artifacts;
-}
-function generateTypeScriptRules() {
+function generateUIKitSkill() {
   return {
-    type: "rule",
-    path: ".claude/rules/typescript.md",
+    type: "skill",
+    path: ".claude/skills/uikit-patterns.md",
     content: `---
-paths:
-  - "**/*.ts"
-  - "**/*.tsx"
+name: uikit-patterns
+description: UIKit view controller patterns and best practices
+globs:
+  - "**/*.swift"
 ---
 
-# TypeScript Rules
+# UIKit Patterns
 
-## Type Safety
+## View Controller Structure
 
-- Avoid \`any\` - use \`unknown\` and narrow types
-- Prefer interfaces for objects, types for unions/intersections
-- Use strict mode (\`strict: true\` in tsconfig)
-- Enable \`noUncheckedIndexedAccess\` for safer array access
+\`\`\`swift
+import UIKit
 
-## Patterns
+class UserViewController: UIViewController {
+    // MARK: - Properties
+    private let viewModel: UserViewModel
+    private var cancellables = Set<AnyCancellable>()
 
-\`\`\`typescript
-// Prefer
-const user: User | undefined = users.find(u => u.id === id);
-if (user) { /* use user */ }
+    // MARK: - UI Components
+    private lazy var tableView: UITableView = {
+        let table = UITableView()
+        table.translatesAutoresizingMaskIntoConstraints = false
+        table.delegate = self
+        table.dataSource = self
+        table.register(UserCell.self, forCellReuseIdentifier: UserCell.identifier)
+        return table
+    }()
 
-// Avoid
-const user = users.find(u => u.id === id) as User;
-\`\`\`
+    // MARK: - Lifecycle
+    init(viewModel: UserViewModel) {
+        self.viewModel = viewModel
+        super.init(nibName: nil, bundle: nil)
+    }
 
-## Naming
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
 
-- Interfaces: PascalCase (e.g., \`UserProfile\`)
-- Types: PascalCase (e.g., \`ApiResponse\`)
-- Functions: camelCase (e.g., \`getUserById\`)
-- Constants: SCREAMING_SNAKE_CASE for true constants
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        setupUI()
+        setupBindings()
+        viewModel.fetchUsers()
+    }
 
-## Imports
+    // MARK: - Setup
+    private func setupUI() {
+        view.backgroundColor = .systemBackground
+        view.addSubview(tableView)
+
+        NSLayoutConstraint.activate([
+            tableView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
+            tableView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            tableView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
+        ])
+    }
 
-- Group imports: external, internal, relative
-- Use path aliases when configured
-- Prefer named exports over default exports
-`,
-    isNew: true
-  };
+    private func setupBindings() {
+        viewModel.$users
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] _ in
+                self?.tableView.reloadData()
+            }
+            .store(in: &cancellables)
+    }
 }
-function generatePythonRules() {
-  return {
-    type: "rule",
-    path: ".claude/rules/python.md",
-    content: `---
-paths:
-  - "**/*.py"
----
+\`\`\`
 
-# Python Rules
+## Coordinator Pattern
 
-## Style
+\`\`\`swift
+protocol Coordinator: AnyObject {
+    var childCoordinators: [Coordinator] { get set }
+    var navigationController: UINavigationController { get set }
+    func start()
+}
 
-- Follow PEP 8
-- Use type hints for function signatures
-- Docstrings for public functions (Google style)
-- Max line length: 88 (Black default)
+class AppCoordinator: Coordinator {
+    var childCoordinators: [Coordinator] = []
+    var navigationController: UINavigationController
 
-## Patterns
+    init(navigationController: UINavigationController) {
+        self.navigationController = navigationController
+    }
 
-\`\`\`python
-# Prefer
-def get_user(user_id: int) -> User | None:
-    """Fetch user by ID.
+    func start() {
+        let vc = HomeViewController()
+        vc.coordinator = self
+        navigationController.pushViewController(vc, animated: false)
+    }
 
-    Args:
+    func showUserDetail(_ user: User) {
+        let vc = UserDetailViewController(user: user)
+        navigationController.pushViewController(vc, animated: true)
+    }
+}
+\`\`\`
+
+## Table View Cell
+
+\`\`\`swift
+class UserCell: UITableViewCell {
+    static let identifier = "UserCell"
+
+    private let nameLabel: UILabel = {
+        let label = UILabel()
+        label.font = .preferredFont(forTextStyle: .headline)
+        label.translatesAutoresizingMaskIntoConstraints = false
+        return label
+    }()
+
+    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
+        super.init(style: style, reuseIdentifier: reuseIdentifier)
+        setupUI()
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    private func setupUI() {
+        contentView.addSubview(nameLabel)
+        NSLayoutConstraint.activate([
+            nameLabel.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 16),
+            nameLabel.centerYAnchor.constraint(equalTo: contentView.centerYAnchor)
+        ])
+    }
+
+    func configure(with user: User) {
+        nameLabel.text = user.name
+    }
+}
+\`\`\`
+
+## Best Practices
+
+1. **Use Auto Layout** - Programmatic constraints over Storyboards
+2. **MARK comments** - Organize code sections
+3. **Coordinator pattern** - For navigation logic
+4. **Dependency injection** - Pass dependencies via init
+5. **Combine for bindings** - Reactive updates from ViewModel
+`,
+    isNew: true
+  };
+}
+function generateVaporSkill() {
+  return {
+    type: "skill",
+    path: ".claude/skills/vapor-patterns.md",
+    content: `---
+name: vapor-patterns
+description: Vapor server-side Swift patterns
+globs:
+  - "**/*.swift"
+  - "Package.swift"
+---
+
+# Vapor Patterns
+
+## Route Structure
+
+\`\`\`swift
+import Vapor
+
+func routes(_ app: Application) throws {
+    // Basic routes
+    app.get { req in
+        "Hello, world!"
+    }
+
+    // Route groups
+    let api = app.grouped("api", "v1")
+
+    // Controller registration
+    try api.register(collection: UserController())
+}
+\`\`\`
+
+## Controller Pattern
+
+\`\`\`swift
+import Vapor
+
+struct UserController: RouteCollection {
+    func boot(routes: RoutesBuilder) throws {
+        let users = routes.grouped("users")
+
+        users.get(use: index)
+        users.post(use: create)
+        users.group(":userID") { user in
+            user.get(use: show)
+            user.put(use: update)
+            user.delete(use: delete)
+        }
+    }
+
+    // GET /users
+    func index(req: Request) async throws -> [UserDTO] {
+        try await User.query(on: req.db).all().map { $0.toDTO() }
+    }
+
+    // POST /users
+    func create(req: Request) async throws -> UserDTO {
+        let input = try req.content.decode(CreateUserInput.self)
+        let user = User(name: input.name, email: input.email)
+        try await user.save(on: req.db)
+        return user.toDTO()
+    }
+
+    // GET /users/:userID
+    func show(req: Request) async throws -> UserDTO {
+        guard let user = try await User.find(req.parameters.get("userID"), on: req.db) else {
+            throw Abort(.notFound)
+        }
+        return user.toDTO()
+    }
+}
+\`\`\`
+
+## Fluent Models
+
+\`\`\`swift
+import Fluent
+import Vapor
+
+final class User: Model, Content {
+    static let schema = "users"
+
+    @ID(key: .id)
+    var id: UUID?
+
+    @Field(key: "name")
+    var name: String
+
+    @Field(key: "email")
+    var email: String
+
+    @Timestamp(key: "created_at", on: .create)
+    var createdAt: Date?
+
+    @Children(for: \\.$user)
+    var posts: [Post]
+
+    init() {}
+
+    init(id: UUID? = nil, name: String, email: String) {
+        self.id = id
+        self.name = name
+        self.email = email
+    }
+}
+
+// Migration
+struct CreateUser: AsyncMigration {
+    func prepare(on database: Database) async throws {
+        try await database.schema("users")
+            .id()
+            .field("name", .string, .required)
+            .field("email", .string, .required)
+            .field("created_at", .datetime)
+            .unique(on: "email")
+            .create()
+    }
+
+    func revert(on database: Database) async throws {
+        try await database.schema("users").delete()
+    }
+}
+\`\`\`
+
+## DTOs and Validation
+
+\`\`\`swift
+struct CreateUserInput: Content, Validatable {
+    var name: String
+    var email: String
+
+    static func validations(_ validations: inout Validations) {
+        validations.add("name", as: String.self, is: !.empty)
+        validations.add("email", as: String.self, is: .email)
+    }
+}
+
+struct UserDTO: Content {
+    var id: UUID?
+    var name: String
+    var email: String
+}
+
+extension User {
+    func toDTO() -> UserDTO {
+        UserDTO(id: id, name: name, email: email)
+    }
+}
+\`\`\`
+
+## Middleware
+
+\`\`\`swift
+struct AuthMiddleware: AsyncMiddleware {
+    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
+        guard let token = request.headers.bearerAuthorization?.token else {
+            throw Abort(.unauthorized)
+        }
+
+        // Validate token
+        let user = try await validateToken(token, on: request)
+        request.auth.login(user)
+
+        return try await next.respond(to: request)
+    }
+}
+\`\`\`
+
+## Testing
+
+\`\`\`swift
+@testable import App
+import XCTVapor
+
+final class UserTests: XCTestCase {
+    var app: Application!
+
+    override func setUp() async throws {
+        app = Application(.testing)
+        try configure(app)
+        try await app.autoMigrate()
+    }
+
+    override func tearDown() async throws {
+        try await app.autoRevert()
+        app.shutdown()
+    }
+
+    func testCreateUser() async throws {
+        try app.test(.POST, "api/v1/users", beforeRequest: { req in
+            try req.content.encode(CreateUserInput(name: "Test", email: "test@example.com"))
+        }, afterResponse: { res in
+            XCTAssertEqual(res.status, .ok)
+            let user = try res.content.decode(UserDTO.self)
+            XCTAssertEqual(user.name, "Test")
+        })
+    }
+}
+\`\`\`
+`,
+    isNew: true
+  };
+}
+function generateJetpackComposeSkill() {
+  return {
+    type: "skill",
+    path: ".claude/skills/compose-patterns.md",
+    content: `---
+name: compose-patterns
+description: Jetpack Compose UI patterns and best practices
+globs:
+  - "**/*.kt"
+---
+
+# Jetpack Compose Patterns
+
+## Composable Structure
+
+\`\`\`kotlin
+@Composable
+fun UserScreen(
+    viewModel: UserViewModel = hiltViewModel()
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    UserScreenContent(
+        uiState = uiState,
+        onRefresh = viewModel::refresh,
+        onUserClick = viewModel::selectUser
+    )
+}
+
+@Composable
+private fun UserScreenContent(
+    uiState: UserUiState,
+    onRefresh: () -> Unit,
+    onUserClick: (User) -> Unit
+) {
+    Scaffold(
+        topBar = {
+            TopAppBar(title = { Text("Users") })
+        }
+    ) { padding ->
+        when (uiState) {
+            is UserUiState.Loading -> LoadingIndicator()
+            is UserUiState.Success -> UserList(
+                users = uiState.users,
+                onUserClick = onUserClick,
+                modifier = Modifier.padding(padding)
+            )
+            is UserUiState.Error -> ErrorMessage(uiState.message)
+        }
+    }
+}
+\`\`\`
+
+## State Management
+
+\`\`\`kotlin
+// UI State
+sealed interface UserUiState {
+    object Loading : UserUiState
+    data class Success(val users: List<User>) : UserUiState
+    data class Error(val message: String) : UserUiState
+}
+
+// ViewModel
+@HiltViewModel
+class UserViewModel @Inject constructor(
+    private val repository: UserRepository
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow<UserUiState>(UserUiState.Loading)
+    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()
+
+    init {
+        loadUsers()
+    }
+
+    fun refresh() {
+        loadUsers()
+    }
+
+    private fun loadUsers() {
+        viewModelScope.launch {
+            _uiState.value = UserUiState.Loading
+            repository.getUsers()
+                .onSuccess { users ->
+                    _uiState.value = UserUiState.Success(users)
+                }
+                .onFailure { error ->
+                    _uiState.value = UserUiState.Error(error.message ?: "Unknown error")
+                }
+        }
+    }
+}
+\`\`\`
+
+## Reusable Components
+
+\`\`\`kotlin
+@Composable
+fun UserCard(
+    user: User,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    Card(
+        onClick = onClick,
+        modifier = modifier.fillMaxWidth()
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            AsyncImage(
+                model = user.avatarUrl,
+                contentDescription = null,
+                modifier = Modifier
+                    .size(48.dp)
+                    .clip(CircleShape)
+            )
+            Spacer(modifier = Modifier.width(16.dp))
+            Column {
+                Text(
+                    text = user.name,
+                    style = MaterialTheme.typography.titleMedium
+                )
+                Text(
+                    text = user.email,
+                    style = MaterialTheme.typography.bodySmall
+                )
+            }
+        }
+    }
+}
+\`\`\`
+
+## Navigation
+
+\`\`\`kotlin
+@Composable
+fun AppNavigation() {
+    val navController = rememberNavController()
+
+    NavHost(
+        navController = navController,
+        startDestination = "home"
+    ) {
+        composable("home") {
+            HomeScreen(
+                onUserClick = { userId ->
+                    navController.navigate("user/$userId")
+                }
+            )
+        }
+        composable(
+            route = "user/{userId}",
+            arguments = listOf(navArgument("userId") { type = NavType.StringType })
+        ) { backStackEntry ->
+            val userId = backStackEntry.arguments?.getString("userId")
+            UserDetailScreen(userId = userId)
+        }
+    }
+}
+\`\`\`
+
+## Theming
+
+\`\`\`kotlin
+@Composable
+fun AppTheme(
+    darkTheme: Boolean = isSystemInDarkTheme(),
+    content: @Composable () -> Unit
+) {
+    val colorScheme = if (darkTheme) {
+        darkColorScheme(
+            primary = Purple80,
+            secondary = PurpleGrey80
+        )
+    } else {
+        lightColorScheme(
+            primary = Purple40,
+            secondary = PurpleGrey40
+        )
+    }
+
+    MaterialTheme(
+        colorScheme = colorScheme,
+        typography = Typography,
+        content = content
+    )
+}
+\`\`\`
+
+## Best Practices
+
+1. **Stateless composables** - Pass state down, events up
+2. **Remember wisely** - Use \`remember\` for expensive calculations
+3. **Lifecycle-aware collection** - Use \`collectAsStateWithLifecycle()\`
+4. **Modifier parameter** - Always accept Modifier as last parameter
+5. **Preview annotations** - Add @Preview for rapid iteration
+`,
+    isNew: true
+  };
+}
+function generateAndroidViewsSkill() {
+  return {
+    type: "skill",
+    path: ".claude/skills/android-views-patterns.md",
+    content: `---
+name: android-views-patterns
+description: Android XML views and traditional patterns
+globs:
+  - "**/*.kt"
+  - "**/*.xml"
+---
+
+# Android Views Patterns
+
+## Activity Structure
+
+\`\`\`kotlin
+class MainActivity : AppCompatActivity() {
+
+    private lateinit var binding: ActivityMainBinding
+    private val viewModel: MainViewModel by viewModels()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivityMainBinding.inflate(layoutInflater)
+        setContentView(binding.root)
+
+        setupUI()
+        observeViewModel()
+    }
+
+    private fun setupUI() {
+        binding.recyclerView.apply {
+            layoutManager = LinearLayoutManager(this@MainActivity)
+            adapter = userAdapter
+        }
+
+        binding.swipeRefresh.setOnRefreshListener {
+            viewModel.refresh()
+        }
+    }
+
+    private fun observeViewModel() {
+        lifecycleScope.launch {
+            repeatOnLifecycle(Lifecycle.State.STARTED) {
+                viewModel.uiState.collect { state ->
+                    updateUI(state)
+                }
+            }
+        }
+    }
+
+    private fun updateUI(state: MainUiState) {
+        binding.swipeRefresh.isRefreshing = state.isLoading
+        userAdapter.submitList(state.users)
+        binding.errorText.isVisible = state.error != null
+        binding.errorText.text = state.error
+    }
+}
+\`\`\`
+
+## Fragment Pattern
+
+\`\`\`kotlin
+class UserFragment : Fragment(R.layout.fragment_user) {
+
+    private var _binding: FragmentUserBinding? = null
+    private val binding get() = _binding!!
+
+    private val viewModel: UserViewModel by viewModels()
+    private val args: UserFragmentArgs by navArgs()
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        _binding = FragmentUserBinding.bind(view)
+
+        setupUI()
+        observeViewModel()
+        viewModel.loadUser(args.userId)
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        _binding = null
+    }
+}
+\`\`\`
+
+## RecyclerView Adapter
+
+\`\`\`kotlin
+class UserAdapter(
+    private val onItemClick: (User) -> Unit
+) : ListAdapter<User, UserAdapter.ViewHolder>(UserDiffCallback()) {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val binding = ItemUserBinding.inflate(
+            LayoutInflater.from(parent.context),
+            parent,
+            false
+        )
+        return ViewHolder(binding)
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        holder.bind(getItem(position))
+    }
+
+    inner class ViewHolder(
+        private val binding: ItemUserBinding
+    ) : RecyclerView.ViewHolder(binding.root) {
+
+        init {
+            binding.root.setOnClickListener {
+                onItemClick(getItem(adapterPosition))
+            }
+        }
+
+        fun bind(user: User) {
+            binding.nameText.text = user.name
+            binding.emailText.text = user.email
+            Glide.with(binding.avatar)
+                .load(user.avatarUrl)
+                .circleCrop()
+                .into(binding.avatar)
+        }
+    }
+
+    class UserDiffCallback : DiffUtil.ItemCallback<User>() {
+        override fun areItemsTheSame(oldItem: User, newItem: User) =
+            oldItem.id == newItem.id
+
+        override fun areContentsTheSame(oldItem: User, newItem: User) =
+            oldItem == newItem
+    }
+}
+\`\`\`
+
+## XML Layout
+
+\`\`\`xml
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <com.google.android.material.appbar.MaterialToolbar
+        android:id="@+id/toolbar"
+        android:layout_width="0dp"
+        android:layout_height="?attr/actionBarSize"
+        app:title="Users"
+        app:layout_constraintTop_toTopOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent" />
+
+    <androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+        android:id="@+id/swipeRefresh"
+        android:layout_width="0dp"
+        android:layout_height="0dp"
+        app:layout_constraintTop_toBottomOf="@id/toolbar"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent">
+
+        <androidx.recyclerview.widget.RecyclerView
+            android:id="@+id/recyclerView"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+
+    </androidx.swiperefreshlayout.widget.SwipeRefreshLayout>
+
+</androidx.constraintlayout.widget.ConstraintLayout>
+\`\`\`
+
+## ViewModel with Repository
+
+\`\`\`kotlin
+@HiltViewModel
+class UserViewModel @Inject constructor(
+    private val repository: UserRepository,
+    private val savedStateHandle: SavedStateHandle
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow(UserUiState())
+    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()
+
+    fun loadUsers() {
+        viewModelScope.launch {
+            _uiState.update { it.copy(isLoading = true) }
+            try {
+                val users = repository.getUsers()
+                _uiState.update { it.copy(users = users, isLoading = false) }
+            } catch (e: Exception) {
+                _uiState.update { it.copy(error = e.message, isLoading = false) }
+            }
+        }
+    }
+}
+
+data class UserUiState(
+    val users: List<User> = emptyList(),
+    val isLoading: Boolean = false,
+    val error: String? = null
+)
+\`\`\`
+
+## Best Practices
+
+1. **View Binding** - Use over findViewById or synthetic imports
+2. **Lifecycle awareness** - Collect flows in repeatOnLifecycle
+3. **ListAdapter** - For efficient RecyclerView updates
+4. **Navigation Component** - For fragment navigation
+5. **Clean up bindings** - Set to null in onDestroyView
+`,
+    isNew: true
+  };
+}
+function generateIterativeDevelopmentSkill(stack) {
+  const testCmd = getTestCommand(stack);
+  const lintCmd = getLintCommand(stack);
+  return {
+    type: "skill",
+    path: ".claude/skills/iterative-development.md",
+    content: `---
+name: iterative-development
+description: TDD-driven iterative loops until tests pass
+globs:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.py"
+  - "**/*.go"
+---
+
+# Iterative Development (TDD Loops)
+
+Self-referential development loops where you iterate until completion criteria are met.
+
+## Core Philosophy
+
+\`\`\`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502  ITERATION > PERFECTION                                     \u2502
+\u2502  Don't aim for perfect on first try.                        \u2502
+\u2502  Let the loop refine the work.                              \u2502
+\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
+\u2502  FAILURES ARE DATA                                          \u2502
+\u2502  Failed tests, lint errors, type mismatches are signals.    \u2502
+\u2502  Use them to guide the next iteration.                      \u2502
+\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
+\u2502  CLEAR COMPLETION CRITERIA                                  \u2502
+\u2502  Define exactly what "done" looks like.                     \u2502
+\u2502  Tests passing. Coverage met. Lint clean.                   \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+\`\`\`
+
+## TDD Workflow (Mandatory)
+
+Every implementation task MUST follow this workflow:
+
+### 1. RED: Write Tests First
+\`\`\`bash
+# Write tests based on requirements
+# Run tests - they MUST FAIL
+${testCmd}
+\`\`\`
+
+### 2. GREEN: Implement Feature
+\`\`\`bash
+# Write minimum code to pass tests
+# Run tests - they MUST PASS
+${testCmd}
+\`\`\`
+
+### 3. VALIDATE: Quality Gates
+\`\`\`bash
+# Full quality check
+${lintCmd ? `${lintCmd} && ` : ""}${testCmd}
+\`\`\`
+
+## Completion Criteria Template
+
+For any implementation task, define:
+
+\`\`\`markdown
+### Completion Criteria
+- [ ] All tests passing
+- [ ] Coverage >= 80% (on new code)
+- [ ] Lint clean (no errors)
+- [ ] Type check passing
+\`\`\`
+
+## When to Use This Workflow
+
+| Task Type | Use TDD Loop? |
+|-----------|---------------|
+| New feature | \u2705 Always |
+| Bug fix | \u2705 Always (write test that reproduces bug first) |
+| Refactoring | \u2705 Always (existing tests must stay green) |
+| Spike/exploration | \u274C Skip (but document findings) |
+| Documentation | \u274C Skip |
+
+## Anti-Patterns
+
+- \u274C Writing code before tests
+- \u274C Skipping the RED phase (tests that never fail are useless)
+- \u274C Moving on when tests fail
+- \u274C Large batches (prefer small, focused iterations)
+`,
+    isNew: true
+  };
+}
+function generateCommitHygieneSkill() {
+  return {
+    type: "skill",
+    path: ".claude/skills/commit-hygiene.md",
+    content: `---
+name: commit-hygiene
+description: Atomic commits, PR size limits, commit thresholds
+globs:
+  - "**/*"
+---
+
+# Commit Hygiene
+
+Keep commits atomic, PRs reviewable, and git history clean.
+
+## Size Thresholds
+
+| Metric | \u{1F7E2} Good | \u{1F7E1} Warning | \u{1F534} Commit Now |
+|--------|---------|------------|---------------|
+| Files changed | 1-5 | 6-10 | > 10 |
+| Lines added | < 150 | 150-300 | > 300 |
+| Total changes | < 250 | 250-400 | > 400 |
+
+**Research shows:** PRs > 400 lines have 40%+ defect rates vs 15% for smaller changes.
+
+## When to Commit
+
+### Commit Triggers (Any = Commit)
+
+| Trigger | Action |
+|---------|--------|
+| Test passes | Just got a test green \u2192 commit |
+| Feature complete | Finished a function \u2192 commit |
+| Refactor done | Renamed across files \u2192 commit |
+| Bug fixed | Fixed the issue \u2192 commit |
+| Threshold hit | > 5 files or > 200 lines \u2192 commit |
+
+### Commit Immediately If
+
+- \u2705 Tests are passing after being red
+- \u2705 You're about to make a "big change"
+- \u2705 You've been coding for 30+ minutes
+- \u2705 You're about to try something risky
+- \u2705 The current state is "working"
+
+## Atomic Commit Patterns
+
+### Good Commits \u2705
+
+\`\`\`
+"Add email validation to signup form"
+- 3 files: validator.ts, signup.tsx, signup.test.ts
+- 120 lines changed
+- Single purpose: email validation
+
+"Fix null pointer in user lookup"
+- 2 files: userService.ts, userService.test.ts
+- 25 lines changed
+- Single purpose: fix one bug
+\`\`\`
+
+### Bad Commits \u274C
+
+\`\`\`
+"Add authentication, fix bugs, update styles"
+- 25 files changed, 800 lines
+- Multiple unrelated purposes
+
+"WIP" / "Updates" / "Fix stuff"
+- Unknown scope, no clear purpose
+\`\`\`
+
+## Quick Status Check
+
+Run frequently to check current state:
+
+\`\`\`bash
+# See what's changed
+git status --short
+
+# Count changes
+git diff --shortstat
+
+# Full summary
+git diff --stat HEAD
+\`\`\`
+
+## PR Size Rules
+
+| PR Size | Review Time | Quality |
+|---------|-------------|---------|
+| < 200 lines | < 30 min | High confidence |
+| 200-400 lines | 30-60 min | Good confidence |
+| 400-1000 lines | 1-2 hours | Declining quality |
+| > 1000 lines | Often skipped | Rubber-stamped |
+
+**Best practice:** If a PR will be > 400 lines, split into stacked PRs.
+`,
+    isNew: true
+  };
+}
+function generateCodeDeduplicationSkill() {
+  return {
+    type: "skill",
+    path: ".claude/skills/code-deduplication.md",
+    content: `---
+name: code-deduplication
+description: Prevent semantic code duplication with capability index
+globs:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.py"
+---
+
+# Code Deduplication
+
+Prevent semantic duplication by maintaining awareness of existing capabilities.
+
+## Core Principle
+
+\`\`\`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502  CHECK BEFORE YOU WRITE                                         \u2502
+\u2502  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2502
+\u2502  AI doesn't copy/paste - it reimplements.                       \u2502
+\u2502  The problem isn't duplicate code, it's duplicate PURPOSE.      \u2502
+\u2502                                                                 \u2502
+\u2502  Before writing ANY new function:                               \u2502
+\u2502  1. Search codebase for similar functionality                   \u2502
+\u2502  2. Check utils/, helpers/, lib/ for existing implementations   \u2502
+\u2502  3. Extend existing code if possible                            \u2502
+\u2502  4. Only create new if nothing suitable exists                  \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+\`\`\`
+
+## Before Writing New Code
+
+### Search Checklist
+
+1. **Search by purpose**: "format date", "validate email", "fetch user"
+2. **Search common locations**:
+   - \`src/utils/\` or \`lib/\`
+   - \`src/helpers/\`
+   - \`src/common/\`
+   - \`src/shared/\`
+3. **Search by function signature**: Similar inputs/outputs
+
+### Common Duplicate Candidates
+
+| Category | Look For |
+|----------|----------|
+| Date/Time | formatDate, parseDate, isExpired, addDays |
+| Validation | isEmail, isPhone, isURL, isUUID |
+| Strings | slugify, truncate, capitalize, pluralize |
+| API | fetchUser, createItem, handleError |
+| Auth | validateToken, requireAuth, getCurrentUser |
+
+## If Similar Code Exists
+
+### Option 1: Reuse directly
+\`\`\`typescript
+// Import and use existing function
+import { formatDate } from '@/utils/dates';
+\`\`\`
+
+### Option 2: Extend with options
+\`\`\`typescript
+// Add optional parameter to existing function
+export function formatDate(
+  date: Date,
+  format: string = 'short',
+  locale?: string  // NEW: added locale support
+): string { ... }
+\`\`\`
+
+### Option 3: Compose from existing
+\`\`\`typescript
+// Build on existing utilities
+export function formatDateRange(start: Date, end: Date) {
+  return \`\${formatDate(start)} - \${formatDate(end)}\`;
+}
+\`\`\`
+
+## File Header Pattern
+
+Document what each file provides:
+
+\`\`\`typescript
+/**
+ * @file User validation utilities
+ * @description Email, phone, and identity validation functions.
+ *
+ * Key exports:
+ * - isEmail(email) - Validates email format
+ * - isPhone(phone, country?) - Validates phone with country
+ * - isValidUsername(username) - Checks username rules
+ */
+\`\`\`
+
+## Anti-Patterns
+
+- \u274C Writing date formatter without checking utils/
+- \u274C Creating new API client when one exists
+- \u274C Duplicating validation logic across files
+- \u274C Copy-pasting functions between files
+- \u274C "I'll refactor later" (you won't)
+`,
+    isNew: true
+  };
+}
+function generateSimplicityRulesSkill() {
+  return {
+    type: "skill",
+    path: ".claude/skills/simplicity-rules.md",
+    content: `---
+name: simplicity-rules
+description: Enforced code complexity constraints
+globs:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.py"
+  - "**/*.go"
+---
+
+# Simplicity Rules
+
+Complexity is the enemy. Every line of code is a liability.
+
+## Enforced Limits
+
+**CRITICAL: These limits are non-negotiable. Check and enforce for EVERY file.**
+
+### Function Level
+
+| Constraint | Limit | Action if Exceeded |
+|------------|-------|-------------------|
+| Lines per function | 20 max | Decompose immediately |
+| Parameters | 3 max | Use options object |
+| Nesting levels | 2 max | Flatten with early returns |
+
+### File Level
+
+| Constraint | Limit | Action if Exceeded |
+|------------|-------|-------------------|
+| Lines per file | 200 max | Split by responsibility |
+| Functions per file | 10 max | Split into modules |
+
+### Module Level
+
+| Constraint | Limit | Reason |
+|------------|-------|--------|
+| Directory nesting | 3 levels max | Flat is better |
+| Circular deps | 0 | Never acceptable |
+
+## Enforcement Protocol
+
+**Before completing ANY file:**
+
+\`\`\`
+1. Count total lines     \u2192 if > 200, STOP and split
+2. Count functions       \u2192 if > 10, STOP and split
+3. Check function length \u2192 if any > 20 lines, decompose
+4. Check parameters      \u2192 if any > 3, refactor to options object
+\`\`\`
+
+## Violation Response
+
+When limits are exceeded:
+
+\`\`\`
+\u26A0\uFE0F FILE SIZE VIOLATION DETECTED
+
+[filename] has [X] lines (limit: 200)
+
+Splitting into:
+- [filename-a].ts - [responsibility A]
+- [filename-b].ts - [responsibility B]
+\`\`\`
+
+**Never defer refactoring.** Fix violations immediately.
+
+## Decomposition Patterns
+
+### Long Function \u2192 Multiple Functions
+
+\`\`\`typescript
+// BEFORE: 40 lines
+function processOrder(order) {
+  // validate... 10 lines
+  // calculate totals... 15 lines
+  // apply discounts... 10 lines
+  // save... 5 lines
+}
+
+// AFTER: 4 functions, each < 15 lines
+function processOrder(order) {
+  validateOrder(order);
+  const totals = calculateTotals(order);
+  const finalPrice = applyDiscounts(totals, order.coupons);
+  return saveOrder({ ...order, finalPrice });
+}
+\`\`\`
+
+### Many Parameters \u2192 Options Object
+
+\`\`\`typescript
+// BEFORE: 6 parameters
+function createUser(name, email, password, role, team, settings) { }
+
+// AFTER: 1 options object
+interface CreateUserOptions {
+  name: string;
+  email: string;
+  password: string;
+  role?: string;
+  team?: string;
+  settings?: UserSettings;
+}
+function createUser(options: CreateUserOptions) { }
+\`\`\`
+
+### Deep Nesting \u2192 Early Returns
+
+\`\`\`typescript
+// BEFORE: 4 levels deep
+function process(data) {
+  if (data) {
+    if (data.valid) {
+      if (data.items) {
+        for (const item of data.items) {
+          // actual logic here
+        }
+      }
+    }
+  }
+}
+
+// AFTER: 1 level deep
+function process(data) {
+  if (!data?.valid || !data.items) return;
+
+  for (const item of data.items) {
+    // actual logic here
+  }
+}
+\`\`\`
+
+## Anti-Patterns
+
+- \u274C God objects/files (do everything)
+- \u274C "Just one more line" (compound violations)
+- \u274C "I'll split it later" (you won't)
+- \u274C Deep inheritance hierarchies
+- \u274C Complex conditionals without extraction
+`,
+    isNew: true
+  };
+}
+function generateSecuritySkill(stack) {
+  const isJS = stack.languages.includes("typescript") || stack.languages.includes("javascript");
+  const isPython = stack.languages.includes("python");
+  return {
+    type: "skill",
+    path: ".claude/skills/security.md",
+    content: `---
+name: security
+description: Security best practices, secrets management, OWASP patterns
+globs:
+  - "**/*"
+---
+
+# Security Best Practices
+
+Security is not optional. Every project must pass security checks.
+
+## Required .gitignore Entries
+
+**NEVER commit these:**
+
+\`\`\`gitignore
+# Environment files
+.env
+.env.*
+!.env.example
+
+# Secrets and credentials
+*.pem
+*.key
+*.p12
+credentials.json
+secrets.json
+*-credentials.json
+service-account*.json
+
+# IDE secrets
+.idea/
+.vscode/settings.json
+\`\`\`
+
+## Environment Variables
+
+### Create .env.example
+
+Document required vars without values:
+
+\`\`\`bash
+# Server-side only (never expose to client)
+DATABASE_URL=
+API_SECRET_KEY=
+ANTHROPIC_API_KEY=
+
+# Client-side safe (public, non-sensitive)
+${isJS ? "VITE_API_URL=\nNEXT_PUBLIC_SITE_URL=" : "API_BASE_URL="}
+\`\`\`
+
+${isJS ? `### Frontend Exposure Rules
+
+| Framework | Client-Exposed Prefix | Server-Only |
+|-----------|----------------------|-------------|
+| Vite | \`VITE_*\` | No prefix |
+| Next.js | \`NEXT_PUBLIC_*\` | No prefix |
+| CRA | \`REACT_APP_*\` | N/A |
+
+**CRITICAL:** Never put secrets in client-exposed env vars!
+
+\`\`\`typescript
+// \u274C WRONG - Secret exposed to browser
+const key = import.meta.env.VITE_API_SECRET;
+
+// \u2705 CORRECT - Secret stays server-side
+const key = process.env.API_SECRET; // in API route only
+\`\`\`
+` : ""}
+
+### Validate at Startup
+
+${isJS ? `\`\`\`typescript
+import { z } from 'zod';
+
+const envSchema = z.object({
+  DATABASE_URL: z.string().url(),
+  API_SECRET_KEY: z.string().min(32),
+  NODE_ENV: z.enum(['development', 'production', 'test']),
+});
+
+export const env = envSchema.parse(process.env);
+\`\`\`` : ""}
+${isPython ? `\`\`\`python
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    database_url: str
+    api_secret_key: str
+    environment: str = "development"
+
+    class Config:
+        env_file = ".env"
+
+settings = Settings()
+\`\`\`` : ""}
+
+## OWASP Top 10 Checklist
+
+| Vulnerability | Prevention |
+|---------------|------------|
+| Injection (SQL, NoSQL, Command) | Parameterized queries, input validation |
+| Broken Auth | Secure session management, MFA |
+| Sensitive Data Exposure | Encryption at rest and in transit |
+| XXE | Disable external entity processing |
+| Broken Access Control | Verify permissions on every request |
+| Security Misconfiguration | Secure defaults, minimal permissions |
+| XSS | Output encoding, CSP headers |
+| Insecure Deserialization | Validate all serialized data |
+| Using Vulnerable Components | Keep dependencies updated |
+| Insufficient Logging | Log security events, monitor |
+
+## Input Validation
+
+\`\`\`
+RULE: Never trust user input. Validate everything.
+
+- Validate type, length, format, range
+- Sanitize before storage
+- Encode before output
+- Use allowlists over denylists
+\`\`\`
+
+## Secrets Detection
+
+Before committing, check for:
+
+- API keys (usually 32+ chars, specific patterns)
+- Passwords in code
+- Connection strings with credentials
+- Private keys (BEGIN RSA/EC/PRIVATE KEY)
+- Tokens (jwt, bearer, oauth)
+
+## Security Review Checklist
+
+Before PR merge:
+
+- [ ] No secrets in code or config
+- [ ] Input validation on all user data
+- [ ] Output encoding where displayed
+- [ ] Authentication checked on protected routes
+- [ ] Authorization verified for resources
+- [ ] Dependencies scanned for vulnerabilities
+- [ ] Error messages don't leak internals
+`,
+    isNew: true
+  };
+}
+function getAgentsForStack(stack) {
+  const agents = [
+    { name: "code-reviewer", description: "Reviews code for quality and security" },
+    { name: "test-writer", description: "Generates tests for code" }
+  ];
+  if (stack.hasDocker) {
+    agents.push({ name: "docker-helper", description: "Helps with Docker and containerization" });
+  }
+  return agents;
+}
+function generateAgents(stack) {
+  const artifacts = [];
+  artifacts.push(generateCodeReviewerAgent(stack));
+  artifacts.push(generateTestWriterAgent(stack));
+  return artifacts;
+}
+function generateCodeReviewerAgent(stack) {
+  const lintCommand = getLintCommand(stack);
+  return {
+    type: "agent",
+    path: ".claude/agents/code-reviewer.md",
+    content: `---
+name: code-reviewer
+description: Reviews code for quality, security issues, and best practices
+tools: Read, Grep, Glob${lintCommand ? `, Bash(${lintCommand})` : ""}
+disallowedTools: Write, Edit
+model: sonnet
+---
+
+You are a senior code reviewer with expertise in security and performance.
+
+## Code Style Reference
+
+Read these files to understand project conventions:
+${stack.linter === "eslint" ? "- `eslint.config.js` or `.eslintrc.*`" : ""}
+${stack.formatter === "prettier" ? "- `.prettierrc`" : ""}
+${stack.languages.includes("typescript") ? "- `tsconfig.json`" : ""}
+${stack.languages.includes("python") ? "- `pyproject.toml` or `setup.cfg`" : ""}
+
+${lintCommand ? `Run \`${lintCommand}\` to check violations programmatically.` : ""}
+
+## Review Process
+
+1. Run \`git diff\` to identify changed files
+2. Analyze each change for:
+   - Security vulnerabilities (OWASP Top 10)
+   - Performance issues
+   - Code style violations
+   - Missing error handling
+   - Test coverage gaps
+
+## Output Format
+
+For each finding:
+
+- **Critical**: Must fix before merge
+- **Warning**: Should address
+- **Suggestion**: Consider improving
+
+Include file:line references for each issue.
+`,
+    isNew: true
+  };
+}
+function generateTestWriterAgent(stack) {
+  const testCommand = getTestCommand(stack);
+  return {
+    type: "agent",
+    path: ".claude/agents/test-writer.md",
+    content: `---
+name: test-writer
+description: Generates comprehensive tests for code
+tools: Read, Grep, Glob, Write, Edit, Bash(${testCommand})
+model: sonnet
+---
+
+You are a testing expert who writes thorough, maintainable tests.
+
+## Testing Framework
+
+This project uses: **${stack.testingFramework || "unknown"}**
+
+## Your Process
+
+1. Read the code to be tested
+2. Identify test cases:
+   - Happy path scenarios
+   - Edge cases
+   - Error conditions
+   - Boundary values
+3. Write tests following project patterns
+4. Run tests to verify they pass
+
+## Test Structure
+
+Follow the AAA pattern:
+- **Arrange**: Set up test data
+- **Act**: Execute the code
+- **Assert**: Verify results
+
+## Guidelines
+
+- One assertion focus per test
+- Descriptive test names
+- Mock external dependencies
+- Don't test implementation details
+- Aim for behavior coverage
+
+## Run Tests
+
+\`\`\`bash
+${testCommand}
+\`\`\`
+`,
+    isNew: true
+  };
+}
+function getLintCommand(stack) {
+  switch (stack.linter) {
+    case "eslint":
+      return `${stack.packageManager === "bun" ? "bun" : "npx"} eslint .`;
+    case "biome":
+      return `${stack.packageManager === "bun" ? "bun" : "npx"} biome check .`;
+    case "ruff":
+      return "ruff check .";
+    default:
+      return "";
+  }
+}
+function getTestCommand(stack) {
+  switch (stack.testingFramework) {
+    case "vitest":
+      return `${stack.packageManager || "npm"} ${stack.packageManager === "npm" ? "run " : ""}test`;
+    case "jest":
+      return `${stack.packageManager || "npm"} ${stack.packageManager === "npm" ? "run " : ""}test`;
+    case "bun-test":
+      return "bun test";
+    case "pytest":
+      return "pytest";
+    case "go-test":
+      return "go test ./...";
+    case "rust-test":
+      return "cargo test";
+    default:
+      return `${stack.packageManager || "npm"} test`;
+  }
+}
+function generateRules(stack) {
+  const artifacts = [];
+  if (stack.languages.includes("typescript")) {
+    artifacts.push(generateTypeScriptRules());
+  }
+  if (stack.languages.includes("python")) {
+    artifacts.push(generatePythonRules());
+  }
+  artifacts.push(generateCodeStyleRule(stack));
+  return artifacts;
+}
+function generateTypeScriptRules() {
+  return {
+    type: "rule",
+    path: ".claude/rules/typescript.md",
+    content: `---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+---
+
+# TypeScript Rules
+
+## Type Safety
+
+- Avoid \`any\` - use \`unknown\` and narrow types
+- Prefer interfaces for objects, types for unions/intersections
+- Use strict mode (\`strict: true\` in tsconfig)
+- Enable \`noUncheckedIndexedAccess\` for safer array access
+
+## Patterns
+
+\`\`\`typescript
+// Prefer
+const user: User | undefined = users.find(u => u.id === id);
+if (user) { /* use user */ }
+
+// Avoid
+const user = users.find(u => u.id === id) as User;
+\`\`\`
+
+## Naming
+
+- Interfaces: PascalCase (e.g., \`UserProfile\`)
+- Types: PascalCase (e.g., \`ApiResponse\`)
+- Functions: camelCase (e.g., \`getUserById\`)
+- Constants: SCREAMING_SNAKE_CASE for true constants
+
+## Imports
+
+- Group imports: external, internal, relative
+- Use path aliases when configured
+- Prefer named exports over default exports
+`,
+    isNew: true
+  };
+}
+function generatePythonRules() {
+  return {
+    type: "rule",
+    path: ".claude/rules/python.md",
+    content: `---
+paths:
+  - "**/*.py"
+---
+
+# Python Rules
+
+## Style
+
+- Follow PEP 8
+- Use type hints for function signatures
+- Docstrings for public functions (Google style)
+- Max line length: 88 (Black default)
+
+## Patterns
+
+\`\`\`python
+# Prefer
+def get_user(user_id: int) -> User | None:
+    """Fetch user by ID.
+
+    Args:
         user_id: The user's unique identifier.
 
     Returns:
@@ -1948,7 +3617,8 @@ function generateCommands() {
     generateTaskCommand(),
     generateStatusCommand(),
     generateDoneCommand(),
-    generateAnalyzeCommand()
+    generateAnalyzeCommand(),
+    generateCodeReviewCommand()
   ];
 }
 function generateTaskCommand() {
@@ -2092,6 +3762,71 @@ Any improvements or concerns noted.
     isNew: true
   };
 }
+function generateCodeReviewCommand() {
+  return {
+    type: "command",
+    path: ".claude/commands/code-review.md",
+    content: `---
+allowed-tools: Read, Glob, Grep, Bash(git diff), Bash(git status), Bash(git log)
+description: Review code changes for quality, security, and best practices
+---
+
+# Code Review
+
+## Changes to Review
+
+!git diff --stat HEAD~1 2>/dev/null || git diff --stat
+
+## Review Process
+
+Analyze all changes for:
+
+### 1. Security (Critical)
+- [ ] No secrets/credentials in code
+- [ ] Input validation present
+- [ ] Output encoding where needed
+- [ ] Auth/authz checks on protected routes
+
+### 2. Quality
+- [ ] Functions \u2264 20 lines
+- [ ] Files \u2264 200 lines
+- [ ] No code duplication
+- [ ] Clear naming
+- [ ] Proper error handling
+
+### 3. Testing
+- [ ] Tests exist for new code
+- [ ] Edge cases covered
+- [ ] Tests are meaningful (not just for coverage)
+
+### 4. Style
+- [ ] Matches existing patterns
+- [ ] Consistent formatting
+- [ ] No commented-out code
+
+## Output Format
+
+For each finding, include file:line reference:
+
+### Critical (Must Fix)
+Issues that block merge
+
+### Warning (Should Fix)
+Issues that should be addressed
+
+### Suggestion (Consider)
+Optional improvements
+
+## Summary
+
+Provide:
+1. Overall assessment (Ready / Changes Needed / Not Ready)
+2. Count of findings by severity
+3. Top priorities to address
+`,
+    isNew: true
+  };
+}
 function formatLanguage(lang) {
   const names = {
     typescript: "TypeScript",
@@ -2111,6 +3846,7 @@ function formatLanguage(lang) {
 }
 function formatFramework(fw) {
   const names = {
+    // JavaScript/TypeScript Frontend
     nextjs: "Next.js",
     react: "React",
     vue: "Vue.js",
@@ -2122,30 +3858,50 @@ function formatFramework(fw) {
     remix: "Remix",
     gatsby: "Gatsby",
     solid: "Solid.js",
+    // JavaScript/TypeScript Backend
     express: "Express",
     nestjs: "NestJS",
     fastify: "Fastify",
     hono: "Hono",
     elysia: "Elysia",
     koa: "Koa",
+    // Python
     fastapi: "FastAPI",
     django: "Django",
     flask: "Flask",
     starlette: "Starlette",
+    // Go
     gin: "Gin",
     echo: "Echo",
     fiber: "Fiber",
+    // Rust
     actix: "Actix",
     axum: "Axum",
     rocket: "Rocket",
+    // Ruby
     rails: "Rails",
     sinatra: "Sinatra",
+    // Java/Kotlin
     spring: "Spring",
     quarkus: "Quarkus",
+    // Android
+    "jetpack-compose": "Jetpack Compose",
+    "android-views": "Android Views",
+    room: "Room",
+    hilt: "Hilt",
+    "ktor-android": "Ktor",
+    // Swift/iOS
+    swiftui: "SwiftUI",
+    uikit: "UIKit",
+    vapor: "Vapor",
+    swiftdata: "SwiftData",
+    combine: "Combine",
+    // CSS/UI
     tailwind: "Tailwind CSS",
     shadcn: "shadcn/ui",
     chakra: "Chakra UI",
     mui: "Material UI",
+    // Database/ORM
     prisma: "Prisma",
     drizzle: "Drizzle",
     typeorm: "TypeORM",
@@ -2203,15 +3959,14 @@ ${pc.bold("MORE INFO")}
 `);
 }
 function showBanner() {
-  console.log(pc.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
-  console.log(pc.cyan(`\u2551   Claude Code Starter v${VERSION.padEnd(24)}\u2551`));
-  console.log(pc.cyan("\u2551   Intelligent AI-Assisted Development Setup     \u2551"));
-  console.log(pc.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  console.log();
+  console.log(pc.bold("Claude Code Starter") + pc.gray(` v${VERSION}`));
+  console.log(pc.gray("Intelligent AI-Assisted Development Setup"));
   console.log();
 }
 function showTechStack(projectInfo, verbose) {
   const { techStack } = projectInfo;
-  console.log(pc.blue("\u{1F4CA} Tech Stack Analysis"));
+  console.log(pc.bold("Tech Stack"));
   console.log();
   if (techStack.primaryLanguage) {
     console.log(`  ${pc.bold("Language:")} ${formatLanguage2(techStack.primaryLanguage)}`);
@@ -2251,7 +4006,7 @@ async function promptNewProject(args) {
   if (!args.interactive) {
     return null;
   }
-  console.log(pc.yellow("\u{1F195} New project detected - let's set it up!"));
+  console.log(pc.yellow("New project detected - let's set it up!"));
   console.log();
   const response = await prompts([
     {
@@ -2441,7 +4196,7 @@ async function main() {
   }
   showBanner();
   const projectDir = process.cwd();
-  console.log(pc.blue("\u{1F50D} Analyzing repository..."));
+  console.log(pc.gray("Analyzing repository..."));
   console.log();
   const projectInfo = analyzeRepository(projectDir);
   showTechStack(projectInfo, args.verbose);
@@ -2457,11 +4212,11 @@ async function main() {
       projectInfo.description = preferences.description;
     }
   } else {
-    console.log(pc.green(`\u{1F4C1} Existing project \xB7 ${projectInfo.fileCount} source files`));
+    console.log(pc.gray(`Existing project with ${projectInfo.fileCount} source files`));
     console.log();
   }
   if (projectInfo.techStack.hasClaudeConfig && !args.force) {
-    console.log(pc.yellow("\u26A0\uFE0F  Existing .claude/ configuration detected"));
+    console.log(pc.yellow("Existing .claude/ configuration detected"));
     console.log();
     if (args.interactive) {
       const { proceed } = await prompts({
@@ -2477,32 +4232,32 @@ async function main() {
     }
     console.log();
   }
-  console.log(pc.blue("\u2699\uFE0F  Generating Claude Code configuration..."));
+  console.log(pc.gray("Generating configuration..."));
   console.log();
   const result = generateArtifacts(projectInfo);
   const { created, updated, skipped } = writeArtifacts(result.artifacts, projectDir, args.force);
   if (created.length > 0) {
-    console.log(pc.green("  Created:"));
+    console.log(pc.green("Created:"));
     for (const file of created) {
-      console.log(pc.green(`    \u2713 ${file}`));
+      console.log(pc.green(`  + ${file}`));
     }
   }
   if (updated.length > 0) {
-    console.log(pc.blue("  Updated:"));
+    console.log(pc.blue("Updated:"));
     for (const file of updated) {
-      console.log(pc.blue(`    \u21BB ${file}`));
+      console.log(pc.blue(`  ~ ${file}`));
     }
   }
   if (skipped.length > 0 && args.verbose) {
-    console.log(pc.gray("  Preserved:"));
+    console.log(pc.gray("Preserved:"));
     for (const file of skipped) {
-      console.log(pc.gray(`    - ${file}`));
+      console.log(pc.gray(`  - ${file}`));
     }
   }
   console.log();
   createTaskFile(projectInfo, preferences);
   const totalFiles = created.length + updated.length;
-  console.log(pc.green(`\u2705 Configuration complete! (${totalFiles} files)`));
+  console.log(pc.green(`Done! (${totalFiles} files)`));
   console.log();
   console.log(pc.bold("Generated for your stack:"));
   const skills = result.artifacts.filter((a) => a.type === "skill");
@@ -2510,24 +4265,24 @@ async function main() {
   const rules = result.artifacts.filter((a) => a.type === "rule");
   if (skills.length > 0) {
     console.log(
-      `  \u{1F4DA} ${skills.length} skills (${skills.map((s) => path3.basename(s.path, ".md")).join(", ")})`
+      `  ${skills.length} skills (${skills.map((s) => path3.basename(s.path, ".md")).join(", ")})`
     );
   }
   if (agents.length > 0) {
     console.log(
-      `  \u{1F916} ${agents.length} agents (${agents.map((a) => path3.basename(a.path, ".md")).join(", ")})`
+      `  ${agents.length} agents (${agents.map((a) => path3.basename(a.path, ".md")).join(", ")})`
     );
   }
   if (rules.length > 0) {
-    console.log(`  \u{1F4CF} ${rules.length} rules`);
+    console.log(`  ${rules.length} rules`);
   }
   console.log();
   console.log(`${pc.cyan("Next step:")} Run ${pc.bold("claude")} to start working!`);
   console.log();
   if (!projectInfo.isExisting) {
-    console.log(pc.gray("\u{1F4A1} Tip: Use /task to define your first task"));
+    console.log(pc.gray("Tip: Use /task to define your first task"));
   } else {
-    console.log(pc.gray("\u{1F4A1} Tip: Use /analyze to explore specific areas of your codebase"));
+    console.log(pc.gray("Tip: Use /analyze to explore specific areas of your codebase"));
   }
 }
 main().catch((err) => {
@@ -2538,6 +4293,13 @@ main().catch((err) => {
   process.exit(1);
 });
 export {
+  createTaskFile,
+  formatFramework2 as formatFramework,
+  formatLanguage2 as formatLanguage,
   getVersion,
-  parseArgs
+  parseArgs,
+  promptNewProject,
+  showBanner,
+  showHelp,
+  showTechStack
 };