claudient 0.1.0

package/prompts/project-starters/fr/nextjs-project.md

@@ -0,0 +1,82 @@
+> 🇫🇷 This is the French translation. [English version](../nextjs-project.md).
+
+# Starter de Projet : Next.js
+
+Utilisez ce prompt pour lancer un nouveau projet Next.js avec Claude Code.
+
+---
+
+## Prompt de démarrage
+
+```
+Bootstrap a new Next.js 15 project with production-ready defaults.
+
+Project: [name and one-sentence description]
+Stack: Next.js 15 (App Router), TypeScript, Tailwind CSS, shadcn/ui
+Database: PostgreSQL with Prisma
+Auth: [Clerk / NextAuth.js / custom JWT]
+Testing: Vitest + React Testing Library
+
+Create the following structure:
+src/
+├── app/
+│   ├── (auth)/           ← Auth routes (sign-in, sign-up)
+│   ├── (dashboard)/      ← Protected routes
+│   ├── api/              ← API route handlers
+│   ├── layout.tsx        ← Root layout
+│   └── page.tsx          ← Landing page
+├── components/
+│   ├── ui/               ← shadcn/ui components (auto-generated)
+│   └── [feature]/        ← Feature-specific components
+├── lib/
+│   ├── db.ts             ← Prisma client singleton
+│   ├── auth.ts           ← Auth utilities
+│   └── utils.ts          ← cn() and shared utilities
+├── server/               ← Server-only code (no client imports)
+│   └── actions/          ← Server actions
+└── types/                ← Shared TypeScript types
+
+prisma/
+├── schema.prisma
+└── migrations/
+
+Start with:
+1. Show the full directory structure
+2. package.json with pinned versions
+3. tsconfig.json and tailwind.config.ts
+4. Root layout.tsx and a working landing page
+5. Prisma schema with a User model
+6. Verify it runs: npm run dev
+
+Do not add features yet — skeleton only.
+```
+
+---
+
+## Conventions clés à appliquer
+
+À ajouter dans CLAUDE.md après le bootstrap :
+
+```markdown
+## Conventions Next.js
+- Server Components par défaut — ajouter 'use client' uniquement quand nécessaire (gestionnaires d'événements, hooks, APIs navigateur)
+- Server Actions pour les mutations — ne jamais appeler les routes API depuis les Server Components
+- Ne jamais importer du code server-only dans les Client Components (utiliser la frontière du répertoire server/)
+- Routes API uniquement pour : webhooks, callbacks OAuth, réponses en streaming
+- Client Prisma : singleton dans lib/db.ts — ne jamais instancier inline
+- Tous les accès à la base de données dans server/ — jamais dans les Client Components
+```
+
+---
+
+## Que faire ensuite
+
+Une fois le squelette en cours d'exécution :
+
+1. Configurer l'auth : "Configure [Clerk/NextAuth] with the auth routes we set up"
+2. Ajouter la première page : "Create a dashboard page showing [resource] with a data table"
+3. Ajouter la première mutation : "Add a server action to create [resource] with form validation"
+
+---
+
+> **Travaillez avec nous :** Claudient est soutenu par [Uitbreiden](https://uitbreiden.com/) — nous construisons des produits IA et des solutions B2B avec des communautés de développeurs. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/project-starters/nextjs-project.md

@@ -0,0 +1,80 @@
+# Project Starter: Next.js
+
+Use this prompt to kick off a new Next.js project with Claude Code.
+
+---
+
+## Kickoff prompt
+
+```
+Bootstrap a new Next.js 15 project with production-ready defaults.
+
+Project: [name and one-sentence description]
+Stack: Next.js 15 (App Router), TypeScript, Tailwind CSS, shadcn/ui
+Database: PostgreSQL with Prisma
+Auth: [Clerk / NextAuth.js / custom JWT]
+Testing: Vitest + React Testing Library
+
+Create the following structure:
+src/
+├── app/
+│   ├── (auth)/           ← Auth routes (sign-in, sign-up)
+│   ├── (dashboard)/      ← Protected routes
+│   ├── api/              ← API route handlers
+│   ├── layout.tsx        ← Root layout
+│   └── page.tsx          ← Landing page
+├── components/
+│   ├── ui/               ← shadcn/ui components (auto-generated)
+│   └── [feature]/        ← Feature-specific components
+├── lib/
+│   ├── db.ts             ← Prisma client singleton
+│   ├── auth.ts           ← Auth utilities
+│   └── utils.ts          ← cn() and shared utilities
+├── server/               ← Server-only code (no client imports)
+│   └── actions/          ← Server actions
+└── types/                ← Shared TypeScript types
+
+prisma/
+├── schema.prisma
+└── migrations/
+
+Start with:
+1. Show the full directory structure
+2. package.json with pinned versions
+3. tsconfig.json and tailwind.config.ts
+4. Root layout.tsx and a working landing page
+5. Prisma schema with a User model
+6. Verify it runs: npm run dev
+
+Do not add features yet — skeleton only.
+```
+
+---
+
+## Key conventions to enforce
+
+Add to CLAUDE.md after bootstrap:
+
+```markdown
+## Next.js conventions
+- Server Components by default — add 'use client' only when needed (event handlers, hooks, browser APIs)
+- Server Actions for mutations — never call API routes from Server Components
+- Never import server-only code in Client Components (use server/ directory boundary)
+- API routes only for: webhooks, OAuth callbacks, streaming responses
+- Prisma client: singleton in lib/db.ts — never instantiate inline
+- All database access in server/ — never in Client Components
+```
+
+---
+
+## What to do next
+
+After the skeleton runs:
+
+1. Set up auth: "Configure [Clerk/NextAuth] with the auth routes we set up"
+2. Add first page: "Create a dashboard page showing [resource] with a data table"
+3. Add first mutation: "Add a server action to create [resource] with form validation"
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/project-starters/nl/fastapi-project.md

@@ -0,0 +1,62 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../fastapi-project.md).
+
+# Project Starter: FastAPI
+
+Gebruik deze prompt om een nieuw FastAPI-project op te starten met Claude Code.
+
+---
+
+## Opstartprompt
+
+```
+Bootstrap a new FastAPI project with production-ready defaults.
+
+Project: [name and one-sentence description]
+Database: PostgreSQL with SQLAlchemy async + Alembic migrations
+Auth: JWT (python-jose) with refresh tokens
+Testing: pytest + httpx async client
+
+Create the following structure:
+app/
+├── api/
+│   └── v1/
+│       ├── routes/       ← One file per resource (users.py, items.py, etc.)
+│       └── deps.py       ← Shared dependencies (get_db, get_current_user)
+├── core/
+│   ├── config.py         ← Settings via pydantic-settings
+│   ├── security.py       ← JWT creation and validation
+│   └── database.py       ← Async engine and session factory
+├── models/               ← SQLAlchemy ORM models
+├── schemas/              ← Pydantic request/response schemas
+├── services/             ← Business logic (no HTTP, no ORM)
+├── tests/
+│   ├── conftest.py       ← Test database, async client, fixtures
+│   └── test_[resource].py
+├── alembic/              ← Migration files
+├── main.py               ← App factory
+└── requirements.txt      ← Pinned versions
+
+Start with:
+1. Show the full directory structure
+2. Create requirements.txt with pinned versions
+3. Create main.py with app factory pattern
+4. Create core/config.py with Settings class
+5. Create core/database.py with async session
+6. Verify it starts with: uvicorn main:app --reload
+
+Do not add business logic yet — skeleton only.
+```
+
+---
+
+## Wat hierna te doen
+
+Nadat het skelet draait:
+
+1. Voeg je eerste resource toe: "Voeg een User-model toe, CRUD-endpoints (GET /users, POST /users, GET /users/{id}) en tests"
+2. Voeg auth toe: "Implementeer JWT-login en refresh token-endpoints met de security.py die we hebben ingesteld"
+3. Voeg de eerste bedrijfsfunctie toe met de feature-development workflow
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/project-starters/nl/nextjs-project.md

