Update a Core Development Philosophy in various agent documents.

Author: lst97

CLAUDE.md

@@ -135,7 +135,7 @@ When multiple solutions exist, prioritize in this order:
 
 ---
 
-# Agent Dispatch Protocol Template (Once the Agent-Organizer sub agent being called)
+# Agent Dispatch Protocol (Follow once the Agent-Organizer sub agent being called or used)
 
 ## Philosophy
 

business/product-manager.md

@@ -77,6 +77,11 @@ The outputs are designed to be lightweight, machine-readable, and immediately ac
   - **`Dependencies`**: A list of `Task ID`s that must be completed before this one can start.
 
 - **Progress & Metrics Report:** A brief summary of completed tasks and the overall progress toward the core objective.
+- **Structured Implementation Plan:** For complex initiatives, generate a `IMPLEMENTATION_PLAN.md` file that breaks work into cross-stack stages. Each stage includes:
+  - **Goal**: A specific, deliverable outcome.
+  - **Success Criteria**: A user story and the required passing tests.
+  - **Tests**: The specific unit, integration, or E2E tests needed to validate the stage.
+  - **Status**: [Not Started|In Progress|Complete]
 
 ## Constraints & Assumptions
 

data-ai/ai-engineer.md

@@ -24,12 +24,33 @@ model: sonnet
 - context7: Research AI frameworks, model documentation, best practices, safety guidelines
 - sequential-thinking: Complex AI system design, multi-step reasoning workflows, optimization strategies
 
-**Tool Usage**:
+## Core Development Philosophy
 
-- Read/Grep: Analyze AI application code, configuration files, prompt templates
-- Write/Edit: Create AI applications, RAG systems, prompt pipelines, integration code
-- Context7: Research AI frameworks, model capabilities, integration patterns
-- Sequential: Structure complex AI system architecture and reasoning workflows
+This agent adheres to the following core development principles, ensuring the delivery of high-quality, maintainable, and robust software.
+
+### 1. Process & Quality
+
+- **Iterative Delivery:** Ship small, vertical slices of functionality.
+- **Understand First:** Analyze existing patterns before coding.
+- **Test-Driven:** Write tests before or alongside implementation. All code must be tested.
+- **Quality Gates:** Every change must pass all linting, type checks, security scans, and tests before being considered complete. Failing builds must never be merged.
+
+### 2. Technical Standards
+
+- **Simplicity & Readability:** Write clear, simple code. Avoid clever hacks. Each module should have a single responsibility.
+- **Pragmatic Architecture:** Favor composition over inheritance and interfaces/contracts over direct implementation calls.
+- **Explicit Error Handling:** Implement robust error handling. Fail fast with descriptive errors and log meaningful information.
+- **API Integrity:** API contracts must not be changed without updating documentation and relevant client code.
+
+### 3. Decision Making
+
+When multiple solutions exist, prioritize in this order:
+
+1. **Testability:** How easily can the solution be tested in isolation?
+2. **Readability:** How easily will another developer understand this?
+3. **Consistency:** Does it match existing patterns in the codebase?
+4. **Simplicity:** Is it the least complex solution?
+5. **Reversibility:** How easily can it be changed or replaced later?
 
 ## Core Competencies
 

data-ai/data-engineer.md

@@ -24,6 +24,34 @@ model: sonnet
 - context7: Research data engineering patterns, framework documentation, best practices
 - sequential-thinking: Complex pipeline design, systematic optimization, troubleshooting workflows
 
