Codeium

# Instalacja przez CLI
code --install-extension Codeium.codeium

# Lub przez VS Code:
# 1. Otwórz Extensions (Cmd/Ctrl + Shift + X)
# 2. Wyszukaj "Codeium"
# 3. Kliknij "Install"
# 4. Zaloguj się przez przycisk w statusbar

1. Otwórz Settings/Preferences
2. Plugins → Marketplace
3. Wyszukaj "Codeium"
4. Zainstaluj i zrestartuj IDE
5. Zaloguj się przez Tools → Codeium → Login

-- Używając lazy.nvim
{
  "Exafunction/codeium.nvim",
  dependencies = {
    "nvim-lua/plenary.nvim",
    "hrsh7th/nvim-cmp",
  },
  config = function()
    require("codeium").setup({})
  end
}

-- Lub używając packer
use {
  "Exafunction/codeium.vim",
  config = function()
    vim.keymap.set('i', '<C-g>', function()
      return vim.fn['codeium#Accept']()
    end, { expr = true })
  end
}

# Po instalacji
:Codeium Auth

" Używając vim-plug
Plug 'Exafunction/codeium.vim'

" Konfiguracja
let g:codeium_disable_bindings = 1
imap <script><silent><nowait><expr> <C-g> codeium#Accept()
imap <C-;> <Cmd>call codeium#CycleCompletions(1)<CR>
imap <C-,> <Cmd>call codeium#CycleCompletions(-1)<CR>
imap <C-x> <Cmd>call codeium#Clear()<CR>

;; Używając use-package
(use-package codeium
  :ensure t
  :init
  (add-to-list 'completion-at-point-functions #'codeium-completion-at-point)
  :config
  (setq codeium-mode-line-enable t))

;; Aktywacja
(codeium-init)

1. Help → Eclipse Marketplace
2. Wyszukaj "Codeium"
3. Zainstaluj i zrestartuj
4. Window → Preferences → Codeium
5. Zaloguj się

// Zacznij pisać funkcję
function calculateTax(income: number, taxRate: number) {
  // Codeium sugeruje:
  return income * (taxRate / 100)
}

// Codeium rozumie typy i interfejsy
interface User {
  id: string
  name: string
  email: string
  createdAt: Date
}

function createUser(data: Partial<User>): User {
  // Codeium: return { id: generateId(), createdAt: new Date(), ...data }
}

// Codeium dopasowuje się do stylu kodu
const users = [
  { name: "Jan", age: 25 },
  { name: "Anna", age: 30 },
]

// Zacznij pisać - Codeium kontynuuje w tym samym stylu
const products = [
  // Codeium: { name: "Laptop", price: 999 },
]

# Napisz komentarz opisujący funkcję
# Function to fetch user data from API and cache it

def fetch_user_with_cache(user_id: str) -> dict:
    # Codeium generuje całą implementację:
    cache_key = f"user:{user_id}"

    # Check cache first
    cached = redis_client.get(cache_key)
    if cached:
        return json.loads(cached)

    # Fetch from API
    response = requests.get(f"{API_URL}/users/{user_id}")
    response.raise_for_status()
    user_data = response.json()

    # Cache for 1 hour
    redis_client.setex(cache_key, 3600, json.dumps(user_data))

    return user_data

function processOrders(orders) {
  const validOrders = orders.filter(order => {
    // Kursor tutaj - Codeium uzupełnia walidację
    // Codeium: return order.status === 'pending' && order.total > 0
  })

  return validOrders.map(order => ({
    id: order.id,
    // Kursor tutaj - Codeium uzupełnia mapowanie
    // Codeium: total: order.total * 1.23, // with VAT
    // Codeium: customer: order.customer.name,
    // Codeium: date: new Date(order.createdAt).toLocaleDateString()
  }))
}

Przykładowe pytania:

1. "Wyjaśnij co robi ta funkcja"
   → Zaznacz kod i zapytaj o wyjaśnienie