@@ -0,0 +1,82 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../nextjs-project.md).
+
+# Project Starter: Next.js
+
+Gebruik deze prompt om een nieuw Next.js-project op te starten met Claude Code.
+
+---
+
+## Opstartprompt
+
+```
+Bootstrap a new Next.js 15 project with production-ready defaults.
+
+Project: [name and one-sentence description]
+Stack: Next.js 15 (App Router), TypeScript, Tailwind CSS, shadcn/ui
+Database: PostgreSQL with Prisma
+Auth: [Clerk / NextAuth.js / custom JWT]
+Testing: Vitest + React Testing Library
+
+Create the following structure:
+src/
+├── app/
+│   ├── (auth)/           ← Auth routes (sign-in, sign-up)
+│   ├── (dashboard)/      ← Protected routes
+│   ├── api/              ← API route handlers
+│   ├── layout.tsx        ← Root layout
+│   └── page.tsx          ← Landing page
+├── components/
+│   ├── ui/               ← shadcn/ui components (auto-generated)
+│   └── [feature]/        ← Feature-specific components
+├── lib/
+│   ├── db.ts             ← Prisma client singleton
+│   ├── auth.ts           ← Auth utilities
+│   └── utils.ts          ← cn() and shared utilities
+├── server/               ← Server-only code (no client imports)
+│   └── actions/          ← Server actions
+└── types/                ← Shared TypeScript types
+
+prisma/
+├── schema.prisma
+└── migrations/
+
+Start with:
+1. Show the full directory structure
+2. package.json with pinned versions
+3. tsconfig.json and tailwind.config.ts
+4. Root layout.tsx and a working landing page
+5. Prisma schema with a User model
+6. Verify it runs: npm run dev
+
+Do not add features yet — skeleton only.
+```
+
+---
+
+## Toe te passen conventies
+
+Voeg toe aan CLAUDE.md na bootstrap:
+
+```markdown
+## Next.js conventies
+- Server Components standaard — voeg 'use client' alleen toe wanneer nodig (event handlers, hooks, browser API's)
+- Server Actions voor mutaties — roep API-routes nooit aan vanuit Server Components
+- Importeer nooit alleen-server-code in Client Components (gebruik server/-directory-grens)
+- API-routes alleen voor: webhooks, OAuth callbacks, streamingantwoorden
+- Prisma client: singleton in lib/db.ts — nooit inline instantiëren
+- Alle databasetoegang in server/ — nooit in Client Components
+```
+
+---
+
+## Wat hierna te doen
+
+Nadat het skelet draait:
+
+1. Auth instellen: "Configureer [Clerk/NextAuth] met de auth-routes die we hebben ingesteld"
+2. Eerste pagina toevoegen: "Maak een dashboardpagina die [resource] toont met een datatabella"
+3. Eerste mutatie toevoegen: "Voeg een server action toe om [resource] aan te maken met formuliervalidatie"
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/system-prompts/ai-product.md

