Communitygithub.com

codebase-onboarding

Analysiere eine unbekannte Codebasis und erstelle einen strukturierten Onboarding-Guide mit Architekturübersicht, wichtigen Einstiegspunkten, Konventionen und einer Starter-CLAUDE.md. Verwende diese Fähigkeit, wenn du einem neuen Projekt beitrittst oder Claude Code zum ersten Mal in einem Repository einrichtest.

Was ist codebase-onboarding?

Diese Fähigkeit ermöglicht es einem KI-Agenten (wie Claude Code), systematisch eine unbekannte Codebasis zu analysieren und einen vollständigen, strukturierten Onboarding-Guide zu erstellen. Sie wurde für Entwickler entwickelt, die einem neuen Projekt beitreten oder Claude Code zum ersten Mal in einem bestehenden Repository einrichten. Der Prozess besteht aus vier Phasen: Aufklärung (Erkennung von Paketmanifesten, Frameworks, Einstiegspunkten, Verzeichnisstruktur, Konfigurations- und Testtools), Architekturzuordnung (Identifizierung von Tech-Stack, Architekturmuster, Schlüsselverzeichnissen und Datenfluss), Konventionserkennung (Namenskonventionen, Codemuster, Git-Konventionen) und schließlich der Generierung von zwei Artefakten: einem menschenlesbaren Onboarding-Guide und einer projektspezifischen CLAUDE.md, die dem Agenten hilft, sich im Projekt zurechtzufinden. Die Fähigkeit unterstützt gängige Plattformen wie Claude Code und ähnliche Codex-Assistenten und vermeidet Antipatterns wie das Lesen jeder Datei oder das Ersetzen einer vorhandenen CLAUDE.md.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/affaan-m/ECC/tree/main/skills/codebase-onboarding

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht codebase-onboarding?

Analysiere systematisch eine unbekannte Codebasis und erstelle einen strukturierten Onboarding-Leitfaden. Entwickelt für Entwickler, die einem neuen Projekt beitreten oder Claude Code zum ersten Mal in einem bestehenden Repository einrichten.

Wann verwenden

  • Erstes Öffnen eines Projekts mit Claude Code
  • Beitritt zu einem neuen Team oder Repository
  • Benutzer fragt: „Hilf mir, diese Codebasis zu verstehen“
  • Benutzer fragt: „Generiere eine CLAUDE.md für ein Projekt“
  • Benutzer sagt: „Onboarde mich“ oder „Führe mich durch dieses Repo“

Wie es funktioniert

Phase 1: Aufklärung

Sammle rohe Signale über das Projekt, ohne jede Datei zu lesen. Führe diese Prüfungen parallel durch:

1. Paketmanifest-Erkennung
   → package.json, go.mod, Cargo.toml, pyproject.toml, pom.xml, build.gradle,
     Gemfile, composer.json, mix.exs, pubspec.yaml

2. Framework-Fingerprinting
   → next.config.*, nuxt.config.*, angular.json, vite.config.*,
     django settings, flask app factory, fastapi main, rails config

3. Einstiegspunkt-Identifizierung
   → main.*, index.*, app.*, server.*, cmd/, src/main/

4. Verzeichnisstruktur-Schnappschuss
   → Die obersten 2 Ebenen des Verzeichnisbaums, ignoriere node_modules, vendor,
     .git, dist, build, __pycache__, .next

5. Konfigurations- und Tool-Erkennung
   → .eslintrc*, .prettierrc*, tsconfig.json, Makefile, Dockerfile,
     docker-compose*, .github/workflows/, .env.example, CI-Konfigurationen

6. Teststruktur-Erkennung
   → tests/, test/, __tests__/, *_test.go, *.spec.ts, *.test.js,
     pytest.ini, jest.config.*, vitest.config.*

Phase 2: Architekturzuordnung

Aus den Aufklärungsdaten identifizieren:

Tech-Stack

  • Sprache(n) und Versionsbeschränkungen
  • Framework(s) und Hauptbibliotheken
  • Datenbank(en) und ORMs
  • Build-Tools und Bundler
  • CI/CD-Plattform

Architekturmuster

  • Monolith, Monorepo, Microservices oder serverlos
  • Frontend/Backend-Aufteilung oder Full-Stack
  • API-Stil: REST, GraphQL, gRPC, tRPC

Schlüsselverzeichnisse Ordne die obersten Verzeichnisse ihrem Zweck zu:

src/components/  → React-UI-Komponenten
src/api/         → API-Routenhandler
src/lib/         → Gemeinsame Hilfsprogramme
src/db/          → Datenbankmodelle und Migrationen
tests/           → Testsuiten
scripts/         → Build- und Bereitstellungsskripte

