Debug Interview Generator - Claude Skill

A reusable Claude skill for generating realistic, intentionally buggy technical interview projects.

Quick Start

Installation

1. Copy this directory to your Claude skills folder:

cp -r debug-interview ~/.claude/skills/

2. Verify installation:

ls ~/.claude/skills/debug-interview

You should see:

• SKILL.md
• skill.yaml
• skill.prompt
• README.md

Usage

Invoke the skill in Claude Code:

Use the debug-interview skill to create a project for a Senior SDE role

Or simply:

/debug-interview

Then follow the interactive prompts.

What You Get

Every generated project includes:

1. Complete Source Code

   • Working application with intentional bugs
   • Realistic file structure
   • Configuration files
   • Dependency manifests

2. Candidate README.md

   • Setup instructions
   • Task description
   • Testing guidelines
   • Time limits

3. SOLUTION_GUIDE.md (Interviewer Only)

   • All bug locations with line numbers
   • Exact fixes required
   • Expected time per bug
   • Hints to provide if stuck
   • Evaluation rubric

4. Supporting Files

   • Realistic error logs
   • Test files (some passing, some failing)
   • Environment templates

Example Commands

Basic Usage

Generate a broken interview project

Specific Requirements

Create a Node.js payment API with database bugs for a 45-minute Senior SDE interview

Generate a LangChain RAG assistant with prompt injection and vector DB bugs for AI Engineer role

Build a React dashboard with state management issues for Mid-level SDE, 30 minutes

Supported Technologies

Backend

• Node.js (Express, Fastify)
• Python (FastAPI, Flask)
• Java (Spring Boot)
• Go (Gin)

Frontend

• React
• Vue
• Angular
• Next.js

AI/ML

• LangChain
• LlamaIndex
• CrewAI
• OpenAI API
• HuggingFace

Databases

• PostgreSQL
• MongoDB
• Redis
• Pinecone
• ChromaDB

Project Templates

Pre-configured templates available:

• payment_processor - Payment service with database and API bugs
• user_auth_system - Authentication with security issues
• chat_assistant - LLM chat with RAG bugs
• data_pipeline - ETL with async/concurrency bugs
• ecommerce_checkout - Full-stack checkout flow
• analytics_dashboard - Real-time dashboard with performance issues
• microservices_api - Multiple services with deployment bugs

Bug Categories

The skill generates realistic bugs across categories:

Obvious (Quick to find)

• Missing imports or typos
• Wrong environment variable names
• Missing await on async calls
• Incorrect port numbers

Hidden (Require investigation)

• Race conditions
• Memory leaks
• Connection pool exhaustion
• N+1 query problems
• Async/await misuse

Design Issues (Senior+ roles)

• Missing rate limiting
• Security vulnerabilities (SQL injection, XSS)
• Missing input validation
• Performance bottlenecks
• Architecture anti-patterns

AI/ML Specific

• Prompt injection vulnerabilities
• Missing token limits
• Poor context window management
• Incorrect embedding dimensions
• Vector database connection issues

Difficulty Levels

Junior (30 mins)

• 3-4 obvious bugs
• 0-1 hidden bugs
• Focus: Reading error messages, basic debugging

Mid-level (45 mins)

• 2-3 obvious bugs
• 2-3 hidden bugs
• 1 design issue

Senior (60 mins)

• 1-2 obvious bugs
• 3-4 hidden bugs
• 2-3 design issues

Principal/Staff (60 mins)

• 0-1 obvious bugs
• 2-3 hidden bugs
• 3-4 architecture issues

Conducting the Interview

Before the Interview

1. Generate the project using this skill
2. Review the SOLUTION_GUIDE.md thoroughly
3. Create a GitHub repository
4. Push the generated code
5. Test that setup instructions work

During the Interview (Typical 45-min format)

0-5 mins: Introduction

• Share repo link
• Ask candidate to screen share
• Explain the task
• Start timer

5-15 mins: Setup & Obvious Bugs

• Candidate clones repo
• Installs dependencies
• Encounters first bugs
• Works through error messages

15-35 mins: Hidden Bugs

• Candidate investigates logs
• Forms hypotheses
• Tests fixes
• Explains reasoning

35-45 mins: Discussion

• Walk through their approach
• Discuss design issues
• Talk about improvements
• Ask about prevention