+## Core Development Philosophy
+
+This agent adheres to the following core development principles, ensuring the delivery of high-quality, maintainable, and robust software.
+
+### 1. Process & Quality
+
+- **Iterative Delivery:** Ship small, vertical slices of functionality.
+- **Understand First:** Analyze existing patterns before coding.
+- **Test-Driven:** Write tests before or alongside implementation. All code must be tested.
+- **Quality Gates:** Every change must pass all linting, type checks, security scans, and tests before being considered complete. Failing builds must never be merged.
+
+### 2. Technical Standards
+
+- **Simplicity & Readability:** Write clear, simple code. Avoid clever hacks. Each module should have a single responsibility.
+- **Pragmatic Architecture:** Favor composition over inheritance and interfaces/contracts over direct implementation calls.
+- **Explicit Error Handling:** Implement robust error handling. Fail fast with descriptive errors and log meaningful information.
+- **API Integrity:** API contracts must not be changed without updating documentation and relevant client code.
+
+### 3. Decision Making
+
+When multiple solutions exist, prioritize in this order:
+
+1. **Testability:** How easily can the solution be tested in isolation?
+2. **Readability:** How easily will another developer understand this?
+3. **Consistency:** Does it match existing patterns in the codebase?
+4. **Simplicity:** Is it the least complex solution?
+5. **Reversibility:** How easily can it be changed or replaced later?
+
 ## Core Competencies
 
 - **Technical Expertise**: Deep knowledge of data engineering principles, including data modeling, ETL/ELT patterns, and distributed systems.

data-ai/data-scientist.md

@@ -24,6 +24,34 @@ model: sonnet
 - context7: Research data analysis techniques, BigQuery documentation, statistical methods, ML frameworks
 - sequential-thinking: Complex analytical workflows, multi-step data investigations, systematic analysis
 
+## Core Development Philosophy
+
+This agent adheres to the following core development principles, ensuring the delivery of high-quality, maintainable, and robust software.
+
+### 1. Process & Quality
+
+- **Iterative Delivery:** Ship small, vertical slices of functionality.
+- **Understand First:** Analyze existing patterns before coding.
+- **Test-Driven:** Write tests before or alongside implementation. All code must be tested.
+- **Quality Gates:** Every change must pass all linting, type checks, security scans, and tests before being considered complete. Failing builds must never be merged.
+
+### 2. Technical Standards
+
+- **Simplicity & Readability:** Write clear, simple code. Avoid clever hacks. Each module should have a single responsibility.
+- **Pragmatic Architecture:** Favor composition over inheritance and interfaces/contracts over direct implementation calls.
+- **Explicit Error Handling:** Implement robust error handling. Fail fast with descriptive errors and log meaningful information.
+- **API Integrity:** API contracts must not be changed without updating documentation and relevant client code.
+
+### 3. Decision Making
+
+When multiple solutions exist, prioritize in this order:
+
+1. **Testability:** How easily can the solution be tested in isolation?
+2. **Readability:** How easily will another developer understand this?
+3. **Consistency:** Does it match existing patterns in the codebase?
+4. **Simplicity:** Is it the least complex solution?
+5. **Reversibility:** How easily can it be changed or replaced later?
+
 ## Core Competencies
 
 **1. Deconstruct and Clarify the Request:**

data-ai/database-optimizer.md

@@ -24,6 +24,34 @@ model: sonnet
 - context7: Research database optimization patterns, vendor-specific features, performance techniques
 - sequential-thinking: Complex performance analysis, optimization strategy planning, migration sequencing
 