@@ -0,0 +1,80 @@
+# CLAUDE.md Starter — AI Product
+
+Drop this into your project's `CLAUDE.md` and fill in the bracketed sections.
+
+---
+
+```markdown
+# [Project Name] — Claude Code Instructions
+
+## What this is
+[One paragraph: what the AI product does, what model it uses, who the users are]
+
+## Stack
+- Language: [TypeScript / Python]
+- Framework: [Next.js / FastAPI]
+- AI: [Claude API via Anthropic SDK / OpenAI / Gemini]
+- Model: [claude-sonnet-4-6 / claude-opus-4-7 / claude-haiku-4-5]
+- Database: [PostgreSQL / Supabase]
+- Vector DB: [Pinecone / pgvector / Weaviate] (if applicable)
+- Deployment: [Vercel / AWS / Railway]
+
+## Project structure
+src/
+├── app/          ← Next.js app router / FastAPI routes
+├── ai/           ← All AI-related code: prompts, chains, tools
+│   ├── prompts/  ← System prompts and prompt templates
+│   ├── tools/    ← Tool definitions for function calling
+│   └── agents/   ← Agent definitions and orchestration
+├── db/           ← Database queries and migrations
+├── services/     ← Business logic
+└── utils/        ← Pure utilities
+
+## AI conventions
+- All system prompts live in src/ai/prompts/ — never inline in route handlers
+- Always pin the model version — never use "latest" alias
+- Always enable prompt caching on system prompts (cache_control: ephemeral)
+- Log token usage per request for cost tracking
+- Streaming responses: use SSE for responses > 1000 tokens
+- Never pass user PII to the model unless the feature explicitly requires it
+- Tool definitions live in src/ai/tools/ — one file per tool
+
+## Prompt caching setup
+- System prompts must use cache_control to enable caching
+- Cache read = $0.30/MTok vs uncached = $3/MTok — always cache
+- Invalidate cache when system prompt changes (automatic on content change)
+
+## Cost controls
+- Default model: [claude-haiku-4-5] for simple tasks, [claude-sonnet-4-6] for complex
+- Max tokens: set explicit max_tokens on every request — never unlimited
+- Rate limit: [X] requests per user per minute
+- Budget alert: log when a single session exceeds $[X]
+
+## Decisions (do not re-discuss)
+- [Model selection rationale]
+- [Why streaming vs. non-streaming]
+- [Context window strategy: summarize at N tokens]
+- [Tool calling vs. direct generation for structured output]
+
+## Testing
+- Unit tests for prompt construction and output parsing
+- Integration tests with recorded API responses (VCR / fixtures)
+- Never make real API calls in tests — costs money and is slow
+- Test adversarial inputs: prompt injection, jailbreak attempts, edge cases
+
+## Commands
+- [dev command]
+- [test command]
+- [deploy command]
+
+## Never do
+- Never inline system prompts in route handlers
+- Never make unbounded AI calls without max_tokens
+- Never log full AI responses in production (may contain user PII)
+- Never hardcode API keys — use environment variables
+- Never call the AI model directly from UI components
+```
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/system-prompts/data-pipeline.md

