@zeyue0329/xiaoma-cli 1.0.49 → 6.0.0-alpha.13

package/src/modules/xmc/docs/enterprise-agentic-development.md

@@ -0,0 +1,686 @@
+# Enterprise Agentic Development with XiaoMa Method
+
+**The paradigm shift: From team-based story parallelism to individual epic ownership**
+
+**Reading Time:** ~18 minutes
+
+---
+
+## Table of Contents
+
+- [The Paradigm Shift](#the-paradigm-shift)
+- [The Evolving Role of Product Managers and UX Designers](#the-evolving-role-of-product-managers-and-ux-designers)
+- [How XiaoMa Method Enables PM/UX Technical Evolution](#how-xiaoma-cli-enables-pmux-technical-evolution)
+- [Team Collaboration Patterns](#team-collaboration-patterns)
+- [Work Distribution Strategies](#work-distribution-strategies)
+- [Enterprise Configuration with Git Submodules](#enterprise-configuration-with-git-submodules)
+- [Best Practices](#best-practices)
+- [Common Scenarios](#common-scenarios)
+
+---
+
+## The Paradigm Shift
+
+### Traditional Agile: Team-Based Story Parallelism
+
+- **Epic duration:** 4-12 weeks across multiple sprints
+- **Story duration:** 2-5 days per developer
+- **Team size:** 5-9 developers working on same epic
+- **Parallelization:** Multiple devs on stories within single epic
+- **Coordination:** Constant - daily standups, merge conflicts, integration overhead
+
+**Example:** Payment Processing Epic
+
+- Sprint 1-2: Backend API (Dev A)
+- Sprint 1-2: Frontend UI (Dev B)
+- Sprint 2-3: Testing (Dev C)
+- **Result:** 6-8 weeks, 3 developers, high coordination
+
+### Agentic Development: Individual Epic Ownership
+
+- **Epic duration:** Hours to days (not weeks)
+- **Story duration:** 30 min to 4 hours with AI agent
+- **Team size:** 1 developer + AI agents completes full epics
+- **Parallelization:** Developers work on separate epics
+- **Coordination:** Minimal - epic boundaries, async updates
+
+**Same Example:** Payment Processing Epic
+
+- Day 1 AM: Backend API stories (1 dev + agent, 3-4 stories)
+- Day 1 PM: Frontend UI stories (same dev + agent, 2-3 stories)
+- Day 2: Testing & deployment (same dev + agent, 2 stories)
+- **Result:** 1-2 days, 1 developer, minimal coordination
+
+### The Core Difference
+
+**What changed:** AI agents collapse story duration from days to hours, making **epic-level ownership** practical.
+
+**Impact:** Single developer with XiaoMa Method can deliver in 1 day what previously required full team and multiple sprints.
+
+---
+
+## The Evolving Role of Product Managers and UX Designers
+
+### The Future is Now
+
+Product Managers and UX Designers are undergoing **the most significant transformation since the creation of these disciplines**. The emergence of AI agents is creating a new breed of technical product leaders who translate vision directly into working code.
+
+### From Spec Writers to Code Orchestrators
+
+**Traditional PM/UX (Pre-2025):**
+
+- Write PRDs, hand off to engineering
+- Wait weeks/months for implementation
+- Limited validation capabilities
+- Non-technical role, heavy on process
+
+**Emerging PM/UX (2025+):**
+
+- Write AI-optimized PRDs that **feed agentic pipelines directly**
+- Generate working prototypes in 10-15 minutes
+- Review pull requests from AI agents
+- Technical fluency is **table stakes**, not optional
+- Orchestrate cloud-based AI agent teams
+
+### Industry Research (November 2025)
+
+- **56% of product professionals** cite AI/ML as top focus
+- **AI agents automating** customer discovery, PRD creation, status reporting
+- **PRD-to-Code automation** enables PMs to build and deploy apps in 10-15 minutes
+- **By 2026**: Roles converging into "Full-Stack Product Lead" (PM + Design + Engineering)
+- **Very high salaries** for AI agent PMs who orchestrate autonomous dev systems
+
+### Required Skills for Modern PMs/UX
+
+1. **AI Prompt Engineering** - Writing PRDs AI agents can execute autonomously
+2. **Coding Literacy** - Understanding code structure, APIs, data flows (not production coding)
+3. **Agentic Workflow Design** - Orchestrating multi-agent systems (planning → design → dev)
+4. **Technical Architecture** - Reasoning frameworks, memory systems, tool integration
+5. **Data Literacy** - Interpreting model outputs, spotting trends, identifying gaps
+6. **Code Review** - Evaluating AI-generated PRs for correctness and vision alignment
+
+### What Remains Human
+
+**AI Can't Replace:**
+
+- Product vision (market dynamics, customer pain, strategic positioning)
+- Empathy (deep user research, emotional intelligence, stakeholder management)
+- Creativity (novel problem-solving, disruptive thinking)
+- Judgment (prioritization decisions, trade-off analysis)
+- Ethics (responsible AI use, privacy, accessibility)
+
+**What Changes:**
+
+- PMs/UX spend **more time on human elements** (AI handles routine execution)
+- Barrier between "thinking" and "building" collapses
+- Product leaders become **builder-thinkers**, not just spec writers
+
+### The Convergence
+
+- **PMs learning to code** with GitHub Copilot, Cursor, v0
+- **UX designers generating code** with UXPin Merge, Figma-to-code tools
+- **Developers becoming orchestrators** reviewing AI output vs writing from scratch
+
+**The Bottom Line:** By 2026, successful PMs/UX will fluently operate in both vision and execution. **XiaoMa Method provides the structured framework to make this transition.**
+
+---
+
+## How XiaoMa Method Enables PM/UX Technical Evolution
+
+XiaoMa Method is specifically designed to position PMs and UX designers for this future.
+
+### 1. AI-Executable PRD Generation
+
+**PM Workflow:**
+
+```bash
+xiaoma pm *create-prd
+```
+
+**XiaoMa produces:**
+
+- Structured, machine-readable requirements
+- Functional Requirements (FRs) with testable acceptance criteria
+- Non-Functional Requirements (NFRs) with measurable targets
+- Technical context for AI agents
+
+**Why it matters:** Traditional PRDs are human-readable prose. XiaoMa PRDs are **AI-executable requirement specifications**.
+
+**PM Value:** Clear requirements that feed into architecture decisions, then into story breakdown. No ambiguity.
+
+### 2. Human-in-the-Loop Architecture
+
+**Architect/PM Workflow:**
+
+```bash
+xiaoma architect *create-architecture
+```
+
+**XiaoMa produces:**
+
+- System architecture aligned with PRD's FRs/NFRs
+- Architecture Decision Records (ADRs)
+- FR/NFR-specific technical guidance
+- Integration patterns and standards
+
+**Why it matters:** PMs can **understand and validate** technical decisions. Architecture is conversational, not template-driven.
+
+**PM Value:** Technical fluency built through guided architecture process. PMs learn while creating.
+
+### 3. Automated Epic/Story Breakdown (AFTER Architecture)
+
+**PM Workflow:**
+
+```bash
+xiaoma pm *create-epics-and-stories
+```
+
+**V6 Improvement:** Epics and stories are now created AFTER architecture for better quality. The workflow uses both PRD (FRs/NFRs) and Architecture to create technically-informed stories.
+
+**XiaoMa produces:**
+
+- Epic files with clear objectives
+- Story files with acceptance criteria, context, technical guidance
+- Priority assignments (P0-P3)
+- Dependency mapping informed by architectural decisions
+
+**Why it matters:** Stories become **work packages for cloud AI agents**. Each story is self-contained with full context AND aligned with architecture.
+
+**PM Value:** No more "story refinement sessions" with engineering. Stories are technically grounded from the start.
+
+### 4. Cloud Agentic Pipeline (Emerging Pattern)
+
+**Current State (2025):**
+
+```
+PM writes XiaoMa PRD (FRs/NFRs)
+   ↓
+Architect creates architecture (technical decisions)
+   ↓
+create-epics-and-stories generates story queue (informed by architecture)
+   ↓
+Stories loaded by human developers + XiaoMa agents
+   ↓
+Developers create PRs
+   ↓
+PM/Team reviews PRs
+   ↓
+Merge and deploy
+```
+
+**Near Future (2026):**
+
+```
+PM writes XiaoMa PRD (FRs/NFRs)
+   ↓
+Architecture auto-generated with PM approval
+   ↓
+create-epics-and-stories generates story queue (informed by architecture)
+   ↓
+Stories automatically fed to cloud AI agent pool
+   ↓
+AI agents implement stories in parallel
+   ↓
+AI agents create pull requests
+   ↓
+PM/UX/Senior Devs review PRs
+   ↓
+Approved PRs auto-merge
+   ↓
+Continuous deployment to production
+```
+
+**Time Savings:**
+
+- **Traditional:** PM writes spec → 2-4 weeks engineering → review → deploy (6-8 weeks)
+- **XiaoMa Agentic:** PM writes PRD → AI agents implement → review PRs → deploy (2-5 days)
+
+### 5. UX Design Integration
+
+**UX Designer Workflow:**
+
+```bash
+xiaoma ux *create-ux-design
+```
+
+**XiaoMa produces:**
+
+- Component-based design system
+- Interaction patterns aligned with tech stack
+- Accessibility guidelines
+- Responsive design specifications
+
+**Why it matters:** Design specs become **implementation-ready** for AI agents. No "lost in translation" between design and dev.
+
+**UX Value:** Designs validated through working prototypes, not static mocks. Technical understanding built through XiaoMa workflows.
+
+### 6. PM Technical Skills Development
+
+**XiaoMa teaches PMs technical skills through:**
+
+- **Conversational workflows** - No pre-requisite knowledge, learn by doing
+- **Architecture facilitation** - Understand system design through guided questions
+- **Story context assembly** - See how code patterns inform implementation
+- **Code review workflows** - Learn to evaluate code quality, patterns, standards
+
+**Example:** PM runs `create-architecture` workflow:
+
+- XiaoMa asks about scale, performance, integrations
+- PM answers business questions
+- XiaoMa explains technical implications
+- PM learns architecture concepts while making decisions
+
+**Result:** PMs gain **working technical knowledge** without formal CS education.
+
+### 7. Organizational Leverage
+
+**Traditional Model:**
+
+- 1 PM → supports 5-9 developers → delivers 1-2 features/quarter
+
+**XiaoMa Agentic Model:**
+
+- 1 PM → writes XiaoMa PRD → 20-50 AI agents execute stories in parallel → delivers 5-10 features/quarter
+
+**Leverage multiplier:** 5-10× with same PM headcount.
+
+### 8. Quality Consistency
+
+**XiaoMa ensures:**
+
+- AI agents follow architectural patterns consistently
+- Code standards applied uniformly
+- PRD traceability throughout implementation (via acceptance criteria)
+- No "telephone game" between PM, design, and dev
+
+**PM Value:** What gets built **matches what was specified**, drastically reducing rework.
+
+### 9. Rapid Prototyping for Validation
+
+**PM Workflow (with XiaoMa + Cursor/v0):**
+
+1. Use XiaoMa to generate PRD structure and requirements
+2. Extract key user flow from PRD
+3. Feed to Cursor/v0 with XiaoMa context
+4. Working prototype in 10-15 minutes
+5. Validate with users **before** committing to full development
+
+**Traditional:** Months of development to validate idea
+**XiaoMa Agentic:** Hours of development to validate idea
+
+### 10. Career Path Evolution
+
+**XiaoMa positions PMs for emerging roles:**
+
+- **AI Agent Product Manager** - Orchestrate autonomous development systems
+- **Full-Stack Product Lead** - Oversee product, design, engineering with AI leverage
+- **Technical Product Strategist** - Bridge business vision and technical execution
+
+**Hiring advantage:** PMs using XiaoMa demonstrate:
+
+- Technical fluency (can read architecture, validate tech decisions)
+- AI-native workflows (structured requirements, agentic orchestration)
+- Results (ship 5-10× faster than peers)
+
+---
+
+## Team Collaboration Patterns
+
+### Old Pattern: Story Parallelism
+
+**Traditional Agile:**
+
+```
+Epic: User Dashboard (8 weeks)
+├─ Story 1: Backend API (Dev A, Sprint 1-2)
+├─ Story 2: Frontend Layout (Dev B, Sprint 1-2)
+├─ Story 3: Data Viz (Dev C, Sprint 2-3)
+└─ Story 4: Integration Testing (Team, Sprint 3-4)
+
+Challenge: Coordination overhead, merge conflicts, integration issues
+```
+
+### New Pattern: Epic Ownership
+
+**Agentic Development:**
+
+```
+Project: Analytics Platform (2-3 weeks)
+
+Developer A:
+└─ Epic 1: User Dashboard (3 days, 12 stories sequentially with AI)
+
+Developer B:
+└─ Epic 2: Admin Panel (4 days, 15 stories sequentially with AI)
+
+Developer C:
+└─ Epic 3: Reporting Engine (5 days, 18 stories sequentially with AI)
+
+Benefit: Minimal coordination, epic-level ownership, clear boundaries
+```
+
+---
+
+## Work Distribution Strategies
+
+### Strategy 1: Epic-Based (Recommended)
+
+**Best for:** 2-10 developers
+
+**Approach:** Each developer owns complete epics, works sequentially through stories
+
+**Example:**
+
+```yaml
+epics:
+  - id: epic-1
+    title: Payment Processing
+    owner: alice
+    stories: 8
+    estimate: 2 days
+
+  - id: epic-2
+    title: User Dashboard
+    owner: bob
+    stories: 12
+    estimate: 3 days
+```
+
+**Benefits:** Clear ownership, minimal conflicts, epic cohesion, reduced coordination
+
+### Strategy 2: Layer-Based
+
+**Best for:** Full-stack apps, specialized teams
+
+**Example:**
+
+```
+Frontend Dev: Epic 1 (Product Catalog UI), Epic 3 (Cart UI)
+Backend Dev: Epic 2 (Product API), Epic 4 (Cart Service)
+```
+
+**Benefits:** Developers in expertise area, true parallel work, clear API contracts
+
+**Requirements:** Strong architecture phase, clear API contracts upfront
+
+### Strategy 3: Feature-Based
+
+**Best for:** Large teams (10+ developers)
+
+**Example:**
+
+```
+Team A (2 devs): Payments feature (4 epics)
+Team B (2 devs): User Management feature (3 epics)
+Team C (2 devs): Analytics feature (3 epics)
+```
+
+**Benefits:** Feature team autonomy, domain expertise, scalable to large orgs
+
+---
+
+## Enterprise Configuration with Git Submodules
+
+### The Challenge
+
+**Problem:** Teams customize XiaoMa (agents, workflows, configs) but don't want personal tooling in main repo.
+
+**Anti-pattern:** Adding `{xiaoma_folder}/` to `.gitignore` breaks IDE tools, submodule management.
+
+### The Solution: Git Submodules
+
+**Benefits:**
+
+- XiaoMa exists in project but tracked separately
+- Each developer controls their own XiaoMa version/config
+- Optional team config sharing via submodule repo
+- IDE tools maintain proper context
+
+### Setup (New Projects)
+
+**1. Create optional team config repo:**
+
+```bash
+git init xmc-config
+cd xmc-config
+npx xiaoma-cli install
+# Customize for team standards
+git commit -m "Team XMC config"
+git push origin main
+```
+
+**2. Add submodule to project:**
+
+```bash
+cd /path/to/your-project
+git submodule add https://github.com/your-org/xmc-config.git xiaoma
+git commit -m "Add XMC as submodule"
+```
+
+**3. Team members initialize:**
+
+```bash
+git clone https://github.com/your-org/your-project.git
+cd your-project
+git submodule update --init --recursive
+# Make personal customizations in {xiaoma_folder}/
+```
+
+### Daily Workflow
+
+**Work in main project:**
+
+```bash
+cd /path/to/your-project
+# XiaoMa available at ./{xiaoma_folder}/, load agents normally
+```
+
+**Update personal config:**
+
+```bash
+cd xiaoma
+# Make changes, commit locally, don't push unless sharing
+```
+
+**Update to latest team config:**
+
+```bash
+cd xiaoma
+git pull origin main
+```
+
+### Configuration Strategies
+
+**Option 1: Fully Personal** - No submodule, each dev installs independently, use `.gitignore`
+
+**Option 2: Team Baseline + Personal** - Submodule has team standards, devs add personal customizations locally
+
+**Option 3: Full Team Sharing** - All configs in submodule, team collaborates on improvements
+
+---
+
+## Best Practices
+
+### 1. Epic Ownership
+
+- **Do:** Assign entire epic to one developer (context → implementation → retro)
+- **Don't:** Split epics across multiple developers (coordination overhead, context loss)
+
+### 2. Dependency Management
+
+- **Do:** Identify epic dependencies in planning, document API contracts, complete prerequisites first
+- **Don't:** Start dependent epic before prerequisite ready, change API contracts without coordination
+
+### 3. Communication Cadence
+
+**Traditional:** Daily standups essential
+**Agentic:** Lighter coordination
+
+**Recommended:**
+
+- Daily async updates ("Epic 1, 60% complete, no blockers")
+- Twice-weekly 15min sync
+- Epic completion demos
+- Sprint retro after all epics complete
+
+### 4. Branch Strategy
+
+```bash
+feature/epic-1-payment-processing    (Alice)
+feature/epic-2-user-dashboard        (Bob)
+feature/epic-3-admin-panel           (Carol)
+
+# PR and merge when epic complete
+```
+
+### 5. Testing Strategy
+
+- **Story-level:** Unit tests (DoD requirement, written by agent during dev-story)
+- **Epic-level:** Integration tests across stories
+- **Project-level:** E2E tests after multiple epics complete
+
+### 6. Documentation Updates
+
+- **Real-time:** `sprint-status.yaml` updated by workflows
+- **Epic completion:** Update architecture docs, API docs, README if changed
+- **Sprint completion:** Incorporate retrospective insights
+
+### 7. Metrics (Different from Traditional)
+
+**Traditional:** Story points per sprint, burndown charts
+**Agentic:** Epics per week, stories per day, time to epic completion
+
+**Example velocity:**
+
+- Junior dev + AI: 1-2 epics/week (8-15 stories)
+- Mid-level dev + AI: 2-3 epics/week (15-25 stories)
+- Senior dev + AI: 3-5 epics/week (25-40 stories)
+
+---
+
+## Common Scenarios
+
+### Scenario 1: Startup (2 Developers)
+
+**Project:** SaaS MVP (Level 3)
+
+**Distribution:**
+
+```
+Developer A:
+├─ Epic 1: Authentication (3 days)
+├─ Epic 3: Payment Integration (2 days)
+└─ Epic 5: Admin Dashboard (3 days)
+
+Developer B:
+├─ Epic 2: Core Product Features (4 days)
+├─ Epic 4: Analytics (3 days)
+└─ Epic 6: Notifications (2 days)
+
+Total: ~2 weeks
+Traditional estimate: 3-4 months
+```
+
+**XMC Setup:** Direct installation, both use Claude Code, minimal customization
+
+### Scenario 2: Mid-Size Team (8 Developers)
+
+**Project:** Enterprise Platform (Level 4)
+
+**Distribution (Layer-Based):**
+
+```
+Backend (2 devs): 6 API epics
+Frontend (2 devs): 6 UI epics
+Full-stack (2 devs): 4 integration epics
+DevOps (1 dev): 3 infrastructure epics
+QA (1 dev): 1 E2E testing epic
+
+Total: ~3 weeks
+Traditional estimate: 9-12 months
+```
+
+**XMC Setup:** Git submodule, team config repo, mix of Claude Code/Cursor users
+
+### Scenario 3: Large Enterprise (50+ Developers)
+
+**Project:** Multi-Product Platform
+
+**Organization:**
+
+- 5 product teams (8-10 devs each)
+- 1 platform team (10 devs - shared services)
+- 1 infrastructure team (5 devs)
+
+**Distribution (Feature-Based):**
+
+```
+Product Team A: Payments (10 epics, 2 weeks)
+Product Team B: User Mgmt (12 epics, 2 weeks)
+Product Team C: Analytics (8 epics, 1.5 weeks)
+Product Team D: Admin Tools (10 epics, 2 weeks)
+Product Team E: Mobile (15 epics, 3 weeks)
+
+Platform Team: Shared Services (continuous)
+Infrastructure Team: DevOps (continuous)
+
+Total: 3-4 months
+Traditional estimate: 2-3 years
+```
+
+**XMC Setup:** Each team has own submodule config, org-wide base config, variety of IDE tools
+
+---
+
+## Summary
+
+### Key Transformation
+
+**Work Unit Changed:**
+
+- **Old:** Story = unit of work assignment
+- **New:** Epic = unit of work assignment
+
+**Why:** AI agents collapse story duration (days → hours), making epic ownership practical.
+
+### Velocity Impact
+
+- **Traditional:** Months for epic delivery, heavy coordination
+- **Agentic:** Days for epic delivery, minimal coordination
+- **Result:** 10-50× productivity gains
+
+### PM/UX Evolution
+
+**XiaoMa Method enables:**
+
+- PMs to write AI-executable PRDs
+- UX designers to validate through working prototypes
+- Technical fluency without CS degrees
+- Orchestration of cloud AI agent teams
+- Career evolution to Full-Stack Product Lead
+
+### Enterprise Adoption
+
+**Git submodules:** Best practice for XMC management across teams
+**Team flexibility:** Mix of tools (Claude Code, Cursor, Windsurf) with shared XMC foundation
+**Scalable patterns:** Epic-based, layer-based, feature-based distribution strategies
+
+### The Future (2026)
+
+PMs write XiaoMa PRDs → Stories auto-fed to cloud AI agents → Parallel implementation → Human review of PRs → Continuous deployment
+
+**The future isn't AI replacing PMs—it's AI-augmented PMs becoming 10× more powerful.**
+
+---
+
+## Related Documentation
+
+- [FAQ](faq.md) - Common questions
+- [Scale Adaptive System](scale-adaptive-system.md) - Project levels explained
+- [Quick Start Guide](quick-start.md) - Getting started
+- [Workflow Documentation](README.md#-workflow-guides) - Complete workflow reference
+- [Agents Guide](agents-guide.md) - Understanding XiaoMa agents
+
+---
+
+_XiaoMa Method fundamentally changes how PMs work, how teams structure work, and how products get built. Understanding these patterns is essential for enterprise success in the age of AI agents._