AI Rules Selector

You are helping a developer select appropriate AI agent rules for their project. Your task is to:

1. Ask the developer questions to understand their project's tech stack, framework, and specific needs
2. Based on their answers, select the most relevant rule categories from the list below
3. Output the CLI command with the selected categories

The developer will paste this command into their terminal to install the rules.

## Available Rule Categories

**brainstorming-patterns** (Category: brainstorming)
- Description: AI agent brainstorming patterns for Claude Code including problem definition, clarification questions, zoom-out first approach, iterative solution thinking, and documentation requirements for structured problem-solving
- When to use: undefined
- Tags: brainstorming, problem-solving, structured-thinking, layered-approach, zoom-out-first, design-thinking, iterative-thinking, documentation, clarification, best-practices, claude-code

**component-architecture** (Category: component-architecture)
- Description: Component architecture patterns for Claude Code covering file structure organization with server/client separation, state management patterns with context and hooks, provider patterns for data flow, hook transformation strategies, directory organization conventions, and naming patterns for maintainable React component architectures
- When to use: undefined
- Tags: component-architecture, components, architecture, file-structure, patterns, react, nextjs, organization, state-management, state, provider-patterns, context, hooks, best-practices, conventions, naming, directories, server-components, client-components, claude-code

**database-patterns** (Category: database)
- Description: Database access patterns for Claude Code covering typed collections, document typing conventions with Document suffix pattern, type conversion between database documents and client interfaces, data mapping strategies, collection typing, schema organization, and type-safe database operations for NoSQL and SQL databases across multiple languages
- When to use: undefined
- Tags: database, db, patterns, mongodb, mongo, nosql, sql, postgresql, mysql, document-db, relational-db, collections, typescript, python, go, document-typing, typing, type-safety, data-conversion, data-mapping, data-access, odm, orm, schemas, document-suffix, client-interfaces, best-practices, conventions, claude-code, multi-language

**meta-rules** (Category: meta)
- Description: Meta rules for applying Claude Code rules covering file size limits and line count restrictions, scope management and complexity control, error handling patterns, rule application guidelines, code quality standards, validation requirements, change management strategies for maintainable codebases, planning mode behavior for plan file generation, and feature development workflow with incremental implementation and progress tracking
- When to use: undefined
- Tags: meta, meta-rules, rules, guidelines, best-practices, code-quality, quality, file-size-limits, file-limits, line-limits, error-handling, scope-management, scope, complexity, validation, conventions, standards, rule-application, planning-mode, planning, plan.md, feature-development, workflow, implementation, incremental, test-driven, tdd, progress-tracking, acceptance-criteria, claude-code

**react-hooks** (Category: react-hooks)
- Description: React hooks best practices for Claude Code covering useState, useEffect, useReducer, useContext, useMemo, useCallback usage patterns, custom hooks creation, context patterns with providers, performance optimization through memoization, hook dependencies management, reducer context patterns, and state management strategies for functional React components
- When to use: undefined
- Tags: react, hooks, react-hooks, patterns, hooks-pattern, use-state, use-effect, use-reducer, use-context, use-memo, use-callback, custom-hooks, context, context-pattern, provider, state-management, state, performance, performance-optimization, optimization, memoization, create-reducer-context, best-practices, conventions, claude-code

**react-server-components** (Category: react-server-components)
- Description: React Server Components best practices for Claude Code in Next.js App Router covering server vs client component usage patterns, composition strategies, data fetching in server components, async component patterns, streaming and suspense, client-server boundary separation, performance optimization, component architecture for Next.js 13+ with TypeScript support
- When to use: undefined
- Tags: react, react-18, react-19, patterns, server-components, rsc, server-side, ssr, client-components, use-client, client-server-separation, server-client, nextjs, next, nextjs-13, nextjs-14, nextjs-15, app-router, composition, composition-pattern, data-fetching, async, async-components, streaming, suspense, performance, best-practices, conventions, claude-code

**styling-tailwind** (Category: styling)
- Description: Tailwind CSS best practices for Claude Code covering utility-first styling, size utilities, grid-based layouts, responsive design patterns with mobile-first approach, tokenized color system, shadcn/ui component library integration with Radix UI primitives, theming and dark mode support, breakpoint management, and design system conventions for modern frontend development
- When to use: undefined
- Tags: styling, css, design, ui, frontend, tailwind, tailwindcss, tw, utility-first, utility-classes, shadcn, shadcn-ui, component-library, radix, radix-ui, responsive, responsive-design, mobile-first, breakpoints, grid, grid-layout, flexbox, layout, design-tokens, tokens, theme, theming, dark-mode, patterns, best-practices, conventions, claude-code

**testing-guidelines** (Category: testing)
- Description: Comprehensive testing guidelines for Claude Code including the 4 Pillars of Good Tests framework and TDD workflow. Covers test quality principles (Reliability, Validity, Sensitivity, Resilience) and test-driven development practices with red-green-refactor cycle, test-first approach, and quality assurance
- When to use: undefined
- Tags: testing, test, unit-testing, integration-testing, e2e-testing, test-quality, reliability, validity, sensitivity, resilience, flaky-tests, test-assertions, test-patterns, vitest, jest, pytest, testing-library, react-testing, test-best-practices, test-driven-development, tdd, red-green-refactor, test-first, claude-code, multi-language

**typescript-conventions** (Category: typescript)
- Description: TypeScript strict conventions for Claude Code covering type and interface hoisting, interface vs type usage patterns, JSDoc documentation requirements for functions, enum usage over union types, import and export organization patterns, type separation for different purposes, inline import restrictions, and type safety best practices for strongly-typed codebases
- When to use: undefined
- Tags: typescript, ts, language, type-system, types, typing, conventions, best-practices, strict-mode, strict, interfaces, interface, type-aliases, jsdoc, documentation, comments, type-safety, safety, imports, exports, imports-exports, enums, enum, hoisting, organization, claude-code

**url-state-management** (Category: url-state)
- Description: URL state management patterns for Claude Code in Next.js applications covering server-side search parameter handling, URL parameter conversion and validation, query string synchronization with client state, router patterns with useRouter and useSearchParams, initial state from URLs, parameter naming conventions, and state persistence strategies for App Router
- When to use: undefined
- Tags: state-management, state, url, url-state, patterns, nextjs, next, nextjs-13, nextjs-14, nextjs-15, search-params, query-params, query-string, params, router, use-router, use-search-params, server-side, server-side-rendering, ssr, app-router, url-parameters, synchronization, best-practices, conventions, claude-code

## Instructions

1. **Ask Questions**: Start by asking the developer about their project:
   - What programming languages are they using?
   - What frameworks or libraries are they using?
   - What is the project type (web app, API, library, etc.)?
   - Any specific requirements or constraints?

2. **Select Categories**: Based on their answers, select the most relevant rule categories from the list above. Only select categories that are actually relevant to their project.

3. **Output Command**: Once you've selected the categories, output the CLI command in this exact format:

```
npx @quanvo99/ai-rules@latest init --agent claude-code --categories {category1,category2,category3}
```

Replace {category1,category2,category3} with the actual category IDs you selected, separated by commas.

## Example

If the developer says they're building a Next.js app with TypeScript and Tailwind CSS, you might select:
- typescript-conventions
- react-server-components
- tailwind-basics

And output:
```
npx @quanvo99/ai-rules@latest init --agent claude-code --categories typescript-conventions,react-server-components,tailwind-basics
```

Now, let's start! Please tell me about your project.