Codebase Onboarding Analysis — Prompt

Codebase Onboarding Analysis

Code Test Case AssistantHelp junior developers analyze code, design test cases covering key behaviors, and generate the corresponding test code.VS Code CodeTour Guide SpecialistHelp developers design, create, and maintain VS Code CodeTour files, writing structured onboarding guides and in-depth feature tours for codebases.Vitest Unit Testing Standards for TypeScript ProjectsGuide developers to organize TypeScript unit tests according to conventions, covering test directories, test data, dependency mocking, assertion styles, and setup and teardown.GitHub Repository AnalystExplains a repository’s structure and modules, reviews documentation, and highlights refactoring opportunities.Introductory Angular Dependency Injection MentorUse clear step-by-step explanations, analogies, and practical examples to help junior developers understand how Angular dependency injection works, its value, and common pitfalls.Simulated SQL Terminal PracticeSet the conversational model as an SQL terminal for a sample database, returning a formatted simulated result table based on the user’s query.AI and Computer Vision Algorithm Improvement ConsultantAnalyzes a given artificial intelligence or computer vision algorithm and proposes practical optimization recommendations concerning efficiency, accuracy, scalability, and bottlenecks, explaining the rationale.Underwater Acoustics Deep-Learning Research ConsultantProvide research advice on experimental design, the use of PyTorch and MATLAB, and data analysis for underwater acoustics and deep-learning simulation experiments.MVC and SOLID Software Architecture GuidanceGuide developers in organizing code with MVC and designing maintainable, extensible software structures in accordance with SOLID principles.HTTP Status Code Decision AdvisorChoose an appropriate HTTP status code for an API based on the request method, actual outcome, authentication status and service dependencies, and explain alternatives, relevant response headers and error body structure.Rust Programming TutorExplain core Rust concepts such as ownership, borrowing, and lifetimes step by step, and help learners reinforce their knowledge with safe, efficient code examples and exercises.Build a Phased Cybersecurity Graduation Project with ClaudeCreates a master prompt for Claude to guide a solo student through research, novelty assessment, implementation, experiments, documentation, and a mock viva. The workflow requires strict phase gates and evidence-based claims.Ethereum Public Message Smart ContractRequests a Solidity contract that stores a publicly readable message, restricts updates to the deployer, and counts message updates. It asks for code and explanations of the implementation.Explain the Chain Rule with ManimCreates Manim code for an accessible animation that explains the calculus chain rule.Java Exam Code Writing SpecialistGenerate clean, concise Java solutions suited to handwritten exams, with comments and a brief explanation of the logic.Architecture Guide for ProgrammersGuides experienced programmers through project architecture, module integration, and architectural styles using practical examples and diagrams.Beginner-Friendly Android Studio GuidePrompts a model to teach Android development with plain language, analogies, small steps, code explanations, and practical debugging help.TensorFlow.js DDQN Snake GameGenerate a playable Snake game and train a Double DQN agent in a single, self-contained HTML file.Deep Copy Functionality GuideGuides a chat model to explain shallow versus deep copies, with examples in Python, Java, and JavaScript and tips on common pitfalls.GPT Flutter Project Starter GuideGuide Flutter beginners through SDK installation, project creation, IDE setup, project organization, and dependency management.Vacuum Arc Simulation AdvisorGuide Fluent modeling of vacuum arcs under transverse magnetic fields, with support for UDF and UDS implementation, troubleshooting, and beginner instruction.Get hints only when solving coding problemsHave the model help build a solution approach step by step, explicitly asking it not to provide the final answer directly.Cross-Language Code Formatting Configuration PlannerHelps analyze a project's technology stack and plan ESLint, Prettier, language formatters, import sorting, Husky, lint-staged, CI checks, and team rollout documentation.Reliable Bash Scripting PracticesGuide the model in writing Bash scripts using engineering best practices, including strict mode, argument parsing, error handling, temporary file cleanup, repeatable execution, and safe handling of untrusted input.Spring Boot and SOLID Architecture ConsultantDesign Spring Boot applications and generate maintainable code solutions according to layered architecture, SOLID, REST, DDD, and enterprise practices.Claude Code Developer Status Bar Script DesignGuide the generation of a single-file Python status bar script that displays development information such as the model, project directory, Git status, and API duration ratio, and includes requirements for caching, performance, and error handling.Pragmatic TypeScript Team Testing StandardsEstablish an actionable set of testing conventions for a TypeScript project, covering unit, integration and end-to-end testing, test data, mocking boundaries and reliability practices.Portable and Secure Shell Script Development AssistantGuide the model in systematically analyzing requirements and designing and writing Shell scripts compatible with POSIX, bash, or zsh, while covering error handling, input validation, security hardening, portability, and a testing checklist.Full-Stack Frontend Development Implementation AssistantHelp plan and implement modern frontend interfaces, covering component architecture, responsive design, performance optimization, state management, accessibility, and testing practices.Backend System Architecture Design and Implementation Planning AssistantGuide the model in analyzing requirements, designing APIs, databases, system architecture, security policies, performance solutions, and deployment and operations plans in the form of a task checklist, and organizing them into traceable Markdown deliverables.

Codebase Onboarding Analysis

PROMPT

Context:
I am a developer who has just joined the project and I am using you, an AI coding assistant, to gain a deep understanding of the existing codebase. My goal is to become productive as quickly as possible and to make informed technical decisions based on a solid understanding of the current system.

Primary Objective:
Analyze the source code provided in this project/workspace and generate a detailed, clear, and well-structured Markdown document that explains the system’s architecture, features, main flows, key components, and technology stack.
This document should serve as a technical onboarding guide.
Whenever possible, improve navigability by providing direct links to relevant files, classes, and functions, as well as code examples that help clarify the concepts.

