If you're using AI coding tools like Claude, Cursor, or GitHub Copilot to build software, you've probably experienced the frustration:
The AI puts files in the wrong place. It uses a different coding style than the rest of your project. It forgets things you told it yesterday. It breaks something that was working fine.
The problem isn't the AI. The problem is context.
AI assistants are incredibly capable, but they don't know your project. They don't know where your components live, what your database schema looks like, or that one weird bug that happens when you forget to check for null on the user object.
The solution? A single markdown file that gives your AI everything it needs to be a productive team member.
I call it CLAUDE.md.
What is CLAUDE.md?
CLAUDE.md is a documentation file that lives in the root of your project. Its sole purpose is to give AI coding assistants the context they need to work effectively on your codebase.
Think of it as onboarding documentation β but for AI.
When I first started using Claude to build our client portal at Pyrus, my CLAUDE.md was 11 lines:
That's it. And honestly, things were rough.
Claude would create components in random folders. It would use inline styles when we use CSS variables. It would write API routes that didn't match our response format. Every task required extra back-and-forth to fix the basics.
After two weeks of iteration, our CLAUDE.md grew significantly:
And the difference is night and day.
The 12 Essential Sections
Here's what I've learned should be in every CLAUDE.md:
1 Pre-commit Rules
Non-negotiable rules that prevent broken builds from reaching production.
2 Project Overview
High-level context so AI understands what it's working on.
3 Project Structure
Directory map so AI knows where things live.
4 Database Schema
Key tables and relationships to prevent bad queries.
5 Key Patterns
Code patterns to follow for consistency.
6 Environment Variables
Every env var the project needs to run.
7 Common Tasks
Step-by-step guides for frequent operations.
8 Testing & Deployment
How to test and ship code safely.
9 Scheduled Jobs
Background tasks that run automatically.
10 Common Gotchas
Mistakes that have burned you before.
11 QA & Safety Checklists
Prevent production disasters.
12 Troubleshooting
Quick fixes for common dev issues.
Let me break down the most important ones:
1. Pre-commit Rules (Critical)
This is the one section you absolutely cannot skip. These are the non-negotiable rules that prevent broken builds from reaching production.
# BEFORE committing or pushing any code, you MUST: 1. Run `npm run build` and verify zero errors 2. Fix ALL errors before committing 3. Never commit code that doesn't pass a clean build # Do not skip this step. # Do not assume it will build. # Actually run it and verify. Why is this critical? Because AI will happily write code that looks correct but doesn't compile. If you don't enforce the build check, you'll end up with broken deployments.
5. Key Patterns
Document the code patterns your project follows. Include actual code snippets β AI learns better from examples than descriptions.
### API Response Format // Success return NextResponse.json({ data: result }) // Error return NextResponse.json( { error: 'Message' }, { status: 400 } ) 10. Common Gotchas
This might be the most valuable section. Document the mistakes that have burned you:
- Framework-specific quirks
- Auth edge cases
- Database gotchas (Row Level Security, anyone?)
- State management pitfalls
Every production bug should get added here so you never make the same mistake twice.
"We learned this one the hard way after a subscription update accidentally reset client data. Now we have a checklist for any code that touches billing."
Pro Tips
π‘ Making It Work
Update After Every Feature
When you build something new, add the pattern while it's fresh. Future you (and your AI) will thank you.
Document Failures
Had a production bug? Add it to "Common Gotchas" immediately. The best documentation comes from real problems.
Show, Don't Just Tell
Include code snippets for your patterns. AI learns better from examples than prose descriptions.
Keep It Current
Run a monthly audit. If your CLAUDE.md doesn't match reality, it's worse than having none at all.
The ROI of Good Documentation
I know what you're thinking: "284 lines of documentation? That sounds like a lot of work."
It is. But consider the alternative.
Without CLAUDE.md, every AI interaction requires more context, more corrections, and more back-and-forth. You spend time fixing basic mistakes instead of building features.
With CLAUDE.md, the AI shows up to work already knowing your codebase. It follows your patterns. It puts files in the right places. It catches itself before making mistakes you've documented.
The documentation pays for itself within a week.
Get Started
You don't need to write all 12 sections today. Start with the critical ones:
- Pre-commit rules β prevent broken builds
- Project structure β tell AI where things go
- Key patterns β show how you write code
Then add sections as you encounter friction. Every time Claude does something wrong, ask yourself: "What could I add to CLAUDE.md to prevent this?"
Over time, you'll build a comprehensive guide that makes AI-assisted development feel like working with a teammate who actually knows your codebase.
And that's when vibe coding really starts to pay off.
The Ultimate CLAUDE.md
Everything your AI coding assistant needs to understand your project and follow your conventions.
For Vibe Coders Who Ship Fast πPre-commit Rules
Non-negotiable rules that prevent broken builds.
- Run build command before every commit
- Fix ALL errors before pushing
- Run tests if they exist
- Never assume it works β verify
Project Overview
High-level context so AI understands the project.
- What the app does (1-2 sentences)
- Tech stack (framework, DB, auth)
- Key user types and flows
- Third-party integrations
Project Structure
Directory map so AI knows where things live.
- Folder tree with descriptions
- Where to put new pages/routes
- Components, hooks, utils locations
- API route organization
Database Schema
Key tables and relationships.
- Core entities and their purpose
- Important relationships
- Commonly misunderstood fields
- Tables grouped by domain
Key Patterns
Code patterns to follow for consistency.
- Auth/session handling pattern
- API response format
- Error handling approach
- Component extraction patterns
Environment Variables
Every env var the project needs.
- Required vs optional vars
- Grouped by service
- Where to get values
- Local vs production differences
Common Tasks
Step-by-step guides for frequent operations.
- Adding a new page/route
- Creating an API endpoint
- Adding database migrations
- Feature-specific tasks
Testing & Deployment
How to test and ship code safely.
- Test commands and frameworks
- Critical paths to test
- Deploy process
- Migration procedures
Scheduled Jobs
Background tasks that run automatically.
- Cron job endpoints & schedules
- What each job does
- How to test locally
- Webhook handlers
Common Gotchas
Mistakes that have burned you before.
- Framework-specific quirks
- Auth edge cases
- Database gotchas (RLS, etc.)
- State management pitfalls
QA & Safety Checklists
Prevent production disasters.
- Pre-deployment checklist
- High-risk areas to watch
- Database audit queries
- Smoke test scenarios
Troubleshooting
Quick fixes for common dev issues.
- Dev server crashes
- Build failures
- Cache invalidation
- File size limits
Pro Tips
Update After Every Feature
Add new patterns while they're fresh. Future you (and AI) will thank you.
Document Failures
Had a production bug? Add it to "Common Gotchas" so it never happens again.
Show, Don't Just Tell
Include code snippets. AI learns better from examples than descriptions.
Keep It Current
Run a monthly audit. Outdated docs are worse than no docs.