claudient 0.1.0

package/prompts/system-prompts/de/saas-backend.md

@@ -0,0 +1,71 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../saas-backend.md).
+
+# CLAUDE.md Starter — SaaS Backend
+
+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 Produkt tut, wer es verwendet, welches Problem es löst]
+
+## Stack
+- Sprache: [TypeScript / Python / Go]
+- Framework: [Express / FastAPI / Gin / NestJS]
+- Datenbank: [PostgreSQL via Prisma / raw pg / SQLAlchemy]
+- Auth: [JWT mit 15-min Access Tokens + 7-Tage Refresh Tokens / Clerk / Auth0]
+- Cache: [Redis]
+- Queue: [BullMQ / SQS / Celery]
+- Deployment: [AWS ECS / Fly.io / Railway]
+
+## Projektstruktur
+src/
+├── api/          ← Route-Handler — dünn, delegieren an Services
+├── services/     ← Business-Logik — keine HTTP-Belange
+├── db/           ← Datenbankabfragen — keine Business-Logik
+├── middleware/   ← Auth, Rate Limiting, Fehlerbehandlung
+├── models/       ← Typdefinitionen und Schemas
+└── utils/        ← Reine Funktionen, keine Nebeneffekte
+
+## Konventionen
+- Route-Handler sind dünn: Eingabe validieren, Service aufrufen, Antwort zurückgeben
+- Services enthalten alle Business-Logik: sie kennen kein HTTP
+- DB-Layer enthält nur Abfragen: keine Business-Logik, keine HTTP-Belange
+- Alle Datenbankzugriffe gehen durch den db/-Layer — niemals ORM direkt aus Services aufrufen
+- Fehler propagieren nach oben mit Kontext — niemals stillschweigend schlucken
+- Alle API-Routes zurückgeben: 200 (Erfolg), 201 (erstellt), 204 (kein Inhalt), 400 (schlechte Eingabe), 401 (unauth), 403 (verboten), 404 (nicht gefunden), 409 (Konflikt), 422 (Validierung), 500 (unerwartet)
+
+## Entscheidungen (nicht neu diskutieren)
+- [Auth-Mechanismus entschieden: JWT, keine Sessions]
+- [ORM-Wahl: Prisma — kein rohes SQL außer für komplexe Analytics-Abfragen]
+- [Fehlerformat: { error: string, code: string } — Form niemals ändern]
+- [Keine Barrel-Dateien — direkt aus der Quelle importieren]
+
+## Tests
+- Integrationstests treffen eine echte Test-Datenbank — keine DB-Mocks
+- Unit-Tests für reine Business-Logik in services/
+- Testdatei: [dateiname].test.ts neben der Quelldatei
+- Ausführen: npm test
+
+## Befehle
+- npm run dev — Entwicklungsserver mit Hot Reload starten
+- npm test — alle Tests ausführen
+- npm run build — Produktions-Build
+- npm run lint — ESLint + Prettier-Prüfung
+- npm run db:migrate — ausstehende Migrationen ausführen
+- npm run db:seed — Entwicklungsdaten seeden
+
+## Niemals tun
+- Niemals Business-Logik in Route-Handlern
+- Niemals die Datenbank direkt aus Route-Handlern aufrufen
+- Niemals rohe Datenbankfehler an Clients zurückgeben
+- Niemals .env-Dateien committen
+- Niemals `any`-Typ in TypeScript verwenden
+```
+
+---
+
+> **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/es/ai-product.md

@@ -0,0 +1,82 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../ai-product.md).
+
+# CLAUDE.md Starter — Producto de IA
+
+Copia esto en el `CLAUDE.md` de tu proyecto y completa las secciones entre corchetes.
+
+---
+
+```markdown
+# [Nombre del Proyecto] — Instrucciones para Claude Code
+
+## Qué es esto
+[Un párrafo: qué hace el producto de IA, qué modelo usa, quiénes son los usuarios]
+
+## Stack
+- Lenguaje: [TypeScript / Python]
+- Framework: [Next.js / FastAPI]
+- IA: [Claude API via Anthropic SDK / OpenAI / Gemini]
+- Modelo: [claude-sonnet-4-6 / claude-opus-4-7 / claude-haiku-4-5]
+- Base de datos: [PostgreSQL / Supabase]
+- BD Vectorial: [Pinecone / pgvector / Weaviate] (si aplica)
+- Despliegue: [Vercel / AWS / Railway]
+
+## Estructura del proyecto
+src/
+├── app/          ← Rutas del router de Next.js / FastAPI
+├── ai/           ← Todo el código relacionado con IA: prompts, chains, herramientas
+│   ├── prompts/  ← Prompts de sistema y plantillas de prompts
+│   ├── tools/    ← Definiciones de herramientas para function calling
+│   └── agents/   ← Definiciones de agentes y orquestación
+├── db/           ← Consultas a la base de datos y migraciones
+├── services/     ← Lógica de negocio
+└── utils/        ← Utilidades puras
+
+## Convenciones de IA
+- Todos los prompts de sistema viven en src/ai/prompts/ — nunca inline en los route handlers
+- Siempre fija la versión del modelo — nunca uses el alias "latest"
+- Siempre habilita el caché de prompts en los prompts de sistema (cache_control: ephemeral)
+- Registra el uso de tokens por solicitud para seguimiento de costos
+- Respuestas con streaming: usa SSE para respuestas > 1000 tokens
+- Nunca pases PII del usuario al modelo a menos que la funcionalidad lo requiera explícitamente
+- Las definiciones de herramientas viven en src/ai/tools/ — un archivo por herramienta
+
+## Configuración de caché de prompts
+- Los prompts de sistema deben usar cache_control para habilitar el caché
+- Lectura de caché = $0.30/MTok vs sin caché = $3/MTok — siempre cachea
+- Invalida el caché cuando el prompt de sistema cambia (automático al cambiar el contenido)
+
+## Controles de costo
+- Modelo por defecto: [claude-haiku-4-5] para tareas simples, [claude-sonnet-4-6] para complejas
+- Tokens máximos: establece max_tokens explícito en cada solicitud — nunca ilimitado
+- Límite de tasa: [X] solicitudes por usuario por minuto
+- Alerta de presupuesto: registra cuando una sesión individual supera $[X]
+
+## Decisiones (no re-discutir)
+- [Justificación de la selección del modelo]
+- [Por qué streaming vs. no-streaming]
+- [Estrategia de ventana de contexto: resumir en N tokens]
+- [Tool calling vs. generación directa para salida estructurada]
+
+## Testing
+- Pruebas unitarias para construcción de prompts y parseo de salida
+- Pruebas de integración con respuestas de API grabadas (VCR / fixtures)
+- Nunca hagas llamadas reales a la API en pruebas — cuesta dinero y es lento
+- Prueba entradas adversariales: inyección de prompts, intentos de jailbreak, casos límite
+
+## Comandos
+- [comando de desarrollo]
+- [comando de pruebas]
+- [comando de despliegue]
+
+## Nunca hacer
+- Nunca pongas prompts de sistema inline en los route handlers
+- Nunca hagas llamadas de IA sin límite sin max_tokens
+- Nunca registres respuestas completas de IA en producción (pueden contener PII del usuario)
+- Nunca hardcodees claves de API — usa variables de entorno
+- Nunca llames al modelo de IA directamente desde componentes de UI
+```
+
+---
+
+> **Trabaja con nosotros:** Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA y soluciones B2B con comunidades de desarrolladores. [uitbreiden.com](https://uitbreiden.com/)

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

@@ -0,0 +1,78 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../data-pipeline.md).
+
+# CLAUDE.md Starter — Proyecto de Pipeline de Datos
+
+Copia esto en el `CLAUDE.md` de tu proyecto y completa las secciones entre corchetes.
+
+---
+
+```markdown
+# [Nombre del Proyecto] — Instrucciones para Claude Code
+
+## Qué es esto
+[Un párrafo: qué datos procesa este pipeline, sistemas fuente, destino, propósito de negocio]
+
+## Stack
+- Orquestador: [Airflow / Prefect / Dagster / dbt Cloud]
+- Transformación: [dbt / PySpark / Pandas / Polars]
+- Warehouse: [BigQuery / Snowflake / Redshift / DuckDB]
+- Ingesta: [Fivetran / Airbyte / personalizado]
+- Lenguaje: [Python / SQL]
+- Infraestructura: [Terraform en AWS / GCP / Azure]
+
+## Estructura del proyecto
+dbt/ (si se usa dbt)
+├── models/
+│   ├── staging/      ← 1:1 con tablas fuente, solo limpieza ligera
+│   ├── intermediate/ ← Lógica de negocio, joins
+│   └── marts/        ← Entidades de negocio finales (prefijos fct_, dim_)
+├── macros/           ← Macros SQL reutilizables
+├── seeds/            ← Datos de referencia estáticos
+└── tests/            ← Tests singulares personalizados
+
+pipelines/ (si se usa Airflow/Prefect/Dagster)
+├── dags/ / flows/    ← Definiciones de pipelines
+├── operators/        ← Operadores/tareas personalizados
+└── utils/            ← Utilidades compartidas
+
+## Convenciones de datos
+- Modelos de staging: renombrar a snake_case, castear tipos, sin joins, sin lógica de negocio
+- Tablas de hechos: prefijo fct_, una fila por evento/transacción
+- Tablas de dimensiones: prefijo dim_, una fila por entidad
+- Nunca uses SELECT * en consultas de producción
+- Todos los modelos mart deben tener tests unique + not_null en la clave primaria
+- Se requieren verificaciones de frescura de fuente en todas las fuentes
+
+## Decisiones (no re-discutir)
+- [Estrategia incremental vs. full-refresh para tablas de hechos]
+- [Zona horaria: todos los timestamps en UTC]
+- [Granularidad: qué representa una fila en cada tabla mart]
+- [Estrategia de manejo de datos tardíos]
+
+## Requisitos de testing
+- Cada modelo de staging: not_null en la clave primaria
+- Cada modelo mart: unique + not_null en la clave primaria, relationships en claves foráneas
+- Frescura de fuente: advertir a las [X] horas, error a las [Y] horas
+
+## Reglas de rendimiento
+- Particiona las tablas grandes por fecha — siempre filtra en la columna de partición
+- Usa modelos incrementales para tablas > [X] filas
+- Nunca ejecutes full refreshes en producción sin aprobación
+- Claves de cluster/sort: [especificar si se usa Snowflake/Redshift]
+
+## Comandos
+- dbt run --select staging — ejecutar la capa de staging
+- dbt test — ejecutar todas las pruebas
+- dbt docs generate && dbt docs serve — previsualizar documentación
+- dbt source freshness — verificar la frescura de los datos fuente
+
+## Nunca hacer
+- Nunca pongas lógica de negocio en los modelos de staging
+- Nunca hardcodees fechas — usa variables dbt o macros
+- Nunca hagas commit de credenciales reales — usa variables de entorno o gestor de secretos
+- Nunca ejecutes dbt run en producción sin que dbt test pase primero
+```
+
+---
+
+> **Trabaja con nosotros:** Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA y soluciones B2B con comunidades de desarrolladores. [uitbreiden.com](https://uitbreiden.com/)

package/prompts/system-prompts/es/saas-backend.md

@@ -0,0 +1,71 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../saas-backend.md).
+
+# CLAUDE.md Starter — Backend SaaS
+
+Copia esto en el `CLAUDE.md` de tu proyecto y completa las secciones entre corchetes.
+
+---
+
+```markdown
+# [Nombre del Proyecto] — Instrucciones para Claude Code
+
+## Qué es esto
+[Un párrafo: qué hace el producto, quién lo usa, qué problema resuelve]
+
+## Stack
+- Lenguaje: [TypeScript / Python / Go]
+- Framework: [Express / FastAPI / Gin / NestJS]
+- Base de datos: [PostgreSQL via Prisma / raw pg / SQLAlchemy]
+- Autenticación: [JWT con tokens de acceso de 15 min + tokens de refresco de 7 días / Clerk / Auth0]
+- Caché: [Redis]
+- Cola: [BullMQ / SQS / Celery]
+- Despliegue: [AWS ECS / Fly.io / Railway]
+
+## Estructura del proyecto
+src/
+├── api/          ← Manejadores de rutas — ligeros, delegan a servicios
+├── services/     ← Lógica de negocio — sin preocupaciones HTTP
+├── db/           ← Consultas a la base de datos — sin lógica de negocio
+├── middleware/   ← Autenticación, limitación de tasa, manejo de errores
+├── models/       ← Definiciones de tipos y esquemas
+└── utils/        ← Funciones puras, sin efectos secundarios
+
+## Convenciones
+- Los manejadores de rutas son ligeros: valida la entrada, llama al servicio, devuelve respuesta
+- Los servicios contienen toda la lógica de negocio: no conocen HTTP
+- La capa de BD contiene solo consultas: sin lógica de negocio, sin preocupaciones HTTP
+- Todo el acceso a la base de datos pasa por la capa db/ — nunca llames al ORM directamente desde los servicios
+- Los errores se propagan hacia arriba con contexto — nunca los ignores silenciosamente
+- Todas las rutas de API devuelven: 200 (éxito), 201 (creado), 204 (sin contenido), 400 (entrada inválida), 401 (no autenticado), 403 (prohibido), 404 (no encontrado), 409 (conflicto), 422 (validación), 500 (inesperado)
+
+## Decisiones (no re-discutir)
+- [Mecanismo de autenticación decidido: JWT, sin sesiones]
+- [Elección de ORM: Prisma — sin SQL crudo excepto para consultas de analítica complejas]
+- [Formato de error: { error: string, code: string } — nunca cambiar la forma]
+- [Sin archivos barrel — importa directamente desde el código fuente]
+
+## Testing
+- Las pruebas de integración usan una base de datos de prueba real — sin mocks de BD
+- Pruebas unitarias para lógica de negocio pura en services/
+- Archivo de prueba: [filename].test.ts junto al archivo fuente
+- Ejecutar: npm test
+
+## Comandos
+- npm run dev — iniciar servidor de desarrollo con hot reload
+- npm test — ejecutar todas las pruebas
+- npm run build — build de producción
+- npm run lint — verificación de ESLint + Prettier
+- npm run db:migrate — ejecutar migraciones pendientes
+- npm run db:seed — sembrar datos de desarrollo
+
+## Nunca hacer
+- Nunca pongas lógica de negocio en los manejadores de rutas
+- Nunca llames a la base de datos directamente desde los manejadores de rutas
+- Nunca devuelvas errores brutos de la base de datos a los clientes
+- Nunca hagas commit de archivos .env
+- Nunca uses el tipo `any` en TypeScript
+```
+
+---
+
+> **Trabaja con nosotros:** Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA y soluciones B2B con comunidades de desarrolladores. [uitbreiden.com](https://uitbreiden.com/)

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

@@ -0,0 +1,82 @@
+> 🇫🇷 This is the French translation. [English version](../ai-product.md).
+
+# Starter CLAUDE.md — Produit IA
+
+Déposez ceci dans le `CLAUDE.md` de votre projet et remplissez les sections entre crochets.
+
+---
+
+```markdown
+# [Nom du Projet] — Instructions Claude Code
+
+## Ce que c'est
+[Un paragraphe : ce que fait le produit IA, quel modèle il utilise, qui sont les utilisateurs]
+
+## Stack
+- Langage : [TypeScript / Python]
+- Framework : [Next.js / FastAPI]
+- IA : [API Claude via Anthropic SDK / OpenAI / Gemini]
+- Modèle : [claude-sonnet-4-6 / claude-opus-4-7 / claude-haiku-4-5]
+- Base de données : [PostgreSQL / Supabase]
+- Vector DB : [Pinecone / pgvector / Weaviate] (si applicable)
+- Déploiement : [Vercel / AWS / Railway]
+
+## Structure du projet
+src/
+├── app/          ← App router Next.js / routes FastAPI
+├── ai/           ← Tout le code lié à l'IA : prompts, chains, outils
+│   ├── prompts/  ← System prompts et templates de prompts
+│   ├── tools/    ← Définitions d'outils pour le function calling
+│   └── agents/   ← Définitions d'agents et orchestration
+├── db/           ← Requêtes de base de données et migrations
+├── services/     ← Logique métier
+└── utils/        ← Utilitaires purs
+
+## Conventions IA
+- Tous les system prompts vivent dans src/ai/prompts/ — jamais inline dans les route handlers
+- Toujours épingler la version du modèle — ne jamais utiliser l'alias "latest"
+- Toujours activer le prompt caching sur les system prompts (cache_control: ephemeral)
+- Logger l'utilisation des tokens par requête pour le suivi des coûts
+- Réponses en streaming : utiliser SSE pour les réponses > 1000 tokens
+- Ne jamais passer les PII utilisateur au modèle sauf si la fonctionnalité le requiert explicitement
+- Les définitions d'outils vivent dans src/ai/tools/ — un fichier par outil
+
+## Configuration du prompt caching
+- Les system prompts doivent utiliser cache_control pour activer le caching
+- Cache read = $0.30/MTok vs non caché = $3/MTok — toujours mettre en cache
+- Invalider le cache quand le system prompt change (automatique au changement de contenu)
+
+## Contrôles de coût
+- Modèle par défaut : [claude-haiku-4-5] pour les tâches simples, [claude-sonnet-4-6] pour les complexes
+- Max tokens : définir max_tokens explicite sur chaque requête — jamais illimité
+- Rate limit : [X] requêtes par utilisateur par minute
+- Alerte budget : logger quand une seule session dépasse $[X]
+
+## Décisions (ne pas re-discuter)
+- [Justification de la sélection du modèle]
+- [Pourquoi streaming vs. non-streaming]
+- [Stratégie de fenêtre de contexte : résumer à N tokens]
+- [Tool calling vs. génération directe pour la sortie structurée]
+
+## Tests
+- Tests unitaires pour la construction des prompts et le parsing des sorties
+- Tests d'intégration avec des réponses API enregistrées (VCR / fixtures)
+- Ne jamais faire de vrais appels API dans les tests — coûte de l'argent et est lent
+- Tester les entrées adversariales : injection de prompt, tentatives de jailbreak, cas limites
+
+## Commandes
+- [commande dev]
+- [commande test]
+- [commande déploiement]
+
+## Ne jamais faire
+- Ne jamais inline les system prompts dans les route handlers
+- Ne jamais faire des appels IA non bornés sans max_tokens
+- Ne jamais logger les réponses IA complètes en production (peut contenir des PII utilisateur)
+- Ne jamais coder en dur des clés API — utiliser des variables d'environnement
+- Ne jamais appeler le modèle IA directement depuis les composants UI
+```
+
+---
+
+> **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/system-prompts/fr/data-pipeline.md

@@ -0,0 +1,78 @@
+> 🇫🇷 This is the French translation. [English version](../data-pipeline.md).
+
+# Starter CLAUDE.md — Projet de Pipeline de Données
+
+Déposez ceci dans le `CLAUDE.md` de votre projet et remplissez les sections entre crochets.
+
+---
+
+```markdown
+# [Nom du Projet] — Instructions Claude Code
+
+## Ce que c'est
+[Un paragraphe : quelles données ce pipeline traite, les systèmes sources, la destination, l'objectif métier]
+
+## Stack
+- Orchestrateur : [Airflow / Prefect / Dagster / dbt Cloud]
+- Transformation : [dbt / PySpark / Pandas / Polars]
+- Entrepôt : [BigQuery / Snowflake / Redshift / DuckDB]
+- Ingestion : [Fivetran / Airbyte / personnalisé]
+- Langage : [Python / SQL]
+- Infra : [Terraform sur AWS / GCP / Azure]
+
+## Structure du projet
+dbt/ (si utilisant dbt)
+├── models/
+│   ├── staging/      ← 1:1 avec les tables sources, nettoyage léger seulement
+│   ├── intermediate/ ← Logique métier, jointures
+│   └── marts/        ← Entités métier finales (préfixes fct_, dim_)
+├── macros/           ← Macros SQL réutilisables
+├── seeds/            ← Données de référence statiques
+└── tests/            ← Tests singuliers personnalisés
+
+pipelines/ (si utilisant Airflow/Prefect/Dagster)
+├── dags/ / flows/    ← Définitions de pipeline
+├── operators/        ← Opérateurs/tâches personnalisés
+└── utils/            ← Utilitaires partagés
+
+## Conventions de données
+- Modèles staging : renommer en snake_case, caster les types, pas de jointures, pas de logique métier
+- Tables de faits : préfixe fct_, une ligne par événement/transaction
+- Tables de dimensions : préfixe dim_, une ligne par entité
+- Ne jamais utiliser SELECT * dans les requêtes de production
+- Tous les modèles mart doivent avoir des tests unique + not_null sur la clé primaire
+- Contrôles de fraîcheur de source requis sur toutes les sources
+
+## Décisions (ne pas re-discuter)
+- [Stratégie incrémentale vs. rafraîchissement complet pour les tables de faits]
+- [Fuseau horaire : tous les timestamps en UTC]
+- [Grain : ce que représente une ligne dans chaque table mart]
+- [Stratégie de gestion des données en retard]
+
+## Exigences de tests
+- Chaque modèle staging : not_null sur la clé primaire
+- Chaque modèle mart : unique + not_null sur la clé primaire, relationships sur les clés étrangères
+- Fraîcheur des sources : avertir à [X] heures, erreur à [Y] heures
+
+## Règles de performance
+- Partitionner les grandes tables par date — toujours filtrer sur la colonne de partition
+- Utiliser des modèles incrémentaux pour les tables > [X] lignes
+- Ne jamais exécuter des rafraîchissements complets en production sans approbation
+- Clés cluster/tri : [spécifier si utilisant Snowflake/Redshift]
+
+## Commandes
+- dbt run --select staging — exécuter la couche staging
+- dbt test — exécuter tous les tests
+- dbt docs generate && dbt docs serve — prévisualiser la documentation
+- dbt source freshness — vérifier la fraîcheur des données sources
+
+## Ne jamais faire
+- Ne jamais mettre de logique métier dans les modèles staging
+- Ne jamais coder en dur des dates — utiliser des variables ou des macros dbt
+- Ne jamais committer de vrais credentials — utiliser des variables d'environnement ou un gestionnaire de secrets
+- Ne jamais exécuter dbt run en production sans que dbt test passe d'abord
+```
+
+---
+
+> **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/system-prompts/fr/saas-backend.md

@@ -0,0 +1,71 @@
+> 🇫🇷 This is the French translation. [English version](../saas-backend.md).
+
+# Starter CLAUDE.md — Backend SaaS
+
+Déposez ceci dans le `CLAUDE.md` de votre projet et remplissez les sections entre crochets.
+
+---
+
+```markdown
+# [Nom du Projet] — Instructions Claude Code
+
+## Ce que c'est
+[Un paragraphe : ce que fait le produit, qui l'utilise, quel problème il résout]
+
+## Stack
+- Langage : [TypeScript / Python / Go]
+- Framework : [Express / FastAPI / Gin / NestJS]
+- Base de données : [PostgreSQL via Prisma / raw pg / SQLAlchemy]
+- Auth : [JWT avec tokens d'accès 15 min + tokens de rafraîchissement 7 jours / Clerk / Auth0]
+- Cache : [Redis]
+- Queue : [BullMQ / SQS / Celery]
+- Déploiement : [AWS ECS / Fly.io / Railway]
+
+## Structure du projet
+src/
+├── api/          ← Route handlers — minces, délèguent aux services
+├── services/     ← Logique métier — pas de préoccupations HTTP
+├── db/           ← Requêtes de base de données — pas de logique métier
+├── middleware/   ← Auth, rate limiting, gestion des erreurs
+├── models/       ← Définitions de types et schémas
+└── utils/        ← Fonctions pures, pas d'effets secondaires
+
+## Conventions
+- Les route handlers sont minces : valider l'entrée, appeler le service, retourner la réponse
+- Les services contiennent toute la logique métier : ils ne connaissent pas HTTP
+- La couche DB contient uniquement des requêtes : pas de logique métier, pas de préoccupations HTTP
+- Tous les accès à la base de données passent par la couche db/ — ne jamais appeler l'ORM directement depuis les services
+- Les erreurs se propagent vers le haut avec du contexte — ne jamais avaler silencieusement
+- Toutes les routes API retournent : 200 (succès), 201 (créé), 204 (pas de contenu), 400 (mauvaise entrée), 401 (non auth), 403 (interdit), 404 (non trouvé), 409 (conflit), 422 (validation), 500 (inattendu)
+
+## Décisions (ne pas re-discuter)
+- [Mécanisme d'auth décidé : JWT, pas de sessions]
+- [Choix ORM : Prisma — pas de SQL brut sauf pour les requêtes d'analytique complexes]
+- [Format d'erreur : { error: string, code: string } — ne jamais changer la forme]
+- [Pas de fichiers barrel — importer directement depuis la source]
+
+## Tests
+- Les tests d'intégration touchent une vraie base de données de test — pas de mocks DB
+- Tests unitaires pour la logique métier pure dans services/
+- Fichier de test : [filename].test.ts à côté du fichier source
+- Exécuter : npm test
+
+## Commandes
+- npm run dev — démarrer le serveur de développement avec rechargement à chaud
+- npm test — exécuter tous les tests
+- npm run build — build de production
+- npm run lint — vérification ESLint + Prettier
+- npm run db:migrate — exécuter les migrations en attente
+- npm run db:seed — seeder les données de développement
+
+## Ne jamais faire
+- Ne jamais mettre de logique métier dans les route handlers
+- Ne jamais appeler la base de données directement depuis les route handlers
+- Ne jamais retourner les erreurs brutes de la base de données aux clients
+- Ne jamais committer des fichiers .env
+- Ne jamais utiliser le type `any` en TypeScript
+```
+
+---
+
+> **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/system-prompts/nl/ai-product.md

@@ -0,0 +1,82 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../ai-product.md).
+
+# CLAUDE.md Starter — AI-product
+
+Zet dit in de `CLAUDE.md` van je project en vul de secties tussen haakjes in.
+
+---
+
+```markdown
+# [Projectnaam] — Claude Code Instructies
+
+## Wat dit is
+[Eén alinea: wat het AI-product doet, welk model het gebruikt, wie de gebruikers zijn]
+
+## Stack
+- Taal: [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] (indien van toepassing)
+- Deployment: [Vercel / AWS / Railway]
+
+## Projectstructuur
+src/
+├── app/          ← Next.js app router / FastAPI routes
+├── ai/           ← Alle AI-gerelateerde code: prompts, ketens, tools
+│   ├── prompts/  ← Systeemprompts en promptsjablonen
+│   ├── tools/    ← Tooldefinities voor function calling
+│   └── agents/   ← Agentdefinities en orkestratie
+├── db/           ← Databasequeries en migraties
+├── services/     ← Bedrijfslogica
+└── utils/        ← Pure hulpprogramma's
+
+## AI-conventies
+- Alle systeemprompts staan in src/ai/prompts/ — nooit inline in route-handlers
+- Pin altijd de modelversie — gebruik nooit de alias "latest"
+- Schakel altijd prompt-caching in op systeemprompts (cache_control: ephemeral)
+- Log tokengebruik per verzoek voor kostentracking
+- Streamingantwoorden: gebruik SSE voor antwoorden > 1000 tokens
+- Geef nooit gebruikers-PII door aan het model tenzij de feature dit expliciet vereist
+- Tooldefinities staan in src/ai/tools/ — één bestand per tool
+
+## Prompt-caching instelling
+- Systeemprompts moeten cache_control gebruiken om caching in te schakelen
+- Cache-lezen = $0.30/MTok vs niet gecachet = $3/MTok — cache altijd
+- Invalideer cache wanneer systeemprompt verandert (automatisch bij inhoudswijziging)
+
+## Kostencontroles
+- Standaardmodel: [claude-haiku-4-5] voor eenvoudige taken, [claude-sonnet-4-6] voor complex
+- Max tokens: stel expliciete max_tokens in op elk verzoek — nooit onbeperkt
+- Rate limit: [X] verzoeken per gebruiker per minuut
+- Budgetalert: log wanneer een enkele sessie $[X] overschrijdt
+
+## Beslissingen (niet opnieuw bespreken)
+- [Modelkeuze-redenering]
+- [Waarom streaming vs. niet-streaming]
+- [Contextvenster-strategie: samenvatten bij N tokens]
+- [Tool calling vs. directe generatie voor gestructureerde output]
+
+## Testen
+- Unittests voor promptconstructie en outputparsing
+- Integratietests met opgenomen API-antwoorden (VCR / fixtures)
+- Doe nooit echte API-aanroepen in tests — kost geld en is traag
+- Test vijandige invoer: prompt-injectie, jailbreak-pogingen, randgevallen
+
+## Commando's
+- [dev commando]
+- [test commando]
+- [deploy commando]
+
+## Nooit doen
+- Nooit systeemprompts inline in route-handlers plaatsen
+- Nooit onbegrensde AI-aanroepen doen zonder max_tokens
+- Nooit volledige AI-antwoorden loggen in productie (kan gebruikers-PII bevatten)
+- Nooit API-sleutels hardcoderen — gebruik omgevingsvariabelen
+- Nooit het AI-model direct aanroepen vanuit UI-componenten
+```
+
+---
+
+> **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/)