Evaluation Tips

Focus on:

• Process over results: How do they debug?
• Communication: Can they explain their thinking?
• Systematic approach: Random changes vs. hypothesis testing
• Tool usage: Logs, debuggers, error messages
• Testing: Do they verify their fixes?

Red flags:

• Doesn't read error messages
• Makes changes without understanding
• Can't explain what the bug was
• Doesn't test fixes
• Gives up without questions

Customization

Adjust Difficulty

Make this project easier - remove 2 hidden bugs

Add more design issues for a Principal Engineer

Add Specific Bug Types

Add a SQL injection vulnerability

Include a memory leak from event listeners

Change Technology

Convert this to Python FastAPI

Use PostgreSQL instead of MongoDB

Tips for Best Results

1. Be Specific: The more details you provide, the better the project

   Good: "Create a Node.js payment API with Stripe integration, database connection pooling bugs, and missing error handling for a Senior SDE"
   
   Less Good: "Make an interview project"
   

2. Match Role Expectations: Junior roles need more obvious bugs, senior roles need design issues

3. Time Budget Wisely:

   • 30 mins = 4-5 total bugs
   • 45 mins = 6-8 total bugs
   • 60 mins = 8-10 total bugs

4. Test Before Using: Run through the setup yourself to ensure it works

5. Reuse & Iterate: Save good projects and create variations for different candidates

Example Session

You: Use debug-interview skill

Claude: I'll help you generate a broken interview project. Let me ask a few questions:

1. What role level is this for?
   - Junior SDE
   - Mid-level SDE
   - Senior SDE
   - Staff/Principal Engineer
   - AI Engineer

You: Senior SDE

Claude: Great! Next questions:

2. How long should the interview be?
   - 30 minutes
   - 45 minutes
   - 60 minutes

You: 45 minutes

Claude: Perfect. Continuing:

3. What technology stack?
   - Node.js/Express
   - Python/FastAPI
   - Java/Spring Boot
   - Full-stack (React + Node)
   - Other (specify)

You: Node.js/Express with PostgreSQL

Claude: Excellent. Final questions:

4. What type of project?
   - REST API
   - Microservice
   - Full application

You: REST API for payment processing

Claude: Got it! Generating your project...

[Claude generates complete project]

Claude:
Generated Project: PaymentAPI-Interview
Type: REST API - Payment Processing
Stack: Node.js, Express, PostgreSQL, Stripe
Bugs: 2 obvious, 3 hidden, 2 design
Duration: 45 minutes
Role: Senior SDE

Files created:
- README.md (candidate instructions)
- SOLUTION_GUIDE.md (interviewer guide)
- src/index.js
- src/routes/payments.js
- src/services/database.js
- src/services/stripe.js
- tests/
- logs/
- .env.example
- package.json

Next steps:
1. Review SOLUTION_GUIDE.md
2. Create GitHub repo
3. Push code
4. Share with candidate

Would you like me to adjust anything?

Advanced Features

Generate Variations

Create 3 variations of this project with different bugs

Add Deployment Issues

Add Docker configuration bugs and deployment issues

Include Load Testing

Add a load test that reveals the connection pool bug

Multi-Step Interviews

Generate Part 1 (obvious bugs, 30 mins) and Part 2 (architecture review, 30 mins)

Troubleshooting

Skill not found?

• Verify installation path: ~/.claude/skills/debug-interview/
• Check file permissions: chmod +r ~/.claude/skills/debug-interview/*

Project too easy/hard?

• Ask Claude to adjust: "Make this harder" or "Reduce the hidden bugs"
• Specify exact bug count: "Include exactly 2 obvious bugs and 3 hidden bugs"

Need different tech stack?

• Just ask: "Convert this to Python" or "Use MongoDB instead"

Contributing

Have ideas for new templates or bug types? Add them to skill.yaml and skill.prompt.

Common additions:

• New project templates
• Language-specific bug patterns
• Domain-specific scenarios (fintech, healthcare, etc.)
• New technology stacks

License

MIT License - Use freely for your interview processes

Support

For issues or questions:

• Check the SKILL.md documentation
• Review example commands above
• Ask Claude for clarification: "How do I [specific task]?"

---

Happy interviewing! Use this skill to create fair, realistic debugging exercises that assess true problem-solving ability.