diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 00000000000..02327ec43b2
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,16 @@
+<!-- Read https://github.com/TheSuperHackers/GeneralsGameCode/tree/main/documentation/how_to_write_a_pull_request.md -->
+## Change list
+<!-- List changes -->
+- 
+
+## Author(s)
+<!-- List additional authors -->
+
+## Fixes Issue(s) <!-- [Optional - Remove if unused] -->
+<!-- Closes/Fixes/Resolves an issue (#123) -->
+
+## Updates PR(s) <!-- [Optional - Remove if unused] -->
+<!-- Updates/Continues a PR (#234) -->
+
+## Additional Notes <!-- [Optional - Remove if unused] -->
+<!-- None changelog related notes -->
\ No newline at end of file
diff --git a/.github/workflows/changelog-file-generation.yaml b/.github/workflows/changelog-file-generation.yaml
new file mode 100644
index 00000000000..699dec3bdda
--- /dev/null
+++ b/.github/workflows/changelog-file-generation.yaml
@@ -0,0 +1,62 @@
+name: Generate Changelog
+on:
+  pull_request:
+    types: [closed]
+
+  workflow_dispatch:
+    inputs:
+      pr-number:
+        description: 'PR number to process'
+        required: true
+        type: number
+
+env:
+    SCRIPTS_PATH: .github/workflows/scripts/changelog_file_generation
+    CONFIG: pr_changelog_config.yaml
+
+jobs:
+  process-pr:
+    if: |
+      github.event_name == 'workflow_dispatch' || 
+      (github.event_name == 'pull_request' && github.event.pull_request.merged)
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r ${{ env.SCRIPTS_PATH }}/requirements.txt
+
+    - name: Determine PR number
+      id: pr-number
+      run: |
+        if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+        echo "pr_number=${{ github.event.inputs.pr-number }}" >> $GITHUB_OUTPUT
+        else
+        echo "pr_number=${{ github.event.pull_request.number }}" >> $GITHUB_OUTPUT
+        fi
+
+    - name: Run changelog generator
+      env:
+        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        GH_REPOSITORY: ${{ github.repository }}
+      run: |
+        python ${{ env.SCRIPTS_PATH}}/src/generate_pr_yaml.py --pr-number ${{ steps.pr-number.outputs.pr_number }} --config ${{ env.CONFIG }} --force
+
+    - name: Commit generated files
+      run: |
+        git config --global user.name "GitHub Actions"
+        git config --global user.email "actions@github.com"
+        git add changelogs/unreleased/*
+        git commit -m "Add changelog for PR #${{ steps.pr-number.outputs.pr_number }}" || echo "No changes to commit"
+        git push
\ No newline at end of file
diff --git a/.github/workflows/pr-linter.yml b/.github/workflows/pr-linter.yml
new file mode 100644
index 00000000000..f0113039a5f
--- /dev/null
+++ b/.github/workflows/pr-linter.yml
@@ -0,0 +1,47 @@
+name: PR Linter
+on:
+  pull_request:
+    types: [opened, edited, synchronize, reopened]
+  workflow_dispatch:
+    inputs:
+      pr-number:
+        description: 'PR number to process'
+        required: true
+        type: number
+
+env:
+  SCRIPTS_PATH: .github/workflows/scripts/changelog_file_generation
+  CONFIG: pr_changelog_config.yaml
+
+jobs:
+  validate-pr:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r ${{ env.SCRIPTS_PATH }}/requirements.txt
+
+      - name: Determine PR number
+        id: pr-number
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+          echo "pr_number=${{ github.event.inputs.pr-number }}" >> $GITHUB_OUTPUT
+          else
+          echo "pr_number=${{ github.event.pull_request.number }}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Run PR Linter
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_REPOSITORY: ${{ github.repository }}
+        run: |
+          python ${{ env.SCRIPTS_PATH}}/src/pr_linter.py --pr-number ${{ steps.pr-number.outputs.pr_number }}
\ No newline at end of file
diff --git a/.github/workflows/scripts/changelog_file_generation/pr_changelog_config.yaml b/.github/workflows/scripts/changelog_file_generation/pr_changelog_config.yaml
new file mode 100644
index 00000000000..4a2ef3829a2
--- /dev/null
+++ b/.github/workflows/scripts/changelog_file_generation/pr_changelog_config.yaml
@@ -0,0 +1,86 @@
+# PR Changelog Generator Configuration
+# ------------------------------------
+# Defines how to parse PR content and structure output YAML
+
+# Section Processing Configuration
+sections:
+  # Change List Section
+  changes:
+    header: "Change list"
+    pattern: "^(\\w+): (.+)"
+    yaml_key: "changes"
+    processor: "key_value"
+    example: "- fix: Description of change"
+    required: true
+    allowed_keywords:
+      - fix
+      - feat
+      - breaking
+      - build
+      - ci
+      - balance
+      - performance
+      - docs
+      - test
+
+  # Authors Section
+  authors:
+    header: "Author\\(s\\)"
+    pattern: "@?(\\w+)"
+    yaml_key: "authors"
+    default: "$pr_creator"
+    example: "@username"
+    merge_with: ["$pr_creator"]
+    processor: "flat_list"
+
+  # Labels Section
+  fixes_issues:
+    header: "Fixes Issue\\(s\\)"
+    pattern: "([Cc]loses|[Ff]ixes|[Rr]esolves) (#?\\d+)"
+    yaml_key: "fixes_issues"
+    example: "- closes #123 or - fixes https://github.com/.../issues/456"
+    processor: "structured_links"
+    link_type: "issue"
+
+  # Linked PRs Section
+  updates_prs:
+    header: "Updates PR\\(s\\)"
+    pattern: "([Uu]pdates|[Cc]ontinues) (#?\\d+)"
+    yaml_key: "updates_prs"
+    example: "- Updates #2"
+    processor: "structured_links"
+    link_type: "pr"
+
+# Title Processing Configuration
+title_processing:
+  scope_pattern: "^\\[([\\w\/]+)\\]"  # Pattern to extract scopes from title
+  scope_key: "affects"                # YAML key for extracted scopes
+  clean_title: true                   # Whether to remove scopes from final title
+  example: "[GEN] short description, or [GEN/ZH] short description"  # Example title format
+  allowed_scopes:                     # Validate title prefixes
+    - GEN
+    - ZH
+    - GITHUB
+    - BUILD
+    - AI
+    - ART
+    - AUDIO
+
+# Output Configuration
+output:
+  required_keys:                                      # Mandatory keys in final YAML
+    - "date"
+    - "title"
+    - "changes"
+  filename_template: "$pr_number_$clean_title.yaml"   # Output filename pattern
+  directory: "changelogs/unreleased"                  # Output directory for YAML files
+  order:                                              # Order of keys in final YAML
+    - date
+    - title
+    - affects
+    - changes
+    - labels
+    - links
+    - authors
+    - fixes_issues
+    - updates_prs
\ No newline at end of file
diff --git a/.github/workflows/scripts/changelog_file_generation/requirements.txt b/.github/workflows/scripts/changelog_file_generation/requirements.txt
new file mode 100644
index 00000000000..4df84e3144f
Binary files /dev/null and b/.github/workflows/scripts/changelog_file_generation/requirements.txt differ
diff --git a/.github/workflows/scripts/changelog_file_generation/src/generate_pr_yaml.py b/.github/workflows/scripts/changelog_file_generation/src/generate_pr_yaml.py
new file mode 100644
index 00000000000..c0e042da85c
--- /dev/null
+++ b/.github/workflows/scripts/changelog_file_generation/src/generate_pr_yaml.py
@@ -0,0 +1,411 @@
+import argparse
+import re
+import yaml
+from pathlib import Path
+from github import Github, Auth, PullRequest, Repository
+from datetime import datetime
+from ruamel.yaml import YAML, CommentedMap
+from typing import Any, Dict, List, Pattern, Tuple, Union
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Type aliases for better readability
+ConfigDict = Dict[str, Any]
+SectionConfig = Dict[str, Union[str, List[str], bool]]
+
+
+class PRProcessor:
+    """Main processor class for converting PR data to structured YAML"""
+
+    def __init__(self, config_path: str) -> None:
+        """
+        Initialize processor with configuration file
+
+        Args:
+            config_path: Path to YAML configuration file
+        """
+        with open(config_path) as f:
+            self.config: ConfigDict = yaml.safe_load(f)
+
+        self.parsed_data: Dict[str, Any] = {}
+        self.repo_context: Dict[str, Union[str, int]] = {}
+
+    def process_pr(
+        self, pr: PullRequest.PullRequest, repo: Repository.Repository
+    ) -> Dict[str, Any]:
+        """
+        Process a GitHub PR and generate structured data
+
+        Args:
+            pr: GitHub PullRequest object
+            repo: GitHub Repository object
+
+        Returns:
+            Dictionary containing processed data and output filename
+        """
+        self._setup_repo_context(pr, repo)
+        self._process_title(pr.title)
+        self._process_body(pr.body, repo.html_url)
+        self._process_github_metadata(pr)
+        return self._prepare_output()
+
+    def _setup_repo_context(self, pr: Any, repo: Any) -> None:
+        """Store repository context including API object"""
+        self.repo_context = {
+            "repo_url": repo.html_url,
+            "pr_creator": pr.user.login,
+            "pr_number": pr.number,
+            "repo_object": repo,  # Store actual repo object for API access
+        }
+
+    def _process_title(self, title: str) -> None:
+        """
+        Extract scopes and clean title based on configuration
+
+        Args:
+            title: Original PR title from GitHub
+        """
+        title_config = self.config.get("title_processing", {})
+        scope_pattern: str = title_config.get("scope_pattern", r"^\[([\w\/]+)\]")
+        scopes: List[str] = []
+        remaining_title = title
+
+        # Extract scopes using configured pattern
+        while True:
+            match = re.match(scope_pattern, remaining_title)
+            if not match:
+                break
+            scopes.extend(match.group(1).upper().split("/"))
+            remaining_title = remaining_title[match.end() :].strip()
+
+        # Validate allowed scopes
+        allowed_scopes = self.config["title_processing"].get("allowed_scopes", [])
+        if allowed_scopes:
+            invalid_scopes = [s for s in scopes if s.upper() not in allowed_scopes]
+            if invalid_scopes:
+                print(
+                    f"Warning: Disallowed scopes detected - {', '.join(invalid_scopes)}"
+                )
+            scopes = [s for s in scopes if s.upper() in allowed_scopes]
+
+        # Store processed data
+        if scope_key := title_config.get("scope_key"):
+            self.parsed_data[scope_key] = scopes
+
+        self.parsed_data["title"] = (
+            remaining_title if title_config.get("clean_title", True) else title
+        )
+
+    def _process_body(self, pr_body: Union[str, None], repo_url: str) -> None:
+        """
+        Process PR body content using configured section definitions
+
+        Args:
+            pr_body: Raw PR body content from GitHub
+            repo_url: Base URL of the repository
+        """
+        sections = self._parse_markdown_sections(pr_body or "")
+
+        for section_name, config in self.config.get("sections", {}).items():
+            if processed := self._process_section(sections, config, repo_url):
+                self._merge_data(
+                    yaml_key=config["yaml_key"],
+                    new_data=processed,
+                    merge_keys=config.get("merge_with", []),
+                )
+
+    def _parse_markdown_sections(self, pr_body: str) -> Dict[str, List[str]]:
+        """
+        Parse PR body into markdown sections
+
+        Args:
+            pr_body: Raw PR body content
+
+        Returns:
+            Dictionary of section names to their content lines
+        """
+        sections: Dict[str, List[str]] = {}
+        current_section = None
+        cleaned_body = re.sub(r"<!--.*?-->", "", pr_body, flags=re.DOTALL)
+
+        for line in cleaned_body.split("\n"):
+            line = line.strip()
+            if line.startswith("## "):
+                current_section = line[3:].split("<!--")[0].strip().lower()
+                sections[current_section] = []
+            elif current_section:
+                sections[current_section].append(line)
+
+        return sections
+
+    def _process_section(
+        self, sections: Dict[str, List[str]], config: SectionConfig, repo_url: str
+    ) -> List[str]:
+        """
+        Process a single section based on configuration
+
+        Args:
+            sections: All parsed markdown sections
+            config: Section processing configuration
+            repo_url: Base repository URL for link resolution
+
+        Returns:
+            List of processed values from this section
+        """
+        target_header = config["header"].lower()
+        section_content: List[str] = []
+
+        # Find matching section header
+        for section_name in sections:
+            if re.fullmatch(config["header"], section_name, re.IGNORECASE):
+                section_content = sections[section_name]
+                break
+
+        # Process section content
+        processed: List[str] = []
+        processor = config.get("processor")
+        pattern: Pattern = re.compile(config["pattern"])
+
+        for line in section_content:
+            # Clean line and remove list markers
+            clean_line = re.sub(r"^-\s*", "", line.strip())
+            matches = pattern.findall(clean_line)
+
+            if not matches:
+                continue
+
+            if processor == "key_value":
+                processed.extend(
+                    [
+                        {match[0].strip(): match[1].strip()}
+                        for match in matches
+                        if len(match) >= 2
+                    ]
+                )
+            elif processor == "structured_links":
+                processed.extend(
+                    [
+                        {
+                            "action": m[0].lower(),
+                            "link": self._resolve_reference(m[1], config["link_type"]),
+                        }
+                        for m in matches
+                        if len(m) >= 2
+                    ]
+                )
+            elif processor == "flat_list":
+                processed.extend([m[0] if isinstance(m, tuple) else m for m in matches])
+            else:
+                processed.extend(matches)
+
+        # Handle default values if no matches found
+        if not processed and "default" in config:
+            default = self._resolve_context_value(config["default"])
+            processed = default if isinstance(default, list) else [default]
+
+        if config.get("allowed_keywords"):
+            processed = [
+                item
+                for item in processed
+                if self._validate_keyword(item, config["allowed_keywords"])
+            ]
+
+        return processed
+
+    def _validate_keyword(self, item: Any, allowed: List[str]) -> bool:
+        """Validate change type keywords against allowed list"""
+        if isinstance(item, dict):
+            key = next(iter(item.keys()))
+            if key not in allowed:
+                print(f"Warning: Disallowed keyword '{key}' found, skipping entry")
+                return False
+        return True
+
+    def _apply_processor(
+        self, matches: List[Union[str, Tuple]], processor: str
+    ) -> List[Any]:
+        """Handle different processor types safely"""
+        if processor == "structured_links":
+            return [self._process_structured_link(m) for m in matches]
+        elif processor == "flat_list":
+            return [m[0] if isinstance(m, tuple) else m for m in matches]
+        return matches
+
+    def _process_structured_link(self, match: Union[str, Tuple]) -> Dict[str, str]:
+        """Convert tuple matches to structured links"""
+        if isinstance(match, tuple) and len(match) >= 2:
+            return {"action": match[0].lower(), "link": match[1]}
+        return {"action": "unknown", "link": str(match)}
+
+    def _resolve_reference(self, ref: str, ref_type: str) -> str:
+        """Resolve references using GitHub API with type validation"""
+        try:
+            # Extract numeric ID from any format (#123 or 123)
+            ref_num = int(ref.lstrip("#"))
+            repo = self.repo_context["repo_object"]
+
+            if ref_type == "issue":
+                issue = repo.get_issue(ref_num)
+                return issue.html_url
+            elif ref_type == "pr":
+                pr = repo.get_pull(ref_num)
+                return pr.html_url
+
+        except Exception as e:
+            print(f"⚠️ Failed to resolve {ref} as {ref_type}: {str(e)}")
+            return f"{self.repo_context['repo_url']}/{ref_type}s/{ref_num}"
+
+    def _merge_data(
+        self, yaml_key: str, new_data: List[Any], merge_keys: List[str]
+    ) -> None:
+        """Merge processed data with existing values and context"""
+        current = self.parsed_data.get(yaml_key, [])
+
+        # Add context values (e.g., PR creator)
+        for key in merge_keys:
+            if context_value := self._resolve_context_value(key):
+                current.extend(
+                    context_value
+                    if isinstance(context_value, list)
+                    else [context_value]
+                )
+
+        # Add new data and deduplicate
+        current.extend(new_data)
+
+        # Handle duplicate removal for both hashable and unhashable types
+        seen = set()
+        deduped = []
+        for item in current:
+            # Create a hashable representation for dictionaries
+            if isinstance(item, dict):
+                item_repr = frozenset(item.items())
+            else:
+                item_repr = item
+
+            if item_repr not in seen:
+                seen.add(item_repr)
+                deduped.append(item)
+
+        self.parsed_data[yaml_key] = deduped
+
+    def _resolve_context_value(self, value: Union[str, Any]) -> Any:
+        """Resolve $ prefixed context variables"""
+        if isinstance(value, str) and value.startswith("$"):
+            return self.repo_context.get(value[1:], "")
+        return value
+
+    def _process_github_metadata(self, pr: Any) -> None:
+        """Add GitHub-specific metadata to parsed data"""
+        self.parsed_data.setdefault(
+            "date",
+            (
+                pr.merged_at.strftime("%Y-%m-%d")
+                if pr.merged_at
+                else datetime.now().strftime("%Y-%m-%d")
+            ),
+        )
+        self.parsed_data.setdefault("labels", sorted(label.name for label in pr.labels))
+        self.parsed_data.setdefault("links", []).insert(0, pr.html_url)
+
+    def _prepare_output(self) -> Dict[str, Any]:
+        """Validate and prepare final output structure"""
+        # Validate required keys
+        for key in self.config.get("output", {}).get("required_keys", []):
+            if key not in self.parsed_data:
+                raise ValueError(f"Missing required key in output: {key}")
+
+        # Generate filename components
+        pr_number = self.repo_context["pr_number"]
+        clean_title = re.sub(r"[^\w-]", "_", self.parsed_data["title"].lower()[:50])
+        filename = (
+            self.config["output"]["filename_template"]
+            .replace("$pr_number", str(pr_number))
+            .replace("$clean_title", clean_title)
+        )
+        
+        output_dir = Path(self.config["output"]["directory"])
+        
+        # Delete existing files for this PR number
+        existing_files = output_dir.glob(f"{pr_number}_*.yaml")
+        for file in existing_files:
+            try:
+                file.unlink()
+                print(f"Removed previous changelog: {file}")
+            except Exception as e:
+                print(f"Error removing {file}: {str(e)}")
+
+        # Create ordered output structure
+        ordered_data = CommentedMap()
+        output_order = self.config["output"].get("order", [])
+
+        # Add keys in specified order
+        for key in output_order:
+            if key in self.parsed_data:
+                ordered_data[key] = self.parsed_data[key]
+
+        # Add any remaining keys not in order list
+        for key in self.parsed_data:
+            if key not in ordered_data:
+                ordered_data[key] = self.parsed_data[key]
+
+        return {
+            "data": ordered_data,
+            "filename": output_dir / filename
+        }
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate YAML changelog from merged GitHub PR."
+    )
+    parser.add_argument("--pr-number", type=int, required=True, help="Merged PR number")
+    parser.add_argument(
+        "--repo",
+        help="GitHub repository (owner/repo)",
+        default=os.getenv("GH_REPOSITORY"),
+    )
+    parser.add_argument(
+        "--token",
+        help="GitHub personal access token",
+        default=os.getenv("GH_TOKEN"),
+    )
+    parser.add_argument(
+        "--output-dir", default="changelogs", help="Output directory for YAML files"
+    )
+    parser.add_argument("--config", default="pr_changelog_config.yaml")
+    parser.add_argument(
+        "--force", action="store_true", help="Run even if PR is not merged"
+    )
+
+    args = parser.parse_args()
+
+    # Authenticate with GitHub
+    auth = Auth.Token(args.token)
+    github = Github(auth=auth)
+    repo = github.get_repo(args.repo)
+    pr = repo.get_pull(args.pr_number)
+
+    if not pr.merged and not args.force:
+        print(f"PR #{args.pr_number} is not merged. Exiting.")
+        return
+
+    # Process PR and write output
+    processor = PRProcessor(Path(__file__).parent.parent / args.config)
+    result = processor.process_pr(pr, repo)
+
+    yaml_handler = YAML(typ="rt")
+    yaml_handler.indent(mapping=2, sequence=4, offset=2)
+    result["filename"].parent.mkdir(parents=True, exist_ok=True)
+
+    with open(result["filename"], "w") as f:
+        yaml_handler.dump(result["data"], f)
+
+    print(f"Successfully generated: {result['filename']}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/workflows/scripts/changelog_file_generation/src/pr_linter.py b/.github/workflows/scripts/changelog_file_generation/src/pr_linter.py
new file mode 100644
index 00000000000..72c23862c39
--- /dev/null
+++ b/.github/workflows/scripts/changelog_file_generation/src/pr_linter.py
@@ -0,0 +1,301 @@
+"""
+PR Format Linter - Validates GitHub Pull Requests against configuration templates.
+"""
+
+import argparse
+import re
+import sys
+from pathlib import Path
+from typing import Dict, List
+import yaml
+from dotenv import load_dotenv
+import os
+load_dotenv()
+
+from github import Github, GithubException
+
+class PRLinter:
+    """Validates GitHub PR formatting against configuration templates using PR number."""
+    
+    def __init__(self, config_path: str = "pr_changelog_config.yaml") -> None:
+        """
+        Initialize linter with validation rules.
+        
+        Args:
+            config_path: Path to YAML config file
+        """
+        with open(config_path) as f:
+            self.config = yaml.safe_load(f)
+        self.errors: List[str] = []
+
+    def lint(self, pr_title: str, pr_body: str) -> bool:
+        """
+        Validate PR title and body against configured rules.
+        
+        Args:
+            pr_title: Pull request title
+            pr_body: Pull request body content
+            
+        Returns:
+            True if valid, False if errors exist
+        """
+        self._validate_title(pr_title)
+        self._validate_body(pr_body)
+        return len(self.errors) == 0
+
+    def _validate_title(self, title: str) -> None:
+        """Validate PR title structure and scopes.
+        
+        Checks:
+        - Title starts with valid scope brackets
+        - Scopes match allowed values from config
+        """
+        scope_pattern = self.config["title_processing"].get("scope_pattern", r"^\[([\w\/]+)\]")
+        allowed_scopes = self.config["title_processing"].get("allowed_scopes", [])
+
+        # Check scope prefix exists
+        if not re.search(scope_pattern, title):
+            self.errors.append("Title missing required scope prefix (e.g. [GEN])")
+            return
+
+        # Extract and validate scopes
+        scopes = []
+        remaining = title
+        while match := re.match(scope_pattern, remaining):
+            scopes.extend(match.group(1).upper().split("/"))
+            remaining = remaining[match.end():].strip()
+
+        if allowed_scopes:
+            invalid = [s for s in scopes if s not in allowed_scopes]
+            if invalid:
+                self.errors.append(
+                    f"Invalid title scopes: {', '.join(invalid)}. "
+                    f"Allowed values: {', '.join(allowed_scopes)}"
+                )
+
+    def _parse_sections(self, body: str) -> Dict[str, List[str]]:
+        """Parse PR body into sections using config header patterns"""
+        sections = {}
+        current_section = None
+        body = re.sub(r"<!--.*?-->", "", body, flags=re.DOTALL)
+        
+        # Build header patterns from config
+        header_patterns = {
+            name: re.compile(config["header"], re.IGNORECASE)
+            for name, config in self.config["sections"].items()
+        }
+
+        for line in body.split("\n"):
+            line = line.strip()
+            if line.startswith("## "):
+                header_text = line[3:].split("<!--")[0].strip()
+                current_section = None
+                
+                # Match against all configured headers
+                for section_name, pattern in header_patterns.items():
+                    if pattern.search(header_text):
+                        current_section = section_name
+                        break
+                
+                if current_section:
+                    sections.setdefault(current_section, [])
+                continue
+                
+            if current_section:
+                sections[current_section].append(line)
+
+        return sections
+
+    def _validate_body(self, body: str) -> None:
+        """Validate sections using config-defined headers"""
+        sections = self._parse_sections(body)
+        
+        # Check required sections
+        required = [
+            name for name, config in self.config["sections"].items()
+            if config.get("required")
+        ]
+        for section in required:
+            if section not in sections:
+                self.errors.append(f"Missing required section: {self.config['sections'][section]['header']}")
+
+        # Validate existing sections
+        for name, content in sections.items():
+            config = self.config["sections"][name]
+            self._validate_section_content(
+                section_name=name,
+                header_name=config["header"],  # Use display name for errors
+                lines=content,
+                pattern=config["pattern"],
+                allowed_keywords=config.get("allowed_keywords"),
+                processor=config.get("processor")
+            )
+
+
+    def _validate_section_content(
+        self,
+        section_name: str,
+        header_name: str,
+        lines: List[str],
+        pattern: str,
+        allowed_keywords: List[str],
+        processor: str
+    ) -> None:
+        """Validate section content with detailed error messages"""
+        section_errors = []
+        expected_format = self.config['sections'][section_name].get('example', '')
+
+        for line_num, raw_line in enumerate(lines, 1):
+            line = raw_line.strip()
+            if not line:
+                continue
+
+            # Validate list item formatting
+            if not line.startswith('- ') and not processor == "flat_list":
+                section_errors.append(
+                    f"Line {line_num}: Item must be a list element starting with '- '"
+                )
+                continue
+
+            clean_line = line[2:].strip()
+            
+            # Validate colon presence for key-value sections
+            if processor == "key_value" and ':' not in clean_line:
+                parts = clean_line.split(' ', 1)
+                if len(parts) > 0 and parts[0].lower() in allowed_keywords:
+                    section_errors.append(
+                        f"Line {line_num}: Missing colon after keyword. "
+                        f"Should be '{parts[0]}: {parts[1]}'"
+                    )
+                else:
+                    section_errors.append(
+                        f"Line {line_num}: Invalid format. Expected: {expected_format}"
+                    )
+                continue
+
+            # Validate pattern match
+            match = re.fullmatch(pattern, clean_line)
+            if not match:
+                section_errors.append(
+                    f"Line {line_num}: Invalid format. Expected: {expected_format}"
+                )
+                continue
+
+            # Validate keywords
+            if allowed_keywords:
+                keyword = match.group(1).lower()
+                if keyword not in allowed_keywords:
+                    section_errors.append(
+                        f"Line {line_num}: Invalid keyword '{keyword}'. "
+                        f"Allowed: {', '.join(allowed_keywords)}"
+                    )
+
+        if section_errors:
+            self.errors.append(
+                f"**{header_name} errors**:\n" + "\n".join(section_errors)
+            )
+
+    def print_errors(self) -> None:
+        """Print formatted validation errors to stderr."""
+        if self.errors:
+            print("\nPR Validation Errors Found:", file=sys.stderr)
+            for error in self.errors:
+                print(f"  • {error}", file=sys.stderr)
+            print("\nPlease refer to the PR template guidelines.", file=sys.stderr)
+        else:
+            print("PR format is valid!")
+
+def create_or_update_comment(
+        pr, 
+        message: str, 
+        bot_marker: str = "<!-- LinterBot -->"
+    ) -> None:
+        """Create or update existing linter comment on PR"""
+        existing_comment = None
+        for comment in pr.get_issue_comments():
+            if bot_marker in comment.body:
+                existing_comment = comment
+                break
+
+        full_message = f"{message}\n{bot_marker}"
+        
+        if existing_comment:
+            existing_comment.edit(full_message)
+        else:
+            pr.create_issue_comment(full_message)
+
+def format_comment(errors: List[str], pr_number: int) -> str:
+    """Format validation results as a GitHub comment"""
+    if not errors:
+        return f"## ✅ PR #{pr_number} Format Validation\nNo linting errors found!"
+
+    error_list = "\n".join(f"❌ {error}\n" for error in errors)
+    return f"## ❌ PR #{pr_number} Format Issues\nThe following formatting issues were found:\n\n{error_list}\nPlease check the PR template guidelines."
+
+def main():
+    """CLI for validating PRs using GitHub PR number."""
+    parser = argparse.ArgumentParser(
+        description="Validate PR format and report via GitHub comments",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument(
+        "--pr-number",
+        type=int,
+        required=True,
+        help="Pull request number to validate"
+    )
+    parser.add_argument(
+        "--repo",
+        default=os.getenv("GH_REPOSITORY"),
+        type=str,
+        help="Repository in owner/repo format"
+    )
+    parser.add_argument(
+        "--token",
+        default=os.getenv("GH_TOKEN"),
+        type=str,
+        help="GitHub token (default: GITHUB_TOKEN env var)"
+    )
+    parser.add_argument(
+        "--config",
+        default="pr_changelog_config.yaml",
+        help="Path to validation config YAML"
+    )
+    parser.add_argument(
+        "-q", "--quiet",
+        action="store_true",
+        help="Suppress output except exit status"
+    )
+
+    args = parser.parse_args()
+
+    try:
+        # GitHub connection setup
+        g = Github(args.token)
+        repo = g.get_repo(args.repo)
+        pr = repo.get_pull(args.pr_number)
+
+        # Run validation
+        linter = PRLinter(Path(__file__).parent.parent / args.config)
+        is_valid = linter.lint(pr.title, pr.body or "")
+        
+        # Format and post comment
+        comment_body = format_comment(linter.errors, args.pr_number)
+        create_or_update_comment(pr, comment_body)
+
+        # CLI output unless quiet
+        if not args.quiet:
+            linter.print_errors()
+            print(f"\nPosted validation results to PR #{args.pr_number}")
+
+        sys.exit(0 if is_valid else 1)
+
+    except GithubException as e:
+        print(f"GitHub API Error: {str(e)}", file=sys.stderr)
+        sys.exit(2)
+    except Exception as e:
+        print(f"Runtime Error: {str(e)}", file=sys.stderr)
+        sys.exit(3)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/Documentation/how_to_write_a_pull_request.md b/Documentation/how_to_write_a_pull_request.md
new file mode 100644
index 00000000000..b71ea51ad3b
--- /dev/null
+++ b/Documentation/how_to_write_a_pull_request.md
@@ -0,0 +1,148 @@
+# How to Write a Pull Request
+When submitting a pull request, it is required that the pull request templated is followed. To do this requires some knowledge of markdown, and the format in which the different fields should be filled out. 
+
+This document will provide a brief overview of the different fields, and what keywords should be used to fill them out.
+
+## Table of Contents
+- [How to Write a Pull Request](#how-to-write-a-pull-request)
+  - [Table of Contents](#table-of-contents)
+  - [Required Fields](#required-fields)
+    - [Title](#title)
+    - [Change list](#change-list)
+  - [Optional Fields](#optional-fields)
+    - [Author(s)](#authors)
+    - [Fixes Issue(s)](#fixes-issues)
+    - [Updates PR(s)](#updates-prs)
+    - [Additional Notes](#additional-notes)
+
+
+## Required Fields
+The following fields are required to be filled out. This is to help the maintainers and reviews understand what the pull request is about, what changes are being made and what the pull request affects.
+
+
+### Title
+The title needs to follow the folling format:
+```
+[<Type>] <Short Description>
+```
+Where `<Type>` is the area the pull request is affecting, and the `<Short Description>` is a title for the pull request. The following `<Type>`'s are available:
+- [GEN] = `Generals`
+- [ZH] = `Zero Hour`
+- [GITHUB] = `GitHub`
+- [DOCS] = `Documentation`
+- [BUILD] = `Build`
+
+Multiple types can be used if the pull request affects multiple areas. Types need to be separated by `/`.
+
+**Example Title:**
+```
+[GEN/ZH] Improving AI pathfinding
+```
+```
+[BUILD] Updated Cmake to version 3.20
+```
+```
+[GITHUB/DOCS] Updated pull request template
+```
+
+
+### Change list
+Changes made in the pull request should be in list form, and follow the following format:
+```
+- <Type>: <Description>
+```
+Where `<Type>` is the type of change being made, and `<Description>` is a short description of the change. The following `<Type>`'s are available:
+- fix = `Fixes a bug`
+- feat = `Adds a new feature`
+- breaking = `Introduces a breaking change, breaks backwards compatibility`
+- build = `Changes to the build system`
+- ci = `Changes to the CI/CD pipeline`
+- docs = `Changes to the documentation`
+- performance = `Improves performance`
+- test = `Adds or modifies tests`
+
+If there are multiple changes, they should all be listed, each in their own bullet point.
+
+**Exmaple**
+```
+Change list
+- fix: Fixed a bug where the game would crash when loading a map
+- test: Added related tests for the bug fix
+```
+```
+Change list
+- breaking: Updated mismatch CRC calculation
+- performance: Reduced GPU calls by 20%
+- test: Added tests for the new CRC calculation
+```
+
+## Optional Fields
+These next fields are optional, and can be removed if not needed. They are used to provide additional information about the pull request, and if one is applicable, it should be filled out.
+
+### Author(s)
+If there are multiple authors for the pull request, they should be listed here. The format is as follows:
+```
+- @<Author>
+```
+Where `<Author>` is the GitHub username of the author. If there are multiple authors, they should be listed in their own bullet point.
+
+**Example**
+```
+* Removed because no additional authors
+```
+```
+Author(s)
+- @<PR Author>
+```
+```
+Author(s)
+- @<PR Author>
+- @<Additional Author>
+```
+
+### Fixes Issue(s)
+If the pull request fixes an issue, it should be listed here. The format is as follows:
+```
+- <Task> #<Issue Number>
+```
+Where `<Task>` is the GitHub keyword for closing an issue. The following keywords are available:
+- `Closes` = `Closes an issue`
+- `Fixes` = `Fixes an issue`
+- `Resolves` = `Resolves an issue`
+
+And `<Issue Number>` is the number of the issue that is being fixed. If there are multiple issues, they should be listed in their own bullet point.
+
+**Example**
+```
+Fixes Issue(s)
+- Fixes #123
+```
+```
+Fixes Issue(s)
+- Closes #123
+- Closes #124
+```
+
+### Updates PR(s)
+If a pull request is updating another pull request, or is a direct continuation of another, it should be listed here. The format is as follows:
+```
+- <Task> #<PR Number>
+```
+Where `<Task>` is the GitHub keyword for updating a PR. The following keywords are available:
+- `Updates` = `Updates an issue`
+- `Continues` = `Continues an issue`
+
+And `<PR Number>` is the number of the PR that is being updated. If there are multiple PRs, they should be listed in their own bullet point.
+
+**Example**
+```
+Updates PR(s)
+- Updates #123
+```
+```
+Updates PR(s)
+- Continues #123
+```
+
+### Additional Notes
+Lastly in the additional notes section, any additional information that is not related to the changelog can be added. This can be anything from additional information about the pull request, to notes about the changes made.
\ No newline at end of file