Datenfluss Verfolge eine Anfrage vom Einstieg bis zur Antwort:

  • Wo tritt eine Anfrage ein? (Router, Handler, Controller)
  • Wie wird sie validiert? (Middleware, Schemata, Guards)
  • Wo befindet sich die Geschäftslogik? (Services, Modelle, Use Cases)
  • Wie erreicht sie die Datenbank? (ORM, rohe Abfragen, Repositories)

Phase 3: Konventionserkennung

Erkenne Muster, denen die Codebasis bereits folgt:

Namenskonventionen

  • Dateibenennung: kebab-case, camelCase, PascalCase, snake_case
  • Komponenten-/Klassenbenennungsmuster
  • Testdateibenennung: *.test.ts, *.spec.ts, *_test.go

Codemuster

  • Fehlerbehandlungsstil: try/catch, Result-Typen, Fehlercodes
  • Abhängigkeitsinjektion oder direkte Importe
  • State-Management-Ansatz
  • Asynchrone Muster: Callbacks, Promises, async/await, Channels

Git-Konventionen

  • Branch-Namensgebung anhand aktueller Branches
  • Commit-Nachrichten-Stil anhand aktueller Commits
  • PR-Workflow (Squash, Merge, Rebase)
  • Wenn das Repo noch keine Commits oder nur eine flache Historie hat (z. B. git clone --depth 1), überspringe diesen Abschnitt und vermerke: „Git-Historie nicht verfügbar oder zu flach, um Konventionen zu erkennen“

Phase 4: Onboarding-Artefakte generieren

Erzeuge zwei Ausgaben:

Ausgabe 1: Onboarding-Leitfaden

# Onboarding-Leitfaden: [Projektname]

## Übersicht
[2-3 Sätze: Was dieses Projekt tut und für wen es gedacht ist]

## Tech-Stack
<!-- Beispiel für ein Next.js-Projekt – durch erkannten Stack ersetzen -->
| Ebene | Technologie | Version |
|-------|-------------|---------|
| Sprache | TypeScript | 5.x |
| Framework | Next.js | 14.x |
| Datenbank | PostgreSQL | 16 |
| ORM | Prisma | 5.x |
| Testen | Jest + Playwright | - |

## Architektur
[Diagramm oder Beschreibung, wie Komponenten verbunden sind]

## Wichtige Einstiegspunkte
<!-- Beispiel für ein Next.js-Projekt – durch erkannte Pfade ersetzen -->
- **API-Routen**: `src/app/api/` — Next.js-Routenhandler
- **UI-Seiten**: `src/app/(dashboard)/` — authentifizierte Seiten
- **Datenbank**: `prisma/schema.prisma` — Datenmodell-Quelle der Wahrheit
- **Konfiguration**: `next.config.ts` — Build- und Laufzeitkonfiguration

## Verzeichniszuordnung
[Top-Level-Verzeichnis → Zweck-Zuordnung]

## Anfragelebenszyklus
[Verfolge eine API-Anfrage vom Einstieg bis zur Antwort]

## Konventionen
- [Dateibenennungsmuster]
- [Fehlerbehandlungsansatz]
- [Testmuster]
- [Git-Workflow]

## Häufige Aufgaben
<!-- Beispiel für ein Node.js-Projekt – durch erkannte Befehle ersetzen -->
- **Dev-Server starten**: `npm run dev`
- **Tests ausführen**: `npm test`
- **Linter ausführen**: `npm run lint`
- **Datenbankmigrationen**: `npx prisma migrate dev`
- **Für Produktion bauen**: `npm run build`

## Wo suchen
<!-- Beispiel für ein Next.js-Projekt – durch erkannte Pfade ersetzen -->
| Ich möchte... | Schauen Sie bei... |
|--------------|-------------------|
| Einen API-Endpunkt hinzufügen | `src/app/api/` |
| Eine UI-Seite hinzufügen | `src/app/(dashboard)/` |
| Eine Datenbanktabelle hinzufügen | `prisma/schema.prisma` |
| Einen Test hinzufügen | `tests/` entsprechend des Quellpfads |
| Build-Konfiguration ändern | `next.config.ts` |

Ausgabe 2: Starter-CLAUDE.md

Generiere oder aktualisiere eine projektspezifische CLAUDE.md basierend auf erkannten Konventionen. Wenn CLAUDE.md bereits existiert, lies sie zuerst und erweitere sie – behalte vorhandene projektspezifische Anweisungen bei und kennzeichne deutlich, was hinzugefügt oder geändert wurde.

# Projektanweisungen