@@ -0,0 +1,76 @@
+# CLAUDE.md Starter — Data Pipeline Project
+
+Drop this into your project's `CLAUDE.md` and fill in the bracketed sections.
+
+---
+
+```markdown
+# [Project Name] — Claude Code Instructions
+
+## What this is
+[One paragraph: what data this pipeline processes, source systems, destination, business purpose]
+
+## Stack
+- Orchestrator: [Airflow / Prefect / Dagster / dbt Cloud]
+- Transformation: [dbt / PySpark / Pandas / Polars]
+- Warehouse: [BigQuery / Snowflake / Redshift / DuckDB]
+- Ingestion: [Fivetran / Airbyte / custom]
+- Language: [Python / SQL]
+- Infra: [Terraform on AWS / GCP / Azure]
+
+## Project structure
+dbt/ (if using dbt)
+├── models/
+│   ├── staging/      ← 1:1 with source tables, light cleaning only
+│   ├── intermediate/ ← Business logic, joins
+│   └── marts/        ← Final business entities (fct_, dim_ prefixes)
+├── macros/           ← Reusable SQL macros
+├── seeds/            ← Static reference data
+└── tests/            ← Custom singular tests
+
+pipelines/ (if using Airflow/Prefect/Dagster)
+├── dags/ / flows/    ← Pipeline definitions
+├── operators/        ← Custom operators/tasks
+└── utils/            ← Shared utilities
+
+## Data conventions
+- Staging models: rename to snake_case, cast types, no joins, no business logic
+- Fact tables: fct_ prefix, one row per event/transaction
+- Dimension tables: dim_ prefix, one row per entity
+- Never use SELECT * in production queries
+- All mart models must have unique + not_null tests on primary key
+- Source freshness checks required on all sources
+
+## Decisions (do not re-discuss)
+- [Incremental vs full-refresh strategy for fact tables]
+- [Timezone: all timestamps in UTC]
+- [Grain: what one row in each mart table represents]
+- [Late-arriving data handling strategy]
+
+## Testing requirements
+- Every staging model: not_null on primary key
+- Every mart model: unique + not_null on primary key, relationships on foreign keys
+- Source freshness: warn at [X] hours, error at [Y] hours
+
+## Performance rules
+- Partition large tables by date — always filter on partition column
+- Use incremental models for tables > [X] rows
+- Never run full refreshes in production without approval
+- Cluster/sort keys: [specify if using Snowflake/Redshift]
+
+## Commands
+- dbt run --select staging — run staging layer
+- dbt test — run all tests
+- dbt docs generate && dbt docs serve — preview documentation
+- dbt source freshness — check source data freshness
+
+## Never do
+- Never put business logic in staging models
+- Never hardcode dates — use dbt variables or macros
+- Never commit real credentials — use environment variables or secrets manager
+- Never run dbt run in production without dbt test passing first
+```
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/system-prompts/de/ai-product.md