2. "Napisz testy jednostkowe dla tej funkcji"
   → Generuje testy dla zaznaczonego kodu

3. "Zrefaktoruj ten kod do użycia async/await"
   → Przepisuje kod z callbacks na async

4. "Znajdź potencjalne bugi w tym kodzie"
   → Analizuje kod pod kątem błędów

5. "Dodaj dokumentację JSDoc"
   → Generuje komentarze dokumentacyjne

// Zaznacz ten kod i zapytaj: "Jak zoptymalizować tę funkcję?"

function findDuplicates(arr: number[]): number[] {
  const duplicates: number[] = []
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j] && !duplicates.includes(arr[i])) {
        duplicates.push(arr[i])
      }
    }
  }
  return duplicates
}

// Codeium Chat odpowie z zoptymalizowaną wersją:
function findDuplicatesOptimized(arr: number[]): number[] {
  const seen = new Set<number>()
  const duplicates = new Set<number>()

  for (const num of arr) {
    if (seen.has(num)) {
      duplicates.add(num)
    } else {
      seen.add(num)
    }
  }

  return [...duplicates]
}

User: "Napisz hook React do debounce'owania wartości"

Codeium Chat:

import { useState, useEffect } from 'react'

function useDebounce<T>(value: T, delay: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value)

  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedValue(value)
    }, delay)

    return () => {
      clearTimeout(timer)
    }
  }, [value, delay])

  return debouncedValue
}

// Użycie:
function SearchComponent() {
  const [query, setQuery] = useState('')
  const debouncedQuery = useDebounce(query, 300)

  useEffect(() => {
    if (debouncedQuery) {
      // Wykonaj wyszukiwanie
      search(debouncedQuery)
    }
  }, [debouncedQuery])

  return (
    <input
      value={query}
      onChange={(e) => setQuery(e.target.value)}
      placeholder="Search..."
    />
  )
}

# Oryginalny kod:
def process_data(data):
    result = []
    for item in data:
        if item['status'] == 'active':
            if item['type'] == 'premium':
                item['discount'] = 0.2
            else:
                item['discount'] = 0.1
            item['final_price'] = item['price'] * (1 - item['discount'])
            result.append(item)
    return result

# Zapytaj: "Zrefaktoruj używając list comprehension i early return"

# Codeium Chat:
def calculate_discount(item_type: str) -> float:
    return 0.2 if item_type == 'premium' else 0.1

def process_item(item: dict) -> dict | None:
    if item['status'] != 'active':
        return None

    discount = calculate_discount(item['type'])
    return {
        **item,
        'discount': discount,
        'final_price': item['price'] * (1 - discount)
    }

def process_data(data: list[dict]) -> list[dict]:
    return [
        processed
        for item in data
        if (processed := process_item(item)) is not None
    ]

Zapytanie: "function that validates email"
→ Znajduje: validateEmail(), isValidEmail(), checkEmailFormat()

Zapytanie: "error handling for API calls"
→ Znajduje: try/catch bloki, error middleware, response handlers

Zapytanie: "database connection setup"
→ Znajduje: connectDB(), initializeDatabase(), createPool()

Zapytanie: "authentication middleware"
→ Znajduje: authMiddleware, verifyToken, requireAuth

1. Cmd/Ctrl + Shift + P → "Codeium: Search"
2. Wpisz zapytanie po znaczeniu
3. Przeglądaj wyniki z różnych plików
4. Kliknij aby przejść do kodu

# Codeium rozumie type hints i docstrings

from typing import Optional, List
from dataclasses import dataclass

@dataclass
class Product:
    id: str
    name: str
    price: float
    category: str

def filter_products(
    products: List[Product],
    min_price: Optional[float] = None,
    category: Optional[str] = None
) -> List[Product]:
    # Codeium sugeruje:
    result = products

    if min_price is not None:
        result = [p for p in result if p.price >= min_price]

    if category is not None:
        result = [p for p in result if p.category == category]

    return result

