Skip to main content

Claude Prompt to Generate a Codebase Onboarding Guide

Generate a full onboarding guide from your codebase: architecture, setup, conventions, domain concepts, workflow, first tasks, and tribal knowledge.

Fill in the placeholders

Edit the values, then copy your finished prompt.

Your Prompt
prompt.txt
You are a staff engineer creating an onboarding guide for a new developer joining the team. Analyze this Laravel 11 codebase and generate a comprehensive onboarding document.

**Project Context:**
- Project Name: My SaaS Application
- Team Size: 6 developers (2 senior, 3 mid, 1 junior)
- Domain: B2B project management with billing

**Generate These Onboarding Sections:**

1. **Architecture Overview (30,000-foot view):**
   - What does this application do in 2-3 sentences?
   - Architecture style (monolith, microservices, modular monolith)
   - Request lifecycle: from HTTP request to response, what happens?
   - Key directories and what lives in each
   - Data flow diagram (text-based)

2. **Local Development Setup:**
   - Prerequisites (language version, tools, services)
   - Step-by-step setup from `git clone` to running locally
   - Environment variables that need to be configured (with explanations, NOT values)
   - Seed data: how to populate the local database
   - Common setup issues and their fixes

3. **Codebase Conventions & Patterns:**
   - Naming conventions (files, classes, methods, database columns)
   - Code organization rules (where to put new controllers, services, models)
   - Patterns used: Repository, Service Layer, Action Classes, DTOs, etc.
   - What the team does differently from framework defaults (and why)
   - Filament admin panel conventions and resource creation patterns

4. **Key Domain Concepts:**
   - Core business entities and their relationships
   - Important business rules encoded in the code
   - Terminology glossary (domain terms a new dev won't know)
   - The 5 most complex areas of the codebase and how to approach them

5. **Development Workflow:**
   - Git branching strategy
   - PR review process and expectations
   - CI/CD pipeline: what runs, what can fail, how to fix it
   - Testing: what to test, how to run tests, minimum coverage expectations
   - Deployment process: how code gets to production

6. **First Tasks Roadmap:**
   - Suggested first PR: a small, safe change to get familiar with the workflow
   - Week 1 goals: what a new dev should understand
   - Week 2-4 goals: first meaningful contribution areas
   - Who to ask for help on what (team knowledge map)

7. **Gotchas & Tribal Knowledge:**
   - Things that will confuse you (and they're intentional)
   - Known tech debt areas (handle with care)
   - Performance-sensitive areas (don't change without benchmarking)
   - The services section reuses the Product model intentionally — do not create a separate Service model

Format with clear headings, code examples from the actual codebase, and links to relevant files.

What this prompt does

This prompt makes the AI a staff engineer that analyzes a [framework] codebase and writes a comprehensive onboarding guide for a new developer. You provide the [project_name], the [team_size], and the [domain], and it produces seven sections: an architecture overview, local development setup, codebase conventions, key domain concepts, the development workflow, a first-tasks roadmap, and gotchas and tribal knowledge. The guide is structured to take someone from git clone to a first meaningful contribution.

The structure works because it captures what is normally explained verbally and lost. The architecture section gives a 30,000-foot view plus the request lifecycle and a text data-flow diagram. The conventions section documents what the team does differently from framework defaults, steered by [convention_focus]. The gotchas section surfaces intentional confusion and tech-debt landmines, including whatever you flag in [additional_gotcha]. The first-tasks roadmap, with a safe starter PR and week-by-week goals, is what actually gets a new developer productive fast.

When to use it

  • You are handing a codebase to a new team or client and need onboarding docs
  • You want conventions and gotchas surfaced from the actual code, not your fading memory
  • You need a safe first-PR suggestion and a week-by-week ramp plan
  • You want the request lifecycle and data flow documented for newcomers
  • You need a domain glossary so a new dev understands the team's vocabulary
  • You want tech-debt and performance-sensitive areas flagged before someone breaks them

Example output

You get a structured onboarding document with the seven sections, clear headings, code examples drawn from the actual codebase, and references to relevant files. It includes a text-based data-flow diagram, a setup walkthrough with env-var explanations (not values), a domain glossary, a first-tasks roadmap, and a tribal-knowledge section covering intentional quirks and tech debt.

Pro tips

  • Set [framework] accurately so the request-lifecycle and convention sections match how your stack actually routes
  • Make [domain] specific so the glossary and business-rules sections reflect real entities, not placeholders
  • Use [convention_focus] to spotlight your trickiest area, like Filament resource patterns
  • Flag the real trap in [additional_gotcha], such as a model reused intentionally that newcomers try to split
  • Run it with the codebase actually available to the AI so the file references and examples are real, not invented
  • Verify the setup steps on a genuinely fresh machine; onboarding docs rot fastest at the install stage

Frequently Asked Questions

Does it pull real examples from my codebase?
It is designed to, formatting the guide with code examples from the actual codebase and links to relevant files. For that to be accurate, run it with the codebase available to the AI; otherwise it may generalize rather than cite real files.
What does the first-tasks roadmap include?
It suggests a small, safe first PR to learn the workflow, sets Week 1 understanding goals, outlines Week 2-4 contribution areas, and provides a team knowledge map of who to ask for help on what. This section is what gets new developers productive fastest.
Will it document our team-specific conventions?
Yes. The conventions section covers naming, code organization, the patterns you use, and crucially what the team does differently from framework defaults. The `[convention_focus]` variable lets you emphasize a specific area like admin panel patterns.
Does it cover environment variables safely?
Yes. The setup section explains which environment variables need configuring and what each does, but it documents explanations rather than actual secret values, so the guide is safe to share without leaking credentials.
Can I use it for a non-Laravel project?
Yes. Set the `[framework]` variable to your stack, and the request-lifecycle, conventions, and setup sections adapt. The seven-section structure is framework-agnostic; only the specifics change to match your codebase.
Engr Mejba Ahmed

Need this built for real?

Engr Mejba Ahmed

AI Developer · Software Engineer

I'm Mejba — I design and ship production AI systems, automations, and full-stack apps. If you want this turned into a working solution for your team, let's talk.

More in AI Coding Assistants

Engr Mejba Ahmed

Engr Mejba Ahmed

AI assistant · trained on my work

👋

Hey there!

Quick Actions

WhatsApp Direct line to me

Chat on WhatsApp

+880 1723 741224 · Replies within the hour on working days

Popular Questions

Engr Mejba Ahmed is connected
Engr Mejba Ahmed is typing...
Engr Mejba Ahmed avatar

✉ Want me to follow up? Drop your email

Engr Mejba Ahmed avatar

📞 Connect Directly

Choose how you'd like to reach me

WhatsApp

+880 1723 741224

Email

mejba.13@gmail.com

✓ Details sent! I'll get back to you shortly.

Powered by OpenAI

335+

Blog Posts

25

AI Courses

63

Projects

Services & Expertise

Pricing & Process

Learning & Resources

Connect & Support