@@ -0,0 +1,82 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../ai-product.md).
+
+# CLAUDE.md Starter — KI-Produkt
+
+Dies in die `CLAUDE.md` des Projekts einfügen und die Abschnitte in eckigen Klammern ausfüllen.
+
+---
+
+```markdown
+# [Projektname] — Claude Code Anweisungen
+
+## Was das ist
+[Ein Absatz: was das KI-Produkt tut, welches Modell es verwendet, wer die Benutzer sind]
+
+## Stack
+- Sprache: [TypeScript / Python]
+- Framework: [Next.js / FastAPI]
+- KI: [Claude API via Anthropic SDK / OpenAI / Gemini]
+- Modell: [claude-sonnet-4-6 / claude-opus-4-7 / claude-haiku-4-5]
+- Datenbank: [PostgreSQL / Supabase]
+- Vektor-DB: [Pinecone / pgvector / Weaviate] (falls zutreffend)
+- Deployment: [Vercel / AWS / Railway]
+
+## Projektstruktur
+src/
+├── app/          ← Next.js App Router / FastAPI Routes
+├── ai/           ← Gesamter KI-bezogener Code: Prompts, Chains, Tools
+│   ├── prompts/  ← System-Prompts und Prompt-Templates
+│   ├── tools/    ← Tool-Definitionen für Function Calling
+│   └── agents/   ← Agentendefinitionen und Orchestrierung
+├── db/           ← Datenbankabfragen und Migrationen
+├── services/     ← Business-Logik
+└── utils/        ← Reine Utilities
+
+## KI-Konventionen
+- Alle System-Prompts befinden sich in src/ai/prompts/ — niemals inline in Route-Handlern
+- Immer die Modellversion pinnen — niemals "latest"-Alias verwenden
+- Prompt Caching auf System-Prompts immer aktivieren (cache_control: ephemeral)
+- Token-Nutzung pro Anfrage für Kostenverfolgung protokollieren
+- Streaming-Antworten: SSE für Antworten > 1000 Tokens verwenden
+- Niemals Benutzer-PII an das Modell übergeben, außer das Feature erfordert es explizit
+- Tool-Definitionen befinden sich in src/ai/tools/ — eine Datei pro Tool
+
+## Prompt Caching Setup
+- System-Prompts müssen cache_control verwenden, um Caching zu aktivieren
+- Cache-Lesen = $0.30/MTok vs. ungespeichert = $3/MTok — immer cachen
+- Cache ungültig machen, wenn sich der System-Prompt ändert (automatisch bei Inhaltsänderung)
+
+## Kostenkontrolle
+- Standardmodell: [claude-haiku-4-5] für einfache Aufgaben, [claude-sonnet-4-6] für komplexe
+- Max Tokens: explizites max_tokens bei jeder Anfrage setzen — niemals unbegrenzt
+- Rate Limit: [X] Anfragen pro Benutzer pro Minute
+- Budget-Alert: protokollieren, wenn eine einzelne Sitzung $[X] überschreitet
+
+## Entscheidungen (nicht neu diskutieren)
+- [Modellauswahl-Begründung]
+- [Warum Streaming vs. Nicht-Streaming]
+- [Kontextfenster-Strategie: Zusammenfassen bei N Tokens]
+- [Tool Calling vs. direkte Generierung für strukturierte Ausgabe]
+
+## Tests
+- Unit-Tests für Prompt-Konstruktion und Ausgabe-Parsing
+- Integrationstests mit aufgezeichneten API-Antworten (VCR / Fixtures)
+- Niemals echte API-Aufrufe in Tests machen — kostet Geld und ist langsam
+- Gegnerische Eingaben testen: Prompt Injection, Jailbreak-Versuche, Edge Cases
+
+## Befehle
+- [Dev-Befehl]
+- [Test-Befehl]
+- [Deploy-Befehl]
+
+## Niemals tun
+- Niemals System-Prompts inline in Route-Handlern
+- Niemals ungebundene KI-Aufrufe ohne max_tokens
+- Niemals vollständige KI-Antworten in der Produktion protokollieren (kann Benutzer-PII enthalten)
+- Niemals API-Keys hardcoden — Umgebungsvariablen verwenden
+- Niemals das KI-Modell direkt aus UI-Komponenten aufrufen
+```
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/system-prompts/de/data-pipeline.md