// Codeium rozumie ownership i lifetimes

use std::collections::HashMap;

struct Cache<T> {
    data: HashMap<String, T>,
    max_size: usize,
}

impl<T: Clone> Cache<T> {
    fn new(max_size: usize) -> Self {
        // Codeium:
        Self {
            data: HashMap::new(),
            max_size,
        }
    }

    fn get(&self, key: &str) -> Option<T> {
        // Codeium:
        self.data.get(key).cloned()
    }

    fn set(&mut self, key: String, value: T) {
        // Codeium:
        if self.data.len() >= self.max_size {
            // Remove oldest entry (simplified)
            if let Some(first_key) = self.data.keys().next().cloned() {
                self.data.remove(&first_key);
            }
        }
        self.data.insert(key, value);
    }
}

// Codeium rozumie idiomy Go

package main

import (
    "encoding/json"
    "net/http"
    "sync"
)

type UserService struct {
    mu    sync.RWMutex
    users map[string]*User
}

func NewUserService() *UserService {
    // Codeium:
    return &UserService{
        users: make(map[string]*User),
    }
}

func (s *UserService) GetUser(id string) (*User, error) {
    // Codeium:
    s.mu.RLock()
    defer s.mu.RUnlock()

    user, ok := s.users[id]
    if !ok {
        return nil, ErrUserNotFound
    }
    return user, nil
}

func (s *UserService) CreateUser(user *User) error {
    // Codeium:
    s.mu.Lock()
    defer s.mu.Unlock()

    if _, exists := s.users[user.ID]; exists {
        return ErrUserExists
    }
    s.users[user.ID] = user
    return nil
}

-- Codeium rozumie schematy i relacje

