Custom Slash Commands for Your Team

---
description: Review code with PR-quality feedback
argument-hint: <file path or "staged" for git changes>
allowed-tools: Glob, Grep, Read, Bash
---

# Code Review Command

You are reviewing: **$ARGUMENTS**

## Context
This is a TypeScript monorepo with strict conventions...

## Review Process
1. Gather changes
2. Analyze code quality
3. Check conventions
...

# /find - Read-only exploration
allowed-tools: Glob, Grep, Read, Task

# /review - Can check git status, but not write files
allowed-tools: Glob, Grep, Read, Bash

# /write - Full access for code generation
allowed-tools: Glob, Grep, Read, Write, Edit, Bash

# /test - Can create test files and run them
allowed-tools: Glob, Grep, Read, Write, Edit, Bash

---
description: Research and plan a feature or solution
argument-hint: <feature or problem to research>
allowed-tools: Glob, Grep, Read, Task, WebSearch, WebFetch
---

# Research & Planning Command

You are researching and planning: **$ARGUMENTS**

## Research Process

1. **Understand the Request**
   - Parse the feature/problem description
   - Identify key requirements
   - Note any ambiguities

2. **Explore Existing Patterns**
   - Search for similar implementations
   - Review relevant package structures
   - Check existing service patterns

3. **Architecture Analysis**
   - Determine affected apps/packages
   - Identify dependencies
   - Consider data flow

4. **Create Implementation Plan**
   - Break down into discrete tasks
   - Order by dependencies
   - Identify potential risks

## Output Format

### Summary
Brief description of the solution approach

### Affected Packages
- List packages that need changes

### Implementation Steps
1. Numbered, actionable steps
2. Include file paths
3. Note dependencies between steps

### Technical Decisions
- Key architectural choices
- Trade-offs considered

### Questions/Blockers
- Items needing clarification

---
description: Deeply understand code, patterns, or architecture
argument-hint: <file path, component, or concept>
allowed-tools: Glob, Grep, Read, Task
---

# Code Understanding Command

You are analyzing: **$ARGUMENTS**

## Analysis Process

1. **Locate the Code**
   - Find relevant files
   - Map directory structure

2. **Trace Dependencies**
   - What does this code depend on?
   - What depends on this code?

3. **Understand Patterns**
   - Identify design patterns
   - Note Effect TS patterns
   - Document React patterns

4. **Document Behavior**
   - What does it do?
   - Inputs/outputs?
   - Side effects?

## Output Format

### Overview
High-level description

### Architecture
Visual representation of structure

### Key Components
- **Name**: What it does

### Patterns Used
- Design patterns
- Framework-specific patterns

### Dependencies
- Upstream: What this needs
- Downstream: What uses this

---
description: Find code, patterns, or implementations
argument-hint: <what to find>
allowed-tools: Glob, Grep, Read, Task
---

# Code Discovery Command

You are searching for: **$ARGUMENTS**

## Search Strategy

1. **Interpret the Query**
   - Consider synonyms
   - Think about file naming conventions

2. **Multi-Pronged Search**
   - File patterns (glob)
   - Content search (grep)
   - Type definitions
   - Usage examples

3. **Rank Results**
   - Primary matches (direct hits)
   - Secondary matches (related)
   - Examples and usage

## Search Patterns

**Components**: `packages/*/src/**/*.tsx`
**Services**: `packages/*/src/**/*.ts`
**Database**: `packages/db/src/schema/*.ts`
**Tests**: `**/*.test.ts`, `**/*.spec.ts`

## Output Format

### Search Results

**File**: `path/to/file.ts:line`
```typescript
// Relevant code snippet

<br />

Usage: `/find authentication middleware`

<br />

### `/review` - Code Review

<br />

```markdown
---
description: Review code with PR-quality feedback
argument-hint: <file path or "staged" for git changes>
allowed-tools: Glob, Grep, Read, Bash
---