Detailed Instructions — Please address the following points:

1. README / Instruction Files Summary

Look for files such as README.md, LEIAME.md, CONTRIBUTING.md, or similar documentation.
Provide an objective yet detailed summary of the most relevant sections for a new developer, including:
Project overview
How to set up and run the system locally
Adopted standards and conventions
Contribution guidelines (if available)

2. Detailed Technology Stack

Identify and list the complete technology stack used in the project:
Programming language(s), including versions when detectable (e.g., from package.json, pom.xml, .tool-versions, requirements.txt, build.gradle, etc.).
Main frameworks (backend, frontend, etc. — e.g., Spring Boot, .NET, React, Angular, Vue, Django, Rails).
Database(s):
Type (SQL / NoSQL)
Name (PostgreSQL, MongoDB, etc.)
Core architecture style (e.g., Monolith, Microservices, Serverless, MVC, MVVM, Clean Architecture).
Cloud platform (if identifiable via SDKs or configuration — AWS, Azure, GCP).
Build tools and package managers (Maven, Gradle, npm, yarn, pip).
Any other relevant technologies (caching, message brokers, containerization — Docker, Kubernetes).
Reference and link the configuration files that demonstrate each item.

3. System Overview and Purpose

Clearly describe what the system does and who it is for.
What problems does it solve?
List the core functionalities.
If possible, relate the system to the business domains involved.
Provide a high-level description of the main features.

4. Project Structure and Reading Recommendations

Entry Point:

Where should I start exploring the code? Identify the main entry points (e.g., main.go, index.js, Program.cs, app.py, Application.java).
Provide direct links to these files.

General Organization:

Explain the overall folder and file structure. Highlight important conventions.
Use real folder and file name examples.

Configuration:

Are there main configuration files? (e.g., config.yaml, .env, appsettings.json)
Which configurations are critical?
Provide links.

Reading Recommendation:

Suggest an order or a set of key files/modules that should be read first to quickly grasp the project’s core concepts.

5. Key Components

Identify and describe the most important or central modules, classes, functions, or services.
Explain the responsibilities of each component.
Describe their responsibilities and interdependencies.
For each component:
Include a representative code snippet
Provide a link to where it is implemented
Provide direct links and code examples whenever possible.

6. Execution and Data Flows

Describe the most common or critical workflows or business processes (e.g., order processing, user authentication).
Explain how data flows through the system:
Where data is persisted
How it is read, modified, and propagated
Whenever possible, illustrate with examples and link to relevant functions or classes.

6.1 Database Schema Overview (if applicable)

For data-intensive applications:
Identify the main entities/tables/collections
Describe their primary relationships
Base this on ORM models, migrations, or schema files if available

7. Dependencies and Integrations

Dependencies:

List the main external libraries, frameworks, and SDKs used.
Briefly explain the role of each one.
Provide links to where they are configured or most commonly used.

Integrations:

Identify and explain integrations with external services, additional databases, third-party APIs, message brokers, etc.
How does communication occur?
Point to the modules/classes responsible and include links.

7.1 API Documentation (if applicable)

If the project exposes APIs:
Is there evidence of API documentation tools or standards (e.g., Swagger/OpenAPI, Javadoc, endpoint-specific docstrings)?
Where can this documentation be found or how can it be generated?

8. Diagrams

Generate high-level diagrams to visualize the system architecture and behavior:
Component diagram (highlighting main modules and their interactions)
Data flow diagram (showing how information moves through the system)
Class diagram (showing key classes and relationships, if applicable)
Simplified deployment diagram (where components run, if detectable)
Simplified infrastructure/deployment diagram (if infrastructure details are apparent)
Create these diagrams using Mermaid syntax inside the Markdown file.
Diagrams should be high-level; extensive detailing is not required.

9. Testing

Are there automated tests?
Unit tests
Integration tests
End-to-end (E2E) tests
Where are they located in the project?
Which testing framework(s) are used?
How are tests typically executed?
How can tests be run locally?
Is there any CI/CD strategy involving tests?

10. Error Handling and Logging

How does the application generally handle errors?
Is there a standard pattern (e.g., global middleware, custom exceptions)?
Which logging library is used?
Is there a standard logging format?
Is there visible integration with monitoring tools (e.g., Datadog, Sentry)?

11. Security Considerations

Are there evident security mechanisms in the code?
Authentication
Authorization (middleware/filters)
Input validation
Are specific security libraries prominently used (e.g., Spring Security, Passport.js, JWT libraries)?
Are there notable security practices?
Secrets management
Protection against common attacks

12. Other Relevant Observations (Including Build/Deploy)

Are there files related to build or deployment?
Dockerfile
docker-compose.yml
Build/deploy scripts
CI/CD configuration files (e.g., .github/workflows/, .gitlab-ci.yml)
What do these files indicate about how the application is built and deployed?
Is there anything else crucial or particularly helpful for a new developer?
Known technical debt mentioned in comments
Unusual design patterns
Important coding conventions
Performance notes

Final Output Format

Generate the complete response as a well-formatted Markdown (.md) document.
Use clear and direct language.
Organize content with titles and subtitles according to the numbered sections above.
Include relevant code snippets (short and representative).
Include clickable links to files, functions, classes, and definitions whenever a specific code element is mentioned.
Structure the document using the numbered sections above for readability.

Whenever possible:

Include clickable links to files, functions, and classes.
Show short, representative code snippets.
Use bullet points or tables for lists.

IMPORTANT

The analysis must consider ALL files in the project.
Read and understand all necessary files required to fully execute this task and achieve a complete understanding of the system.

Action

Please analyze the source code currently available in my environment/workspace and generate the Markdown document as requested.

The output file name must follow this format:
<yyyy-mm-dd-project-name-app-dev-discovery_cursor.md>