-- Po zdefiniowaniu tabel:
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL,
    name VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE orders (
    id SERIAL PRIMARY KEY,
    user_id INTEGER REFERENCES users(id),
    total DECIMAL(10, 2) NOT NULL,
    status VARCHAR(50) DEFAULT 'pending',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Zacznij pisać - Codeium sugeruje:
SELECT
    u.name,
    u.email,
    COUNT(o.id) as order_count,
    SUM(o.total) as total_spent
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
WHERE o.status = 'completed'
GROUP BY u.id, u.name, u.email
HAVING SUM(o.total) > 100
ORDER BY total_spent DESC;

// settings.json
{
  // Włącz/wyłącz Codeium
  "codeium.enableConfig": {
    "*": true,
    "markdown": false,
    "plaintext": false
  },

  // Opóźnienie przed pokazaniem sugestii (ms)
  "codeium.completionDelay": 100,

  // Maksymalna liczba linii w sugestii
  "codeium.maxCompletionLines": 10,

  // Pokaż sugestie inline
  "codeium.enableInlineCompletion": true,

  // Pokaż status w pasku
  "codeium.showStatusBar": true,

  // Automatyczne akceptowanie
  "codeium.enableAutoAccept": false
}

// .codeiumignore (w katalogu głównym projektu)
// Działa jak .gitignore

# Ignoruj pliki konfiguracyjne
*.config.js
*.env*

# Ignoruj wygenerowany kod
generated/
dist/
build/

# Ignoruj vendor
vendor/
node_modules/

# Ignoruj konkretne pliki
secrets.json
credentials.yaml

# codeium-config.yaml
enterprise:
  # Własny endpoint (on-premise)
  api_url: https://codeium.your-company.com

  # Telemetria
  telemetry_enabled: false

  # Używanie kodu do treningu
  training_opt_out: true

  # Dozwolone języki
  allowed_languages:
    - python
    - javascript
    - typescript
    - go

  # Blokowane repozytoria
  blocked_repos:
    - internal-secrets
    - legacy-codebase

1. Kod NIE jest używany do treningu modeli (opt-in)
2. Snippety są przetwarzane ale nie przechowywane
3. Dane są szyfrowane w transit (TLS 1.3)
4. Brak logowania kodu na serwerach

// VS Code settings
{
  // Wyłącz telemetrię
  "codeium.telemetryEnabled": false,

  // Wyłącz używanie kodu do ulepszania modelu
  "codeium.enableModelImprovement": false
}

# Dla organizacji wymagających wysokiego bezpieczeństwa

deployment:
  type: on-premise  # Lub private-cloud

security:
  encryption_at_rest: AES-256
  network_isolation: true
  audit_logging: true

compliance:
  soc2: true
  hipaa: available
  gdpr: true

#!/bin/bash
# .git/hooks/pre-commit

# Sprawdź czy Codeium nie zostawił TODO
if grep -r "// Codeium:" --include="*.ts" --include="*.js" .; then
  echo "Error: Found Codeium comments in code"
  exit 1
fi

# GitHub Actions - sprawdź jakość kodu
name: Code Quality

on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Check for AI-generated TODOs
        run: |
          if grep -r "TODO.*Codeium\|FIXME.*generated" .; then
            echo "Review AI-generated code before committing"
            exit 1
          fi

# Checklist dla kodu wygenerowanego przez AI

- [ ] Czy kod robi to co powinien?
- [ ] Czy są edge cases do obsłużenia?
- [ ] Czy nazwy zmiennych są sensowne?
- [ ] Czy logika jest zrozumiała?
- [ ] Czy są potencjalne problemy z wydajnością?
- [ ] Czy kod jest przetestowany?

// ❌ Słaby kontekst
function process(data) {
  // Codeium nie wie co ma robić
}

// ✅ Dobry kontekst
interface OrderData {
  items: CartItem[]
  customer: Customer
  shipping: ShippingMethod
}

/**
 * Process order and calculate final price including:
 * - Item prices with quantities
 * - Shipping cost based on method
 * - Tax based on customer location
 * - Any applicable discounts
 */
function processOrder(data: OrderData): ProcessedOrder {
  // Codeium ma pełny kontekst
}

# Zawsze weryfikuj wygenerowany kod

# Codeium może zasugerować:
def divide(a, b):
    return a / b

# Ale lepiej:
def divide(a: float, b: float) -> float:
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

// Komentarze pomagają Codeium zrozumieć intencje

// Fetch user data from API, handle errors, and cache result
async function getUserWithCache(userId) {
  // Codeium wygeneruje lepszy kod z tym kontekstem
}

// Sort users by last activity, most recent first
const sortedUsers = users.sort((a, b) => {
  // Codeium wie czego oczekujesz
})

# Install via CLI
code --install-extension Codeium.codeium

# Or via VS Code:
# 1. Open Extensions (Cmd/Ctrl + Shift + X)
# 2. Search for "Codeium"
# 3. Click "Install"
# 4. Log in using the button in the status bar

1. Open Settings/Preferences
2. Plugins → Marketplace
3. Search for "Codeium"
4. Install and restart the IDE
5. Log in via Tools → Codeium → Login

-- Using lazy.nvim
{
  "Exafunction/codeium.nvim",
  dependencies = {
    "nvim-lua/plenary.nvim",
    "hrsh7th/nvim-cmp",
  },
  config = function()
    require("codeium").setup({})
  end
}

-- Or using packer
use {
  "Exafunction/codeium.vim",
  config = function()
    vim.keymap.set('i', '<C-g>', function()
      return vim.fn['codeium#Accept']()
    end, { expr = true })
  end
}

# After installation
:Codeium Auth

" Using vim-plug
Plug 'Exafunction/codeium.vim'

" Configuration
let g:codeium_disable_bindings = 1
imap <script><silent><nowait><expr> <C-g> codeium#Accept()
imap <C-;> <Cmd>call codeium#CycleCompletions(1)<CR>
imap <C-,> <Cmd>call codeium#CycleCompletions(-1)<CR>
imap <C-x> <Cmd>call codeium#Clear()<CR>

;; Using use-package
(use-package codeium
  :ensure t
  :init
  (add-to-list 'completion-at-point-functions #'codeium-completion-at-point)
  :config
  (setq codeium-mode-line-enable t))

;; Activation
(codeium-init)

1. Help → Eclipse Marketplace
2. Search for "Codeium"
3. Install and restart
4. Window → Preferences → Codeium
5. Log in

// Start typing a function
function calculateTax(income: number, taxRate: number) {
  // Codeium suggests:
  return income * (taxRate / 100)
}

// Codeium understands types and interfaces
interface User {
  id: string
  name: string
  email: string
  createdAt: Date
}

function createUser(data: Partial<User>): User {
  // Codeium: return { id: generateId(), createdAt: new Date(), ...data }
}

// Codeium adapts to your code style
const users = [
  { name: "Jan", age: 25 },
  { name: "Anna", age: 30 },
]

// Start typing - Codeium continues in the same style
const products = [
  // Codeium: { name: "Laptop", price: 999 },
]

# Write a comment describing the function
# Function to fetch user data from API and cache it

def fetch_user_with_cache(user_id: str) -> dict:
    # Codeium generates the entire implementation:
    cache_key = f"user:{user_id}"

    # Check cache first
    cached = redis_client.get(cache_key)
    if cached:
        return json.loads(cached)

    # Fetch from API
    response = requests.get(f"{API_URL}/users/{user_id}")
    response.raise_for_status()
    user_data = response.json()

    # Cache for 1 hour
    redis_client.setex(cache_key, 3600, json.dumps(user_data))

    return user_data

function processOrders(orders) {
  const validOrders = orders.filter(order => {
    // Cursor here - Codeium fills in the validation
    // Codeium: return order.status === 'pending' && order.total > 0
  })

  return validOrders.map(order => ({
    id: order.id,
    // Cursor here - Codeium fills in the mapping
    // Codeium: total: order.total * 1.23, // with VAT
    // Codeium: customer: order.customer.name,
    // Codeium: date: new Date(order.createdAt).toLocaleDateString()
  }))
}

Example questions:

1. "Explain what this function does"
   → Select code and ask for an explanation

2. "Write unit tests for this function"
   → Generates tests for the selected code

3. "Refactor this code to use async/await"
   → Rewrites code from callbacks to async

4. "Find potential bugs in this code"
   → Analyzes code for errors

5. "Add JSDoc documentation"
   → Generates documentation comments

// Select this code and ask: "How can I optimize this function?"

function findDuplicates(arr: number[]): number[] {
  const duplicates: number[] = []
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j] && !duplicates.includes(arr[i])) {
        duplicates.push(arr[i])
      }
    }
  }
  return duplicates
}