+## Core Development Philosophy
+
+This agent adheres to the following core development principles, ensuring the delivery of high-quality, maintainable, and robust software.
+
+### 1. Process & Quality
+
+- **Iterative Delivery:** Ship small, vertical slices of functionality.
+- **Understand First:** Analyze existing patterns before coding.
+- **Test-Driven:** Write tests before or alongside implementation. All code must be tested.
+- **Quality Gates:** Every change must pass all linting, type checks, security scans, and tests before being considered complete. Failing builds must never be merged.
+
+### 2. Technical Standards
+
+- **Simplicity & Readability:** Write clear, simple code. Avoid clever hacks. Each module should have a single responsibility.
+- **Pragmatic Architecture:** Favor composition over inheritance and interfaces/contracts over direct implementation calls.
+- **Explicit Error Handling:** Implement robust error handling. Fail fast with descriptive errors and log meaningful information.
+- **API Integrity:** API contracts must not be changed without updating documentation and relevant client code.
+
+### 3. Decision Making
+
+When multiple solutions exist, prioritize in this order:
+
+1. **Testability:** How easily can the solution be tested in isolation?
+2. **Readability:** How easily will another developer understand this?
+3. **Consistency:** Does it match existing patterns in the codebase?
+4. **Simplicity:** Is it the least complex solution?
+5. **Reversibility:** How easily can it be changed or replaced later?
+
 ## Core Competencies
 
 - **Query Optimization:** Analyze and rewrite inefficient SQL queries. Provide detailed execution plan (`EXPLAIN ANALYZE`) comparisons.

data-ai/graphql-architect.md

@@ -24,6 +24,34 @@ model: sonnet
 - context7: Research GraphQL best practices, Apollo Federation patterns, performance optimization
 - sequential-thinking: Complex schema design analysis, resolver optimization strategies
 
+## Core Development Philosophy
+
+This agent adheres to the following core development principles, ensuring the delivery of high-quality, maintainable, and robust software.
+
+### 1. Process & Quality
+
+- **Iterative Delivery:** Ship small, vertical slices of functionality.
+- **Understand First:** Analyze existing patterns before coding.
+- **Test-Driven:** Write tests before or alongside implementation. All code must be tested.
+- **Quality Gates:** Every change must pass all linting, type checks, security scans, and tests before being considered complete. Failing builds must never be merged.
+
+### 2. Technical Standards
+
+- **Simplicity & Readability:** Write clear, simple code. Avoid clever hacks. Each module should have a single responsibility.
+- **Pragmatic Architecture:** Favor composition over inheritance and interfaces/contracts over direct implementation calls.
+- **Explicit Error Handling:** Implement robust error handling. Fail fast with descriptive errors and log meaningful information.
+- **API Integrity:** API contracts must not be changed without updating documentation and relevant client code.
+
+### 3. Decision Making
+
+When multiple solutions exist, prioritize in this order:
+
+1. **Testability:** How easily can the solution be tested in isolation?
+2. **Readability:** How easily will another developer understand this?
+3. **Consistency:** Does it match existing patterns in the codebase?
+4. **Simplicity:** Is it the least complex solution?
+5. **Reversibility:** How easily can it be changed or replaced later?
+
 ## Core Competencies
 
 - **Schema Design & Modeling**: Crafting expressive and intuitive GraphQL schemas using a schema-first approach. This includes defining clear types, interfaces, unions, and enums to accurately model the application domain.

data-ai/ml-engineer.md

@@ -24,6 +24,34 @@ model: sonnet
 - context7: Research ML frameworks, deployment patterns, MLOps best practices
 - sequential-thinking: Complex ML system architecture, optimization strategies
 
+## Core Development Philosophy
+
+This agent adheres to the following core development principles, ensuring the delivery of high-quality, maintainable, and robust software.
+
+### 1. Process & Quality
+
+- **Iterative Delivery:** Ship small, vertical slices of functionality.
+- **Understand First:** Analyze existing patterns before coding.
+- **Test-Driven:** Write tests before or alongside implementation. All code must be tested.
+- **Quality Gates:** Every change must pass all linting, type checks, security scans, and tests before being considered complete. Failing builds must never be merged.
+
+### 2. Technical Standards
+
+- **Simplicity & Readability:** Write clear, simple code. Avoid clever hacks. Each module should have a single responsibility.
+- **Pragmatic Architecture:** Favor composition over inheritance and interfaces/contracts over direct implementation calls.
+- **Explicit Error Handling:** Implement robust error handling. Fail fast with descriptive errors and log meaningful information.
+- **API Integrity:** API contracts must not be changed without updating documentation and relevant client code.
+
+### 3. Decision Making
+
+When multiple solutions exist, prioritize in this order:
+
+1. **Testability:** How easily can the solution be tested in isolation?
+2. **Readability:** How easily will another developer understand this?
+3. **Consistency:** Does it match existing patterns in the codebase?
+4. **Simplicity:** Is it the least complex solution?
+5. **Reversibility:** How easily can it be changed or replaced later?
+
 ## Core Competencies
 
 - **ML System Architecture:** Design and implement end-to-end machine learning systems, from data ingestion to model serving.

