Technical Codebase Discovery & Onboarding Prompt
A reusable prompt for asking an AI assistant to work as Technical Codebase Discovery & Onboarding Prompt.
The full prompt is on this page. A prompt is not an installable skill package.
When to use this prompt
Use Technical Codebase Discovery & Onboarding Prompt when you want an AI assistant to start from a ready-made prompt template: paste it into the chat, then adapt its inputs, constraints and desired output to your task.
When not to use it
Skip Technical Codebase Discovery & Onboarding Prompt when you need an installable agent skill with its own files or scripts: a prompt template is plain text, not a SKILL.md package. A more specific prompt in the coding category may also fit better.
What this prompt does
A reusable prompt for asking an AI assistant to work as Technical Codebase Discovery & Onboarding Prompt.
Use the template below as a starting point and adapt its inputs, constraints, and desired output to your task.
The 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>`Source: f/prompts.chat, dedicated to the public domain under CC0 1.0. View it at its source.
How to get started
The full prompt is on this page. A prompt is not an installable skill package.
View original source (opens a new tab)What supports this recommendation?
56/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 43/100
- Practical detail
- 52/100
- Source evidence
- 63/100
- Source signals
- 82/100
Model compatibility evidence
- claudeinferred
The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.
- chatgptinferred
The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.
- geminiinferred
The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.
- copilotinferred
The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.
- llamainferred
The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.
- perplexityinferred
The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.
- mistralinferred
The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.
- grokinferred
The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
Intended uses
- Ask an AI assistant to take on the Technical Codebase Discovery & Onboarding Prompt role.
Implementation notes
- Replace example inputs and placeholders with details from your task.
- Review the result before relying on it for consequential decisions.
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.