// Codeium Chat responds with an optimized version:
function findDuplicatesOptimized(arr: number[]): number[] {
  const seen = new Set<number>()
  const duplicates = new Set<number>()

  for (const num of arr) {
    if (seen.has(num)) {
      duplicates.add(num)
    } else {
      seen.add(num)
    }
  }

  return [...duplicates]
}

User: "Write a React hook for debouncing a value"

Codeium Chat:

import { useState, useEffect } from 'react'

function useDebounce<T>(value: T, delay: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value)

  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedValue(value)
    }, delay)

    return () => {
      clearTimeout(timer)
    }
  }, [value, delay])

  return debouncedValue
}

// Usage:
function SearchComponent() {
  const [query, setQuery] = useState('')
  const debouncedQuery = useDebounce(query, 300)

  useEffect(() => {
    if (debouncedQuery) {
      // Perform search
      search(debouncedQuery)
    }
  }, [debouncedQuery])

  return (
    <input
      value={query}
      onChange={(e) => setQuery(e.target.value)}
      placeholder="Search..."
    />
  )
}

# Original code:
def process_data(data):
    result = []
    for item in data:
        if item['status'] == 'active':
            if item['type'] == 'premium':
                item['discount'] = 0.2
            else:
                item['discount'] = 0.1
            item['final_price'] = item['price'] * (1 - item['discount'])
            result.append(item)
    return result