# Code Review Command

You are reviewing: **$ARGUMENTS**

## Review Process

1. **Gather Changes**
   - If "staged": run `git diff --staged`
   - If file path: read file and check history

2. **Analyze Code Quality**
   - Type safety and correctness
   - Error handling
   - Performance considerations

3. **Check Conventions**
   - Naming conventions
   - File organization
   - Import ordering

4. **Security Review**
   - Input validation
   - Authentication/authorization
   - Secrets handling

## Review Categories

### Critical (Must Fix)
- Security vulnerabilities
- Type errors
- Breaking changes

### Important (Should Fix)
- Logic errors
- Missing error handling
- Performance issues

### Suggestions (Nice to Have)
- Code style
- Better naming
- Refactoring opportunities

## Checklist
- [ ] Types are correct
- [ ] Error handling is complete
- [ ] No security issues
- [ ] Follows repo conventions

---
description: Create, run, or improve tests
argument-hint: <file, function, or component to test>
allowed-tools: Glob, Grep, Read, Write, Edit, Bash
---

# Testing Workflow Command

You are testing: **$ARGUMENTS**

## Testing Process

1. **Analyze Target**
   - Read code to be tested
   - Identify functions and behaviors
   - Understand dependencies

2. **Check Existing Tests**
   - Look for test files
   - Review current coverage
   - Identify gaps

3. **Plan Tests**
   - Unit tests for isolated logic
   - Integration tests for workflows
   - Edge cases and error handling

4. **Write/Update Tests**
   - Follow existing patterns
   - Use descriptive test names
   - Arrange-act-assert structure

5. **Run Tests**
   - Execute with vitest
   - Check coverage
   - Fix failures

## Commands

```bash
bun run test                              # All tests
bun run test --filter=@bts/package-name   # Specific package
bun run test:coverage                     # With coverage

<br />

Usage: `/test packages/auth/src/session.ts`

<br />

### `/write` - Code Generation

<br />

```markdown
---
description: Generate code following repo patterns
argument-hint: <description of what to create>
allowed-tools: Glob, Grep, Read, Write, Edit, Bash
---

# Code Generation Command

You are creating: **$ARGUMENTS**

## Generation Process

1. **Understand Requirements**
   - Parse what needs to be created
   - Identify code type (service, component, API)
   - Determine involved packages

2. **Find Patterns**
   - Search for similar code
   - Extract patterns to follow
   - Note naming conventions

3. **Plan Structure**
   - File locations
   - Exports and imports
   - Dependencies

4. **Generate Code**
   - Follow existing patterns exactly
   - Include TypeScript types
   - Add necessary imports
   - Include exports in index files

5. **Verify**
   - `bun run check-types`
   - `bun run build`

## Code Patterns

### Effect TS Service
```typescript
export class MyService extends Context.Tag('MyService')<...>() {}
export const MyServiceLive = Layer.succeed(MyService, {...})

export const myRouter = {
  myAction: publicProcedure
    .input(z.object({...}))
    .handler(async ({ input, context }) => {...})
}

export function MyComponent({ className }: Props) {
  return <div className={cn('base', className)}>...</div>
}

<br />

Usage: `/write a new authentication guard hook for admin routes`

<br />

## The Workflow in Practice

<br />

A typical feature development session:

<br />

```bash
# 1. Research the approach
/research add project archiving feature

# 2. Understand existing patterns
/understand packages/project-ai/src/tools

# 3. Find similar implementations
/find soft delete implementation

# 4. Write the code
/write an archiveProject tool following the recent-projects pattern

# 5. Test it
/test packages/project-ai/src/tools/archive-project

# 6. Review before committing
/review staged

---
description: What this command does
argument-hint: <what to pass>
allowed-tools: [appropriate tools]
---

# My Command

You are doing X with: **$ARGUMENTS**

## Process
1. Step one
2. Step two

## Output Format
- How results should look