@@ -0,0 +1,78 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../data-pipeline.md).
+
+# CLAUDE.md Starter — Data Pipeline Projekt
+
+Dies in die `CLAUDE.md` des Projekts einfügen und die Abschnitte in eckigen Klammern ausfüllen.
+
+---
+
+```markdown
+# [Projektname] — Claude Code Anweisungen
+
+## Was das ist
+[Ein Absatz: welche Daten diese Pipeline verarbeitet, Quellsysteme, Ziel, geschäftlicher Zweck]
+
+## Stack
+- Orchestrator: [Airflow / Prefect / Dagster / dbt Cloud]
+- Transformation: [dbt / PySpark / Pandas / Polars]
+- Warehouse: [BigQuery / Snowflake / Redshift / DuckDB]
+- Ingestion: [Fivetran / Airbyte / custom]
+- Sprache: [Python / SQL]
+- Infra: [Terraform auf AWS / GCP / Azure]
+
+## Projektstruktur
+dbt/ (falls dbt verwendet wird)
+├── models/
+│   ├── staging/      ← 1:1 mit Quelltabellen, nur leichte Bereinigung
+│   ├── intermediate/ ← Business-Logik, Joins
+│   └── marts/        ← Finale Business-Entitäten (fct_, dim_-Präfixe)
+├── macros/           ← Wiederverwendbare SQL-Makros
+├── seeds/            ← Statische Referenzdaten
+└── tests/            ← Benutzerdefinierte singuläre Tests
+
+pipelines/ (falls Airflow/Prefect/Dagster verwendet wird)
+├── dags/ / flows/    ← Pipeline-Definitionen
+├── operators/        ← Benutzerdefinierte Operatoren/Tasks
+└── utils/            ← Gemeinsame Utilities
+
+## Datenkonventionen
+- Staging-Modelle: in snake_case umbenennen, Typen casten, keine Joins, keine Business-Logik
+- Faktentabellen: fct_-Präfix, eine Zeile pro Ereignis/Transaktion
+- Dimensionstabellen: dim_-Präfix, eine Zeile pro Entität
+- Niemals SELECT * in Produktionsabfragen verwenden
+- Alle Mart-Modelle müssen unique + not_null-Tests auf dem Primärschlüssel haben
+- Frische-Prüfungen für alle Sources erforderlich
+
+## Entscheidungen (nicht neu diskutieren)
+- [Incremental vs. Full-Refresh-Strategie für Faktentabellen]
+- [Zeitzone: alle Timestamps in UTC]
+- [Granularität: was eine Zeile in jeder Mart-Tabelle repräsentiert]
+- [Strategie zur Behandlung verspäteter Daten]
+
+## Testanforderungen
+- Jedes Staging-Modell: not_null auf Primärschlüssel
+- Jedes Mart-Modell: unique + not_null auf Primärschlüssel, Beziehungen auf Fremdschlüssel
+- Source-Frische: Warnung nach [X] Stunden, Fehler nach [Y] Stunden
+
+## Performance-Regeln
+- Große Tabellen nach Datum partitionieren — immer nach Partitionsspalte filtern
+- Inkrementelle Modelle für Tabellen > [X] Zeilen verwenden
+- Niemals vollständige Refreshes in der Produktion ohne Genehmigung ausführen
+- Cluster/Sort-Keys: [angeben, wenn Snowflake/Redshift verwendet wird]
+
+## Befehle
+- dbt run --select staging — Staging-Layer ausführen
+- dbt test — alle Tests ausführen
+- dbt docs generate && dbt docs serve — Dokumentation vorschauen
+- dbt source freshness — Frische der Quelldaten prüfen
+
+## Niemals tun
+- Niemals Business-Logik in Staging-Modellen
+- Niemals Daten hardcoden — dbt-Variablen oder Makros verwenden
+- Niemals echte Anmeldedaten committen — Umgebungsvariablen oder Secrets Manager verwenden
+- Niemals dbt run in der Produktion ohne bestandenes dbt test ausführen
+```
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. [uitbreiden.com](https://uitbreiden.com/)