# Ask: "Refactor using list comprehension and early return"

# Codeium Chat:
def calculate_discount(item_type: str) -> float:
    return 0.2 if item_type == 'premium' else 0.1

def process_item(item: dict) -> dict | None:
    if item['status'] != 'active':
        return None

    discount = calculate_discount(item['type'])
    return {
        **item,
        'discount': discount,
        'final_price': item['price'] * (1 - discount)
    }

def process_data(data: list[dict]) -> list[dict]:
    return [
        processed
        for item in data
        if (processed := process_item(item)) is not None
    ]

Query: "function that validates email"
→ Finds: validateEmail(), isValidEmail(), checkEmailFormat()

Query: "error handling for API calls"
→ Finds: try/catch blocks, error middleware, response handlers

Query: "database connection setup"
→ Finds: connectDB(), initializeDatabase(), createPool()

Query: "authentication middleware"
→ Finds: authMiddleware, verifyToken, requireAuth

1. Cmd/Ctrl + Shift + P → "Codeium: Search"
2. Type a query by meaning
3. Browse results from different files
4. Click to navigate to the code

# Codeium understands type hints and docstrings

from typing import Optional, List
from dataclasses import dataclass

@dataclass
class Product:
    id: str
    name: str
    price: float
    category: str

def filter_products(
    products: List[Product],
    min_price: Optional[float] = None,
    category: Optional[str] = None
) -> List[Product]:
    # Codeium suggests:
    result = products

    if min_price is not None:
        result = [p for p in result if p.price >= min_price]

    if category is not None:
        result = [p for p in result if p.category == category]

    return result

// Codeium understands ownership and lifetimes

use std::collections::HashMap;

struct Cache<T> {
    data: HashMap<String, T>,
    max_size: usize,
}

impl<T: Clone> Cache<T> {
    fn new(max_size: usize) -> Self {
        // Codeium:
        Self {
            data: HashMap::new(),
            max_size,
        }
    }

    fn get(&self, key: &str) -> Option<T> {
        // Codeium:
        self.data.get(key).cloned()
    }

    fn set(&mut self, key: String, value: T) {
        // Codeium:
        if self.data.len() >= self.max_size {
            // Remove oldest entry (simplified)
            if let Some(first_key) = self.data.keys().next().cloned() {
                self.data.remove(&first_key);
            }
        }
        self.data.insert(key, value);
    }
}

// Codeium understands Go idioms

package main

import (
    "encoding/json"
    "net/http"
    "sync"
)

type UserService struct {
    mu    sync.RWMutex
    users map[string]*User
}

func NewUserService() *UserService {
    // Codeium:
    return &UserService{
        users: make(map[string]*User),
    }
}

func (s *UserService) GetUser(id string) (*User, error) {
    // Codeium:
    s.mu.RLock()
    defer s.mu.RUnlock()

    user, ok := s.users[id]
    if !ok {
        return nil, ErrUserNotFound
    }
    return user, nil
}

func (s *UserService) CreateUser(user *User) error {
    // Codeium:
    s.mu.Lock()
    defer s.mu.Unlock()

    if _, exists := s.users[user.ID]; exists {
        return ErrUserExists
    }
    s.users[user.ID] = user
    return nil
}

-- Codeium understands schemas and relationships

