bmad-method 4.2.0 → 4.4.1

package/docs/claude-code-guide.md

@@ -0,0 +1,119 @@
+# BMAD Method Guide for Claude Code
+
+This guide walks you through the complete BMAD workflow using Claude Code as your AI-powered IDE.
+
+## Step 1: Install BMAD in Your Project
+
+1. Navigate to your project directory
+2. Run the BMAD installer:
+   ```bash
+   npx bmad-method install
+   ```
+3. When prompted:
+   - **Installation Type**: Choose "Complete installation (recommended)"
+   - **IDE**: Select "Claude Code"
+
+This creates a `.bmad-core` folder with all agents and a `.claude/commands` folder with agent commands.
+
+## Step 2: Set Up Team Fullstack in Gemini
+
+For ideation and planning, use Google's Gemini with the team-fullstack configuration:
+
+1. Open [Google AI Studio (Gemini)](https://aistudio.google.com/)
+2. Create a new chat
+3. Copy the contents of `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
+4. Paste this content into Gemini to set up the team
+
+### Gemini Planning Phase
+
+In Gemini, ask the BMAD team to help you:
+
+- **Ideate** your project concept
+- **Brainstorm** features and requirements
+- **Create a PRD** (Product Requirements Document)
+- **Design the architecture**
+
+Ask questions like:
+
+- "Help me brainstorm a [type of application] that does [core functionality]"
+- "Create a comprehensive PRD for this concept"
+- "Design the technical architecture for this system"
+
+Copy the PRD and architecture documents that Gemini creates into your project's `docs/` folder:
+
+- `docs/prd.md`
+- `docs/architecture.md`
+
+## Step 3: Back to Claude Code - Document Sharding
+
+Once you have your PRD and architecture documents in the `docs/` folder:
+
+1. **Start a new chat in Claude Code**
+2. **Load the bmad-master agent**: Type `/bmad-master`
+3. **Shard the PRD**: Type `*shard-doc docs/prd.md prd`
+4. **Shard the architecture**: Type `*shard-doc docs/architecture.md architecture`
+
+This creates organized folders:
+
+- `docs/prd/` - Contains broken down PRD sections
+- `docs/architecture/` - Contains broken down architecture sections
+
+## Step 4: Story Development Cycle
+
+Now begin the iterative development cycle:
+
+### Create Stories (Scrum Master)
+
+1. **Start a new chat**
+2. **Load SM agent**: Type `/sm`
+3. **Create story**: Type `*create` (this runs the create-next-story task)
+4. **Review the generated story**
+5. **If approved**: Set story status to "Approved" in the story file
+
+### Implement Stories (Developer)
+
+1. **Start a new chat**
+2. **Load Dev agent**: Type `/dev`
+3. **The agent will ask which story to implement**
+4. **Follow the development tasks** the agent provides
+5. **When story is complete**: Mark status as "Done"
+
+### Repeat the Cycle
+
+1. **Start a new chat with SM agent** (`/sm`)
+2. **Create next story**: Type `*create`
+3. **Review and approve**
+4. **Start new chat with Dev agent** (`/dev`)
+5. **Implement the story**
+6. **Repeat until project complete**
+
+## Available Commands in Claude Code
+
+All BMAD agents are available as Claude Code commands:
+
+- `/bmad-master` - Universal task executor
+- `/sm` - Scrum Master for story creation
+- `/dev` - Full-stack developer for implementation
+- `/architect` - Solution architect for design
+- `/pm` - Product manager for planning
+- `/analyst` - Business analyst for requirements
+- `/qa` - QA specialist for testing
+- `/po` - Product owner for prioritization
+- `/ux-expert` - UX specialist for design
+
+## Key Workflow Principles
+
+1. **Always start new chats** when switching agents to avoid context confusion
+2. **Use Gemini for initial planning** and ideation with the team-fullstack bundle
+3. **Use bmad-master for document management** (sharding, templates, etc.)
+4. **Follow the SM → Dev cycle** for consistent story development
+5. **Review and approve stories** before implementation begins
+
+## Tips for Success
+
+- **Keep chats focused**: Each chat should have one agent and one primary task
+- **Use \*help command**: Every agent supports `*help` to see available commands
+- **Review generated content**: Always review and approve stories before marking them ready
+- **Maintain status updates**: Keep story statuses current (Draft → Approved → InProgress → Done)
+
+This workflow ensures systematic, AI-assisted development following agile principles with clear handoffs between planning, story creation, and implementation phases.

package/docs/core-architecture.md

@@ -0,0 +1,213 @@
+# BMAD Method: Core Architecture
+
+This document serves as the definitive source of truth for the BMAD-Method's architecture. It is designed to be understood by both human developers and the AI agents that operate within the framework.
+
+## 1. Overview
+
+The BMAD-Method is an AI-Powered Agile Development Framework designed to transform software development by providing specialized AI agents for every role in a complete Agile team. The core purpose of the project is to provide a structured yet flexible set of prompts, templates, and workflows that users can employ to guide AI agents (like Gemini, Claude, or ChatGPT) to perform complex software development tasks in a predictable, high-quality manner.
+
+The system facilitates a full development lifecycle:
+
+1. **Ideation & Planning**: Brainstorming, market research, and creating project briefs.
+2. **Architecture & Design**: Defining system architecture and UI/UX specifications.
+3. **Development Execution**: A cyclical workflow where a Scrum Master (SM) agent drafts stories and a Developer (Dev) agent implements them one at a time. This process works for both new (Greenfield) and existing (Brownfield) projects.
+
+## 2. System Architecture Diagram
+
+The entire BMAD-Method ecosystem is designed around the `.bmad-core` directory, which acts as the brain of the operation. The `tools` directory provides the means to process and package this brain for different environments.
+
+````mermaid
+graph TD
+    subgraph BMAD Method Project
+        subgraph Core Framework
+            A["bmad-core"]
+            A --> B["agents"]
+            A --> C["agent-teams"]
+            A --> D["workflows"]
+            A --> E["templates"]
+            A --> F["tasks"]
+            A --> G["checklists"]
+            A --> H["data (KB)"]
+        end
+
+        subgraph Tooling
+            I["tools/builders/web-builder.js"]
+        end
+
+        subgraph Outputs
+            J[".bmad-core/web-bundles"]
+        end
+
+        B -- defines dependencies for --> E
+        B -- defines dependencies for --> F
+        B -- defines dependencies for --> G
+        B -- defines dependencies for --> H
+
+        C -- bundles --> B
+        I -- reads from --> A
+        I -- creates --> J
+    end
+
+    subgraph Target Environments
+        K["IDE (Cursor, VS Code, etc.)"]
+        L["Web UI (Gemini, ChatGPT)"]
+    end
+
+    B --> K
+    J --> L
+
+    style A fill:#1a73e8,color:#fff
+    style I fill:#f9ab00,color:#fff
+    style J fill:#34a853,color:#fff
+```text
+
+## 3. Core Components
+
+The `.bmad-core` directory contains all the definitions and resources that give the agents their capabilities.
+
+### 3.1. Agents (`.bmad-core/agents/`)
+
+- **Purpose**: These are the foundational building blocks of the system. Each markdown file (e.g., `bmad-master.md`, `pm.md`, `dev.md`) defines the persona, capabilities, and dependencies of a single AI agent.
+- **Structure**: An agent file contains a YAML header that specifies its role, persona, dependencies, and startup instructions. These dependencies are lists of tasks, templates, checklists, and data files that the agent is allowed to use.
+- **Startup Instructions**: Agents can include startup sequences that load project-specific documentation from the `docs/` folder, such as coding standards, API specifications, or project structure documents. This provides immediate project context upon activation.
+- **Document Integration**: Agents can reference and load documents from the project's `docs/` folder as part of tasks, workflows, or startup sequences. Users can also drag documents directly into chat interfaces to provide additional context.
+- **Example**: The `bmad-master` agent lists its dependencies, which tells the build tool which files to include in a web bundle and informs the agent of its own capabilities.
+
+### 3.2. Agent Teams (`.bmad-core/agent-teams/`)
+
+- **Purpose**: Team files (e.g., `team-all.yml`) define collections of agents and workflows that are bundled together for a specific purpose, like "full-stack development" or "backend-only". This creates a larger, pre-packaged context for web UI environments.
+- **Structure**: A team file lists the agents to include. It can use wildcards, such as `"*"` to include all agents. This allows for the creation of comprehensive bundles like `team-all`.
+
+### 3.3. Workflows (`.bmad-core/workflows/`)
+
+- **Purpose**: Workflows are YAML files (e.g., `greenfield-fullstack.yml`) that define a prescribed sequence of steps and agent interactions for a specific project type. They act as a strategic guide for the user and the `bmad-orchestrator` agent.
+- **Structure**: A workflow defines sequences for both complex and simple projects, lists the agents involved at each step, the artifacts they create, and the conditions for moving from one step to the next. It often includes a Mermaid diagram for visualization.
+
+### 3.4. Reusable Resources (`templates`, `tasks`, `checklists`, `data`)
+
+- **Purpose**: These folders house the modular components that are dynamically loaded by agents based on their dependencies.
+  - **`templates/`**: Contains markdown templates for common documents like PRDs, architecture specifications, and user stories.
+  - **`tasks/`**: Defines the instructions for carrying out specific, repeatable actions like "shard-doc" or "create-next-story".
+  - **`checklists/`**: Provides quality assurance checklists for agents like the Product Owner (`po`) or Architect.
+  - **`data/`**: Contains the core knowledge base (`bmad-kb.md`), technical preferences (`technical-preferences.md`), and other key data files.
+
+#### 3.4.1. Template Processing System
+
+A key architectural principle of BMAD is that templates are self-contained and interactive - they embed both the desired document output and the LLM instructions needed to work with users. This means that in many cases, no separate task is needed for document creation, as the template itself contains all the processing logic.
+
+The BMAD framework employs a sophisticated template processing system orchestrated by three key components:
+
+- **`template-format.md`** (`.bmad-core/utils/`): Defines the foundational markup language used throughout all BMAD templates. This specification establishes syntax rules for variable substitution (`{{placeholders}}`), AI-only processing directives (`[[LLM: instructions]]`), and conditional logic blocks. Templates follow this format to ensure consistent processing across the system.
+
+- **`create-doc.md`** (`.bmad-core/tasks/`): Acts as the orchestration engine that manages the entire document generation workflow. This task coordinates template selection, manages user interaction modes (incremental vs. rapid generation), enforces template-format processing rules, and handles validation. It serves as the primary interface between users and the template system.
+
+- **`advanced-elicitation.md`** (`.bmad-core/tasks/`): Provides an interactive refinement layer that can be embedded within templates through `[[LLM: instructions]]` blocks. This component offers 10 structured brainstorming actions, section-by-section review capabilities, and iterative improvement workflows to enhance content quality.
+
+The system maintains a clean separation of concerns: template markup is processed internally by AI agents but never exposed to users, while providing sophisticated AI processing capabilities through embedded intelligence within the templates themselves.
+
+#### 3.4.2. Technical Preferences System
+
+BMAD includes a personalization layer through the `technical-preferences.md` file in `.bmad-core/data/`. This file serves as a persistent technical profile that influences agent behavior across all projects.
+
+**Purpose and Benefits:**
+- **Consistency**: Ensures all agents reference the same technical preferences
+- **Efficiency**: Eliminates the need to repeatedly specify preferred technologies
+- **Personalization**: Agents provide recommendations aligned with user preferences
+- **Learning**: Captures lessons learned and preferences that evolve over time
+
+**Content Structure:**
+The file typically includes preferred technology stacks, design patterns, external services, coding standards, and anti-patterns to avoid. Agents automatically reference this file during planning and development to provide contextually appropriate suggestions.
+
+**Integration Points:**
+- Templates can reference technical preferences during document generation
+- Agents suggest preferred technologies when appropriate for project requirements
+- When preferences don't fit project needs, agents explain alternatives
+- Web bundles can include preferences content for consistent behavior across platforms
+
+**Evolution Over Time:**
+Users are encouraged to continuously update this file with discoveries from projects, adding both positive preferences and technologies to avoid, creating a personalized knowledge base that improves agent recommendations over time.
+
+## 4. The Build & Delivery Process
+
+The framework is designed for two primary environments: local IDEs and web-based AI chat interfaces. The `web-builder.js` script is the key to supporting the latter.
+
+### 4.1. Web Builder (`tools/builders/web-builder.js`)
+
+- **Purpose**: This Node.js script is responsible for creating the `.txt` bundles found in `.bmad-core/web-bundles/`.
+- **Process**:
+  1. **Resolves Dependencies**: For a given agent or team, the script reads its definition file.
+  2. It recursively finds all dependent resources (tasks, templates, etc.) that the agent/team needs.
+  3. **Bundles Content**: It reads the content of all these files and concatenates them into a single, large text file, with clear separators indicating the original file path of each section.
+  4. **Outputs Bundle**: The final `.txt` file is saved in the `web-bundles` directory, ready to be uploaded to a web UI.
+
+### 4.2. Environment-Specific Usage
+
+- **For IDEs**: Users interact with the agents directly via their markdown files in `.bmad-core/agents/`. The IDE integration (for Cursor, Claude Code, etc.) knows how to call these agents.
+- **For Web UIs**: Users upload a pre-built bundle from `.bmad-core/web-bundles/`. This single file provides the AI with the context of the entire team and all their required tools and knowledge.
+
+## 5. BMAD Workflows
+
+### 5.1. The Planning Workflow
+
+Before development begins, BMAD follows a structured planning workflow that establishes the foundation for successful project execution:
+
+```mermaid
+graph TD
+    A["Start: Project Idea"] --> B{"Optional: Analyst Brainstorming"}
+    B -->|Yes| C["Analyst: Market Research & Analysis"]
+    B -->|No| D["Create Project Brief"]
+    C --> D["Analyst: Create Project Brief"]
+    D --> E["PM: Create PRD from Brief"]
+    E --> F["Architect: Create Architecture from PRD"]
+    F --> G["PO: Run Master Checklist"]
+    G --> H{"Documents Aligned?"}
+    H -->|Yes| I["Planning Complete"]
+    H -->|No| J["PO: Update Epics & Stories"]
+    J --> K["Update PRD/Architecture as needed"]
+    K --> G
+    I --> L["📁 Switch to IDE"]
+    L --> M["PO: Shard Documents"]
+    M --> N["Ready for SM/Dev Cycle"]
+
+    style I fill:#34a853,color:#fff
+    style G fill:#f9ab00,color:#fff
+    style L fill:#1a73e8,color:#fff
+    style N fill:#34a853,color:#fff
+````
+
+**Key Planning Phases:**
+
+1. **Optional Analysis**: Analyst conducts market research and competitive analysis
+2. **Project Brief**: Foundation document created by Analyst or user
+3. **PRD Creation**: PM transforms brief into comprehensive product requirements
+4. **Architecture Design**: Architect creates technical foundation based on PRD
+5. **Validation & Alignment**: PO ensures all documents are consistent and complete
+6. **Refinement**: Updates to epics, stories, and documents as needed
+7. **Environment Transition**: Critical switch from web UI to IDE for development workflow
+8. **Document Preparation**: PO shards large documents for development consumption
+
+**Workflow Orchestration**: The `bmad-orchestrator` agent uses these workflow definitions to guide users through the complete process, ensuring proper transitions between planning (web UI) and development (IDE) phases.
+
+### 5.2. The Core Development Cycle
+
+Once the initial planning and architecture phases are complete, the project moves into a cyclical development workflow, as detailed in the `bmad-kb.md`. This ensures a steady, sequential, and quality-controlled implementation process.
+
+```mermaid
+graph TD
+    A["Start: Planning Artifacts Complete"] --> B["PO: Shard Epics"]
+    B --> C["PO: Shard Arch"]
+    C --> D["Development Phase"]
+    D --> E["Scrum Master: Drafts next story from sharded epic"]
+    E --> F{"User Approval"}
+    F -->|Approved| G["Dev: Implement Story"]
+    F -->|Needs Changes| E
+    G --> H["Dev: Complete story Tasks"]
+    H --> I{"User Verification"}
+    I -->|Verified Complete| J["Mark Story as Done"]
+    I -->|Needs Fixes| G
+    J --> E
+
+    style J fill:#34a853,color:#fff
+```
+
+This cycle continues, with the Scrum Master and Developer agents working in tandem, until all stories in the epic are completed.

package/docs/cursor-guide.md

@@ -0,0 +1,127 @@
+# BMAD Method Guide for Cursor
+
+This guide walks you through the complete BMAD workflow using Cursor as your AI-powered IDE.
+
+## Step 1: Install BMAD in Your Project
+
+1. Navigate to your project directory
+2. Run the BMAD installer:
+   ```bash
+   npx bmad-method install
+   ```
+3. When prompted:
+   - **Installation Type**: Choose "Complete installation (recommended)"
+   - **IDE**: Select "Cursor"
+
+This creates a `.bmad-core` folder with all agents and a `.cursor/rules` folder with agent rules.
+
+## Step 2: Set Up Team Fullstack in Gemini
+
+For ideation and planning, use Google's Gemini with the team-fullstack configuration:
+
+1. Open [Google AI Studio (Gemini)](https://aistudio.google.com/)
+2. Create a new chat
+3. Copy the contents of `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
+4. Paste this content into Gemini to set up the team
+
+### Gemini Planning Phase
+
+In Gemini, ask the BMAD team to help you:
+
+- **Ideate** your project concept
+- **Brainstorm** features and requirements
+- **Create a PRD** (Product Requirements Document)
+- **Design the architecture**
+
+Ask questions like:
+
+- "Help me brainstorm a [type of application] that does [core functionality]"
+- "Create a comprehensive PRD for this concept"
+- "Design the technical architecture for this system"
+
+Copy the PRD and architecture documents that Gemini creates into your project's `docs/` folder:
+
+- `docs/prd.md`
+- `docs/architecture.md`
+
+## Step 3: Back to Cursor - Document Sharding
+
+Once you have your PRD and architecture documents in the `docs/` folder:
+
+1. **Start a new chat in Cursor**
+2. **Load the bmad-master agent**: Type `@bmad-master`
+3. **Shard the PRD**: Type `*shard-doc docs/prd.md prd`
+4. **Shard the architecture**: Type `*shard-doc docs/architecture.md architecture`
+
+This creates organized folders:
+
+- `docs/prd/` - Contains broken down PRD sections
+- `docs/architecture/` - Contains broken down architecture sections
+
+## Step 4: Story Development Cycle
+
+Now begin the iterative development cycle:
+
+### Create Stories (Scrum Master)
+
+1. **Start a new chat**
+2. **Load SM agent**: Type `@sm`
+3. **Create story**: Type `*create` (this runs the create-next-story task)
+4. **Review the generated story**
+5. **If approved**: Set story status to "Approved" in the story file
+
+### Implement Stories (Developer)
+
+1. **Start a new chat**
+2. **Load Dev agent**: Type `@dev`
+3. **The agent will ask which story to implement**
+4. **Follow the development tasks** the agent provides
+5. **When story is complete**: Mark status as "Done"
+
+### Repeat the Cycle
+
+1. **Start a new chat with SM agent** (`@sm`)
+2. **Create next story**: Type `*create`
+3. **Review and approve**
+4. **Start new chat with Dev agent** (`@dev`)
+5. **Implement the story**
+6. **Repeat until project complete**
+
+## Available Agent Rules in Cursor
+
+All BMAD agents are available as Cursor rules (use `@` prefix):
+
+- `@bmad-master` - Universal task executor
+- `@sm` - Scrum Master for story creation
+- `@dev` - Full-stack developer for implementation
+- `@architect` - Solution architect for design
+- `@pm` - Product manager for planning
+- `@analyst` - Business analyst for requirements
+- `@qa` - QA specialist for testing
+- `@po` - Product owner for prioritization
+- `@ux-expert` - UX specialist for design
+
+## Cursor-Specific Features
+
+- **Agent rules are stored in**: `.cursor/rules/` as `.mdc` files
+- **Auto-completion**: Cursor will suggest `@agent-name` as you type
+- **Rule activation**: Rules activate automatically when you mention `@agent-name`
+- **Context awareness**: Agents have access to your current file context
+
+## Key Workflow Principles
+
+1. **Always start new chats** when switching agents to avoid context confusion
+2. **Use Gemini for initial planning** and ideation with the team-fullstack bundle
+3. **Use bmad-master for document management** (sharding, templates, etc.)
+4. **Follow the SM → Dev cycle** for consistent story development
+5. **Review and approve stories** before implementation begins
+
+## Tips for Success
+
+- **Keep chats focused**: Each chat should have one agent and one primary task
+- **Use \*help command**: Every agent supports `*help` to see available commands
+- **Review generated content**: Always review and approve stories before marking them ready
+- **Maintain status updates**: Keep story statuses current (Draft → Approved → InProgress → Done)
+- **Leverage Cursor's context**: Agents can see your current file selection for better assistance
+
+This workflow ensures systematic, AI-assisted development following agile principles with clear handoffs between planning, story creation, and implementation phases.

package/docs/how-to-contribute-with-pull-requests.md

@@ -0,0 +1,141 @@
+# How to Contribute with Pull Requests
+
+**New to GitHub and pull requests?** This guide will walk you through the basics step by step.
+
+## What is a Pull Request?
+
+A pull request (PR) is how you propose changes to a project on GitHub. Think of it as saying "Here are some changes I'd like to make - please review and consider adding them to the main project."
+
+## Before You Start
+
+⚠️ **Important**: Please keep your contributions small and focused! We prefer many small, clear changes rather than one massive change. If you're planning something big, please [open an issue](https://github.com/bmadcode/bmad-method/issues) or start a [discussion](https://github.com/bmadcode/bmad-method/discussions) first.
+
+## Step-by-Step Guide
+
+### 1. Fork the Repository
+
+1. Go to the [BMAD-METHOD repository](https://github.com/bmadcode/bmad-method)
+2. Click the "Fork" button in the top-right corner
+3. This creates your own copy of the project
+
+### 2. Clone Your Fork
+
+````bash
+# Replace YOUR-USERNAME with your actual GitHub username
+git clone https://github.com/YOUR-USERNAME/bmad-method.git
+cd bmad-method
+```text
+
+### 3. Create a New Branch
+
+**Never work directly on the `main` branch!** Always create a new branch for your changes:
+
+```bash
+# Create and switch to a new branch
+git checkout -b fix/typo-in-readme
+# or
+git checkout -b feature/add-new-agent
+````
+
+**Branch naming tips:**
+
+- `fix/description` - for bug fixes
+- `feature/description` - for new features
+- `docs/description` - for documentation changes
+
+### 4. Make Your Changes
+
+- Edit the files you want to change
+- Keep changes small and focused on one thing
+- Test your changes if possible
+
+### 5. Commit Your Changes
+
+````bash
+# Add your changes
+git add .
+
+# Commit with a clear message
+git commit -m "Fix typo in README.md"
+```text
+
+**Good commit messages:**
+
+- "Fix typo in installation instructions"
+- "Add example for new agent usage"
+- "Update broken link in docs"
+
+**Bad commit messages:**
+
+- "stuff"
+- "changes"
+- "update"
+
+### 6. Push to Your Fork
+
+```bash
+# Push your branch to your fork
+git push origin fix/typo-in-readme
+````
+
+### 7. Create the Pull Request
+
+1. Go to your fork on GitHub
+2. You'll see a green "Compare & pull request" button - click it
+3. Fill out the PR template:
+   - **Title**: Clear, descriptive title
+   - **Description**: Explain what you changed and why
+
+### 8. Wait for Review
+
+- A maintainer will review your PR
+- They might ask for changes
+- Be patient and responsive to feedback
+
+## What Makes a Good Pull Request?
+
+✅ **Good PRs:**
+
+- Change one thing at a time
+- Have clear, descriptive titles
+- Explain what and why in the description
+- Include only the files that need to change
+
+❌ **Avoid:**
+
+- Changing formatting of entire files
+- Multiple unrelated changes in one PR
+- Copying your entire project/repo into the PR
+- Changes without explanation
+
+## Common Mistakes to Avoid
+
+1. **Don't reformat entire files** - only change what's necessary
+2. **Don't include unrelated changes** - stick to one fix/feature per PR
+3. **Don't paste code in issues** - create a proper PR instead
+4. **Don't submit your whole project** - contribute specific improvements
+
+## Need Help?
+
+- 💬 Join our [Discord Community](https://discord.gg/g6ypHytrCB) for real-time help
+- 💬 Ask questions in [Discussions](https://github.com/bmadcode/bmad-method/discussions)
+- 🐛 Report bugs in [Issues](https://github.com/bmadcode/bmad-method/issues)
+- 📖 Read the full [Contributing Guidelines](../CONTRIBUTING.md)
+
+## Example: Good vs Bad PRs
+
+### 😀 Good PR Example
+
+**Title**: "Fix broken link to installation guide"
+**Changes**: One file, one line changed
+**Description**: "The link in README.md was pointing to the wrong file. Updated to point to correct installation guide."
+
+### 😞 Bad PR Example
+
+**Title**: "Updates"
+**Changes**: 50 files, entire codebase reformatted
+**Description**: "Made some improvements"
+
+---
+
+**Remember**: We're here to help! Don't be afraid to ask questions. Every expert was once a beginner.