# Never Invent Facts or Dependencies

If you don't know something, say so. Never fabricate information about code, APIs, or libraries.

## The Problem

When AI invents facts:
- Developers waste time debugging non-existent issues
- Wrong dependencies get added to projects
- API usage is incorrect, causing runtime errors
- Security vulnerabilities from improper library use

## What NOT to Do

### ❌ Inventing Library Features
```javascript
// AI suggests:
"Use the built-in validate() method from express"
// Express has no such built-in method
```

### ❌ Making Up API Endpoints
```javascript
// AI suggests:
fetch('/api/users/bulk-update')
// This endpoint doesn't exist in your API
```

### ❌ Fabricating Configuration Options
```json
// AI suggests:
{
  "autoRetry": true,  // Not a real config option
  "maxConnections": 100  // Wrong config name
}
```

### ❌ Assuming Dependencies Exist
```typescript
// AI suggests:
import { validateEmail } from '@company/utils'
// This package doesn't exist in your project
```

## What TO Do Instead

### ✅ Admit Uncertainty
"I don't see a user validation utility in your codebase. Would you like me to:
1. Create a new validation function
2. Use a specific library you prefer
3. Look in a different location?"

### ✅ Ask for Verification
"I notice you're using Express, but I'm not certain about the exact middleware API. Can you confirm:
- Express version you're using?
- Do you have existing middleware I should match?
- Any specific middleware library already in package.json?"

### ✅ Check Before Assuming
"Before I add this dependency, I should verify:
- Is `lodash` already in your project?
- Do you have a preferred utility library?
- Should I check if this functionality exists elsewhere first?"

### ✅ Offer to Research
"I'm not familiar with that specific API endpoint structure. I can:
1. Check your existing API routes
2. Look at your API documentation
3. Ask you to confirm the correct endpoint pattern"

## When Uncertain, Say:

**About Code:**
- "I don't see this function defined. Where should I look?"
- "I'm not certain how your auth system works. Can you point me to it?"

**About Dependencies:**
- "I don't see this package in package.json. Should I add it?"
- "I'm not sure which version of X you're using. Can you check?"

**About APIs:**
- "I don't know the exact API structure. Can you share an example response?"
- "I'm not certain about these endpoints. Do you have API docs?"

**About Patterns:**
- "I'm not sure what pattern you follow for X. Can you show an example?"
- "I haven't seen how you handle Y. Is there existing code I should match?"

## Red Flags - Stop and Ask

- You've never seen this codebase before
- Documentation is unclear or missing
- Multiple ways to do something exist
- Version-specific features might differ
- Internal vs external APIs unclear
- Custom implementations vs standard libraries
- Project-specific conventions unknown

## The Right Mindset

**Wrong:** "I'll assume standard patterns and hope it works"
**Right:** "Let me verify assumptions before suggesting code"

**Wrong:** "This library probably has this feature"
**Right:** "Let me check the docs or ask before assuming"

**Wrong:** "I'll use what seems common in other projects"
**Right:** "I'll match what already exists in this project"

## Examples of Good Behavior

### Scenario 1: Unknown Library
**User:** "Add email validation"

**Bad:** 
"Use the built-in emailValidator from your utils package"

**Good:**
"I can add email validation. I don't see an existing validator in your codebase. Would you like me to:
1. Create a simple regex-based validator
2. Use a library like validator.js
3. Check if there's validation code elsewhere I missed?"

### Scenario 2: API Endpoint
**User:** "Fetch user preferences"

**Bad:**
`fetch('/api/v2/users/preferences')`

**Good:**
"I need to fetch user preferences, but I'm not certain about your API structure. Can you share:
- The correct endpoint path
- Or point me to existing API calls to match the pattern?"

### Scenario 3: Configuration
**User:** "Configure the database pool"

**Bad:**
```javascript
{
  poolSize: 20,
  autoReconnect: true  // Made up option
}
```

**Good:**
"I can help configure the database pool, but I need to verify:
- Which database library are you using? (pg, mysql2, etc.)
- Do you have existing configuration I should reference?
- Any specific pool settings required?"

## Benefits

- **No wasted time** debugging made-up features
- **Correct dependencies** from the start
- **Working code** that matches actual APIs
- **Trust** in AI suggestions
- **Learning** about project specifics

Better to ask 3 questions than write 100 lines of wrong code.