## Tech-Stack
[Erkannter Stack – Zusammenfassung]

## Codestil
- [Erkannte Namenskonventionen]
- [Erkannte Muster, die zu befolgen sind]

## Testen
- Tests ausführen: `[erkannter Testbefehl]`
- Testmuster: [erkannte Testdateikonvention]
- Abdeckung: [falls konfiguriert, der Abdeckungsbefehl]

## Build & Ausführung
- Dev: `[erkannter Dev-Befehl]`
- Build: `[erkannter Build-Befehl]`
- Lint: `[erkannter Lint-Befehl]`

## Projektstruktur
[Schlüsselverzeichnis → Zweck-Zuordnung]

## Konventionen
- [Commit-Stil, falls erkennbar]
- [PR-Workflow, falls erkennbar]
- [Fehlerbehandlungsmuster]

Best Practices

  1. Nicht alles lesen – Aufklärung sollte Glob und Grep verwenden, nicht Read auf jeder Datei. Lies nur selektiv, wenn Signale mehrdeutig sind.
  2. Überprüfen, nicht raten – Wenn ein Framework anhand der Konfiguration erkannt wird, der tatsächliche Code aber etwas anderes verwendet, vertraue dem Code.
  3. Vorhandene CLAUDE.md respektieren – Wenn bereits eine vorhanden ist, erweitere sie, anstatt sie zu ersetzen. Kennzeichne, was neu ist vs. vorhanden.
  4. Kurz und bündig bleiben – Der Onboarding-Leitfaden sollte in 2 Minuten durchsuchbar sein. Details gehören in den Code, nicht in den Leitfaden.
  5. Unbekanntes kennzeichnen – Wenn eine Konvention nicht sicher erkannt werden kann, sag es, anstatt zu raten. „Test-Runner konnte nicht ermittelt werden“ ist besser als eine falsche Antwort.

Zu vermeidende Antipatterns

  • Eine CLAUDE.md generieren, die länger als 100 Zeilen ist – konzentriert bleiben
  • Jede Abhängigkeit auflisten – nur die hervorheben, die die Art und Weise der Codeentwicklung prägen
  • Offensichtliche Verzeichnisnamen beschreiben – src/ braucht keine Erklärung
  • Die README kopieren – der Onboarding-Leitfaden bietet strukturelle Einblicke, die der README fehlen

Beispiele

Beispiel 1: Zum ersten Mal in einem neuen Repository

Benutzer: „Onboarde mich in diese Codebasis“ Aktion: Führe vollständigen 4-Phasen-Workflow aus → produziere Onboarding-Leitfaden + Starter-CLAUDE.md Ausgabe: Onboarding-Leitfaden direkt in die Konversation ausgegeben, plus eine CLAUDE.md, die in das Projektstammverzeichnis geschrieben wird

Beispiel 2: CLAUDE.md für ein bestehendes Projekt generieren

Benutzer: „Generiere eine CLAUDE.md für dieses Projekt“ Aktion: Führe Phasen 1-3 aus, überspringe Onboarding-Leitfaden, produziere nur CLAUDE.md Ausgabe: Projektspezifische CLAUDE.md mit erkannten Konventionen

Beispiel 3: Vorhandene CLAUDE.md erweitern

Benutzer: „Aktualisiere die CLAUDE.md mit den aktuellen Projektkonventionen“ Aktion: Lies vorhandene CLAUDE.md, führe Phasen 1-3 aus, füge neue Erkenntnisse zusammen Ausgabe: Aktualisierte CLAUDE.md mit deutlich gekennzeichneten Ergänzungen

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/content-engine

Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.

affaan-m/ECC

Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform using content-engine patterns. Never posts identical content cross-platform. Use when the user wants to distribute content across social platforms.

affaan-m/fal-ai-media

Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI.

affaan-m/manim-video

日本語翻訳:このファイルは manim-video 用の日本語翻訳が必要です

affaan-m/remotion-video-creation

Remotion のベストプラクティス - React で動画を作成する。3D、アニメーション、音声、字幕、チャート、トランジションなどをカバーするドメイン固有の29のルール。

affaan-m/video-editing

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

agent-self-evaluation

Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions.

agent-sort

Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.

ai-first-engineering

Engineering operating model for teams where AI agents generate a large share of implementation output. Use when setting team process, review gates, or ownership rules for a codebase largely written by agents.

ai-regression-testing

Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code. Use when adding regression coverage to AI-assisted code, or when the same model both wrote and reviewed a change.

android-clean-architecture

Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns. Use when structuring modules, layers, or data flow in an Android or KMP project.

angular-developer

Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling.

Verwandte Skills