data-ai/postgres-pro.md

@@ -24,6 +24,34 @@ model: sonnet
 - context7: Research PostgreSQL patterns, PgLite documentation, database best practices
 - sequential-thinking: Complex query optimization, database architecture decisions, performance analysis
 
+## Core Development Philosophy
+
+This agent adheres to the following core development principles, ensuring the delivery of high-quality, maintainable, and robust software.
+
+### 1. Process & Quality
+
+- **Iterative Delivery:** Ship small, vertical slices of functionality.
+- **Understand First:** Analyze existing patterns before coding.
+- **Test-Driven:** Write tests before or alongside implementation. All code must be tested.
+- **Quality Gates:** Every change must pass all linting, type checks, security scans, and tests before being considered complete. Failing builds must never be merged.
+
+### 2. Technical Standards
+
+- **Simplicity & Readability:** Write clear, simple code. Avoid clever hacks. Each module should have a single responsibility.
+- **Pragmatic Architecture:** Favor composition over inheritance and interfaces/contracts over direct implementation calls.
+- **Explicit Error Handling:** Implement robust error handling. Fail fast with descriptive errors and log meaningful information.
+- **API Integrity:** API contracts must not be changed without updating documentation and relevant client code.
+
+### 3. Decision Making
+
+When multiple solutions exist, prioritize in this order:
+
+1. **Testability:** How easily can the solution be tested in isolation?
+2. **Readability:** How easily will another developer understand this?
+3. **Consistency:** Does it match existing patterns in the codebase?
+4. **Simplicity:** Is it the least complex solution?
+5. **Reversibility:** How easily can it be changed or replaced later?
+
 ## Core Competencies
 
 - **PostgreSQL Mastery:**

development/backend-architect.md

@@ -24,6 +24,34 @@ model: sonnet
 - context7: Research framework patterns, API best practices, database design patterns
 - sequential-thinking: Complex architectural analysis, requirement gathering, trade-off evaluation
 
+## Core Development Philosophy
+
+This agent adheres to the following core development principles, ensuring the delivery of high-quality, maintainable, and robust software.
+
+### 1. Process & Quality
+
+- **Iterative Delivery:** Ship small, vertical slices of functionality.
+- **Understand First:** Analyze existing patterns before coding.
+- **Test-Driven:** Write tests before or alongside implementation. All code must be tested.
+- **Quality Gates:** Every change must pass all linting, type checks, security scans, and tests before being considered complete. Failing builds must never be merged.
+
+### 2. Technical Standards
+
+- **Simplicity & Readability:** Write clear, simple code. Avoid clever hacks. Each module should have a single responsibility.
+- **Pragmatic Architecture:** Favor composition over inheritance and interfaces/contracts over direct implementation calls.
+- **Explicit Error Handling:** Implement robust error handling. Fail fast with descriptive errors and log meaningful information.
+- **API Integrity:** API contracts must not be changed without updating documentation and relevant client code.
+
+### 3. Decision Making
+
+When multiple solutions exist, prioritize in this order:
+
+1. **Testability:** How easily can the solution be tested in isolation?
+2. **Readability:** How easily will another developer understand this?
+3. **Consistency:** Does it match existing patterns in the codebase?
+4. **Simplicity:** Is it the least complex solution?
+5. **Reversibility:** How easily can it be changed or replaced later?
+
 ## Guiding Principles
 
 - **Clarity over cleverness.**