-- After defining tables:
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL,
    name VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE orders (
    id SERIAL PRIMARY KEY,
    user_id INTEGER REFERENCES users(id),
    total DECIMAL(10, 2) NOT NULL,
    status VARCHAR(50) DEFAULT 'pending',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Start typing - Codeium suggests:
SELECT
    u.name,
    u.email,
    COUNT(o.id) as order_count,
    SUM(o.total) as total_spent
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
WHERE o.status = 'completed'
GROUP BY u.id, u.name, u.email
HAVING SUM(o.total) > 100
ORDER BY total_spent DESC;

// settings.json
{
  // Enable/disable Codeium
  "codeium.enableConfig": {
    "*": true,
    "markdown": false,
    "plaintext": false
  },

  // Delay before showing suggestions (ms)
  "codeium.completionDelay": 100,

  // Maximum number of lines in a suggestion
  "codeium.maxCompletionLines": 10,

  // Show inline suggestions
  "codeium.enableInlineCompletion": true,

  // Show status in the bar
  "codeium.showStatusBar": true,

  // Automatic acceptance
  "codeium.enableAutoAccept": false
}

// .codeiumignore (in the project root directory)
// Works like .gitignore

# Ignore configuration files
*.config.js
*.env*

# Ignore generated code
generated/
dist/
build/

# Ignore vendor
vendor/
node_modules/

# Ignore specific files
secrets.json
credentials.yaml

# codeium-config.yaml
enterprise:
  # Custom endpoint (on-premise)
  api_url: https://codeium.your-company.com

  # Telemetry
  telemetry_enabled: false

  # Using code for training
  training_opt_out: true

  # Allowed languages
  allowed_languages:
    - python
    - javascript
    - typescript
    - go

  # Blocked repositories
  blocked_repos:
    - internal-secrets
    - legacy-codebase

1. Code is NOT used for model training (opt-in)
2. Snippets are processed but not stored
3. Data is encrypted in transit (TLS 1.3)
4. No code logging on servers

// VS Code settings
{
  // Disable telemetry
  "codeium.telemetryEnabled": false,

  // Disable using code to improve the model
  "codeium.enableModelImprovement": false
}

# For organizations requiring high security

deployment:
  type: on-premise  # Or private-cloud

security:
  encryption_at_rest: AES-256
  network_isolation: true
  audit_logging: true

compliance:
  soc2: true
  hipaa: available
  gdpr: true

#!/bin/bash
# .git/hooks/pre-commit

# Check if Codeium left any TODO comments
if grep -r "// Codeium:" --include="*.ts" --include="*.js" .; then
  echo "Error: Found Codeium comments in code"
  exit 1
fi

# GitHub Actions - check code quality
name: Code Quality

on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Check for AI-generated TODOs
        run: |
          if grep -r "TODO.*Codeium\|FIXME.*generated" .; then
            echo "Review AI-generated code before committing"
            exit 1
          fi

# Checklist for AI-generated code

- [ ] Does the code do what it should?
- [ ] Are there edge cases to handle?
- [ ] Are variable names sensible?
- [ ] Is the logic clear?
- [ ] Are there potential performance issues?
- [ ] Is the code tested?

// ❌ Weak context
function process(data) {
  // Codeium doesn't know what to do
}

// ✅ Good context
interface OrderData {
  items: CartItem[]
  customer: Customer
  shipping: ShippingMethod
}

/**
 * Process order and calculate final price including:
 * - Item prices with quantities
 * - Shipping cost based on method
 * - Tax based on customer location
 * - Any applicable discounts
 */
function processOrder(data: OrderData): ProcessedOrder {
  // Codeium has full context
}

# Always verify generated code

# Codeium may suggest:
def divide(a, b):
    return a / b

# But this is better:
def divide(a: float, b: float) -> float:
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

// Comments help Codeium understand your intent

// Fetch user data from API, handle errors, and cache result
async function getUserWithCache(userId) {
  // Codeium generates better code with this context
}

// Sort users by last activity, most recent first
const sortedUsers = users.sort((a, b) => {
  // Codeium knows what you expect
})