Gemini Context Setup: The Complete Developer Guide for 2026

# Project Context Template
## Project: [Your Project Name]
**Type**: [Web app / API / CLI tool / Library]
**Tech Stack**: [Primary language + frameworks]
**Architecture**: [Monorepo / microservices / serverless / etc]
**Database**: [PostgreSQL / MongoDB / etc]
**Deployment**: [Docker / Kubernetes / Vercel / etc]

## Coding Standards
- **Language**: [TypeScript strict mode / Python with type hints / etc]
- **Style**: [Prettier + ESLint / Black + isort / etc]
- **Testing**: [Jest + Testing Library / pytest / etc]
- **Documentation**: [JSDoc / Sphinx / etc]

## Current Phase
[What you're building right now - be specific]

---

# Current Task Context

## Files I'm Working On
```typescript
// src/components/UserProfile.tsx
[Current file content]
```

```typescript  
// src/hooks/useUserData.ts
[Related hook/utility]
```

## Related Test Files
```typescript
// src/components/__tests__/UserProfile.test.tsx
[Test file if it exists]
```

## API Contracts
```typescript
// types/api.ts
interface UserProfile {
  id: string;
  email: string;
  displayName: string;
  // ... etc
}
```

## Current Task
I need to add user avatar upload functionality to the UserProfile component.

**Requirements:**
- File upload with drag-and-drop
- Image preview before upload
- Validation: max 2MB, jpeg/png only  
- Upload to S3 with presigned URLs
- Optimistic UI updates
- Error handling for network failures

**Success Criteria:**
- Component renders upload area when no avatar exists
- Shows current avatar with "change" option when avatar exists
- Handles upload progress with loading states
- Validates file type/size before upload
- Updates user context after successful upload

# Context Prioritization (most important first)

## 1. Current Task (top of context)
[What you're working on right now]

## 2. Relevant Code
[3-5 files directly related to task]

## 3. Project Standards  
[Coding style, architecture decisions, conventions]

## 4. Dependencies & APIs
[External APIs, key libraries, data structures]

## 5. Previous Solutions (if relevant)
[Similar problems you've solved in this project]

---
# Everything below this line is supplementary

Generate the UserProfile component with avatar upload functionality.

**Code Requirements:**
- Use TypeScript with strict mode
- Follow our existing component patterns (see ProfileSettings.tsx)
- Include proper error boundaries
- Add comprehensive PropTypes/interface definitions
- Include inline comments for complex logic
- Generate corresponding test file

**Implementation Notes:**
- Use React Hook Form for form handling (consistent with codebase)
- Integrate with existing useUserData hook
- Follow our error handling patterns (see ErrorBoundary.tsx)
- Match the styling patterns in our design system

**Output Format:**
1. Main component file
2. Hook file (if new custom hook needed)
3. Test file with unit tests
4. Type definitions (if new types needed)

Start with the main component.

# Multi-File Context Pattern

## Architecture Change: Add User Permissions System

### Current State (include relevant files)
```typescript
// src/auth/AuthContext.tsx
[Current auth context]
```

```typescript
// src/components/AdminPanel.tsx  
[Component that needs permission checks]
```

```typescript
// src/hooks/useAuth.ts
[Current auth hook]
```

### Target Architecture
I need to add a role-based permissions system that:
- Extends the existing AuthContext
- Adds permission checking hooks
- Updates components to use permission checks
- Maintains backward compatibility

Show me the complete implementation across all affected files.

// .vscode/settings.json
{
  "google-ai-studio.contextFiles": [
    "README.md",
    "package.json", 
    "tsconfig.json",
    "src/types/index.ts",
    ".env.example"
  ],
  "google-ai-studio.excludePatterns": [
    "node_modules/**",
    "dist/**", 
    "coverage/**",
    "*.log"
  ],
  "google-ai-studio.maxContextSize": 1800000
}

#!/bin/bash
# scripts/generate-context.sh

echo "# Project Context - $(date)"
echo "## Project: $(basename $(pwd))"
echo

echo "## Package Configuration"
echo '```json'
cat package.json | jq '{name, version, dependencies, devDependencies}'
echo '```'
echo

echo "## Current Files"
for file in "$@"; do
    if [ -f "$file" ]; then
        echo "### $file"
        echo '```'$(file --mime-type -b "$file" | cut -d'/' -f2)'
        cat "$file"
        echo '```'
        echo
    fi
done

echo "## Git Context"
echo "**Branch:** $(git branch --show-current)"
echo "**Recent commits:**"
git log --oneline -5

# Workflow Pattern

## 1. Architectural Planning (Gemini)
- Multi-file changes
- Complex business logic
- Design patterns
- Error handling strategies

## 2. Implementation (GitHub Copilot)
- Line-by-line coding
- Repetitive patterns
- Standard CRUD operations
- Test boilerplate

## 3. Review & Refinement (Gemini)
- Code review with full context
- Performance optimization
- Security considerations
- Documentation generation

# Good Context Structure
## CURRENT TASK (most important)
[What you're building right now]

## WORKING FILES  
[3-5 files you're actively changing]

## RELATED FILES
[Dependencies, types, utilities]

---
# REFERENCE ONLY (least important)
## Project Overview
## Previous Solutions
## Documentation

## Recent Changes
**Branch:** feature/user-profiles
**Last 3 commits:**
- abc123f: Add user profile API endpoints
- def456a: Implement profile validation logic  
- ghi789b: Add user profile database schema

**Current status:** Working on frontend component integration

# Code Review Context

## Review Request
Please review this pull request for security, performance, and consistency with our codebase standards.

## Changed Files
[Include all changed files]

## Project Standards  
[Include your coding standards]

## Security Checklist
- Input validation
- Authentication checks
- SQL injection prevention
- XSS prevention
- Secrets management

## Performance Checklist
- Database query optimization
- Bundle size impact
- Memory leak prevention
- Caching strategies

Please provide specific feedback with code suggestions.

# Documentation Generation Context

## Target: API Documentation for User Management

## Include All Related Files
[User models, API routes, validation schemas, test files]

## Documentation Requirements
- OpenAPI 3.0 spec
- Usage examples for each endpoint
- Error response documentation  
- Authentication requirements
- Rate limiting information

Generate complete API documentation that developers can use to integrate with our user management system.

# Save these as reusable templates:

## project-foundation.md
[Your project's core context - rarely changes]

## current-sprint.md  
[Current development focus - updated weekly]

## today-context.md
[Files you're working with today - updated daily]

# Combine with: cat project-foundation.md current-sprint.md today-context.md

# Simple token counter
function count_tokens() {
    local file="$1"
    # Rough estimate: ~4 chars per token
    wc -c < "$file" | awk '{print int($1/4)}'
}

# Check before sending to Gemini
context_size=$(cat context.md | wc -c | awk '{print int($1/4)}')
echo "Context size: ~$context_size tokens"