commit f684c4b5b183c140ab2e7c27d3dde16d7b4c64dd
Author: Zhongwei Li <lizhongwei.nkcs@gmail.com>
Date:   Sat Nov 29 17:54:15 2025 +0800

    Initial commit

diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json
new file mode 100644
index 0000000..c57ee88
--- /dev/null
+++ b/.claude-plugin/plugin.json
@@ -0,0 +1,15 @@
+{
+  "name": "experienced-engineer",
+  "description": "A comprehensive plugin with specialized engineering subagents and productivity commands for software teams",
+  "version": "1.0.0",
+  "author": {
+    "name": "Anand Tyagi",
+    "url": "https://github.com/ananddtyagi"
+  },
+  "commands": [
+    "./commands/"
+  ],
+  "hooks": [
+    "./hooks/hooks.json"
+  ]
+}
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c485263
--- /dev/null
+++ b/README.md
@@ -0,0 +1,3 @@
+# experienced-engineer
+
+A comprehensive plugin with specialized engineering subagents and productivity commands for software teams
diff --git a/commands/code-explain.md b/commands/code-explain.md
new file mode 100644
index 0000000..59d0aaa
--- /dev/null
+++ b/commands/code-explain.md
@@ -0,0 +1,114 @@
+---
+description: Deep dive into codebase to answer questions and explain functionality
+---
+
+# Code Explain Command
+
+You are tasked with explaining code and answering questions about the codebase with depth and clarity.
+
+## Your Role
+
+When a user asks a question about the codebase, you should:
+
+1. **Understand the Question** - Clarify what the user is asking about
+2. **Locate Relevant Code** - Search the codebase for relevant files, functions, and modules
+3. **Analyze Thoroughly** - Read and understand the code, including dependencies and context
+4. **Explain Clearly** - Provide a comprehensive but accessible explanation
+
+## Approach
+
+### For "How does X work?" questions:
+
+1. Locate the relevant code (functions, classes, modules)
+2. Trace the execution flow
+3. Explain the logic step-by-step
+4. Highlight key concepts and patterns
+5. Show relevant code snippets with context
+6. Explain dependencies and interactions with other parts
+7. Mention any gotchas or edge cases
+
+### For "What does X do?" questions:
+
+1. Find the code element (function, class, file)
+2. Explain its purpose and responsibility
+3. Describe inputs and outputs
+4. Show how it's used in the codebase
+5. Explain its role in the larger system
+
+### For "Where is X implemented?" questions:
+
+1. Search for the functionality across the codebase
+2. Identify the main implementation location
+3. Show related files and dependencies
+4. Explain the architecture around it
+5. Mention any configuration or environment factors
+
+### For "Why is X done this way?" questions:
+
+1. Examine the implementation
+2. Consider the context and requirements
+3. Explain the design decisions
+4. Discuss alternatives and tradeoffs
+5. Look for comments or documentation that explain rationale
+
+## Explanation Style
+
+- **Be thorough but clear** - Don't oversimplify, but make it accessible
+- **Use examples** - Show concrete code snippets when relevant
+- **Provide context** - Explain how pieces fit into the larger system
+- **Visual aids** - Use diagrams or flowcharts for complex logic when helpful
+- **Cite sources** - Reference specific files and line numbers
+- **Progressive detail** - Start with high-level overview, then dive deeper
+- **Highlight key points** - Use formatting to emphasize important information
+
+## Code Snippet Format
+
+When showing code:
+```
+📁 path/to/file.js (lines 45-60)
+
+[relevant code snippet]
+```
+
+- Show enough context to understand the code
+- Highlight the most important parts
+- Explain what the code does line-by-line if complex
+
+## Example Response Structure
+
+```
+## Overview
+[High-level explanation of what's being asked]
+
+## Implementation Location
+[Where the relevant code lives]
+
+## How It Works
+[Step-by-step explanation with code snippets]
+
+## Key Components
+[Important functions, classes, or modules involved]
+
+## Integration
+[How this fits into the larger system]
+
+## Additional Notes
+[Edge cases, gotchas, or related information]
+```
+
+## Tips
+
+- Ask clarifying questions if the user's question is ambiguous
+- If code is complex, break down the explanation into logical sections
+- Point out patterns, best practices, or issues you notice
+- Suggest related code or concepts the user might want to explore
+- If you find issues or improvements, mention them constructively
+
+## Remember
+
+- Your goal is to help the user truly understand the code, not just answer superficially
+- Take time to search and read the relevant code thoroughly
+- Don't guess - search the codebase for accurate information
+- If something isn't clear from the code alone, say so
+- Encourage follow-up questions for deeper understanding
+
diff --git a/commands/update-claude.md b/commands/update-claude.md
new file mode 100644
index 0000000..e197106
--- /dev/null
+++ b/commands/update-claude.md
@@ -0,0 +1,164 @@
+---
+description: Update the CLAUDE.md file to reflect major changes in the codebase
+---
+
+# Update CLAUDE.md Command
+
+You should update the `CLAUDE.md` or `.claude/CLAUDE.md` file to reflect recent major changes in the codebase.
+
+## Purpose
+
+The CLAUDE.md file serves as a high-level guide for Claude Code (and other AI assistants) to understand:
+- Project structure and organization
+- Key architectural decisions
+- Important conventions and patterns
+- Where to find things
+- What to watch out for
+
+## When to Update
+
+Update CLAUDE.md after:
+- Major refactoring or restructuring
+- New features or modules added
+- Changes to architecture or patterns
+- Updates to dependencies or tooling
+- Changes to conventions or standards
+- New directories or significant file moves
+
+## What to Include
+
+### 1. Project Overview
+- Brief description of what the project does
+- Tech stack and key dependencies
+- Development setup instructions
+
+### 2. Architecture & Structure
+```markdown
+## Project Structure
+
+- `/src` - Main application code
+  - `/components` - React components
+  - `/services` - Business logic and API calls
+  - `/utils` - Helper functions
+  - `/types` - TypeScript type definitions
+- `/tests` - Test files
+- `/docs` - Documentation
+- `/scripts` - Build and utility scripts
+```
+
+### 3. Key Patterns & Conventions
+- Code organization patterns
+- Naming conventions
+- State management approach
+- Error handling patterns
+- Testing strategies
+
+### 4. Important Notes
+- Gotchas or common pitfalls
+- Performance considerations
+- Security requirements
+- Browser/platform support
+- Third-party integrations
+
+### 5. Development Workflow
+- How to run locally
+- How to run tests
+- How to build
+- How to deploy
+- Branch strategy
+
+## Format Example
+
+```markdown
+# Project Name
+
+## Overview
+Brief description of the project and its purpose.
+
+## Tech Stack
+- Framework/Language
+- Key libraries and tools
+- Database
+- Infrastructure
+
+## Project Structure
+[Detailed structure as shown above]
+
+## Architecture
+Describe the high-level architecture:
+- Frontend architecture (React, state management)
+- Backend architecture (API structure, services)
+- Database design
+- External integrations
+
+## Key Conventions
+- File naming: kebab-case for components, camelCase for utilities
+- Component structure: Functional components with hooks
+- State management: Redux Toolkit for global state
+- Styling: CSS Modules with BEM naming
+- Testing: Jest + React Testing Library
+
+## Important Notes
+- Authentication uses JWT tokens stored in httpOnly cookies
+- API rate limiting is 100 requests per minute
+- Image uploads are handled by AWS S3
+- Background jobs use Bull queue with Redis
+
+## Development
+```bash
+# Install dependencies
+npm install
+
+# Run locally
+npm run dev
+
+# Run tests
+npm test
+
+# Build for production
+npm run build
+```
+
+## Where to Find Things
+- API endpoints: `/src/routes`
+- Database models: `/src/models`
+- Authentication logic: `/src/middleware/auth.js`
+- Email templates: `/src/templates/email`
+
+## Common Tasks
+- Adding a new API endpoint: Create route in `/src/routes`, add controller in `/src/controllers`
+- Adding a new database table: Create migration in `/migrations`, add model in `/src/models`
+- Adding a new React page: Create component in `/src/pages`, add route in `/src/App.js`
+```
+
+## Your Task
+
+1. **Locate the CLAUDE.md file** (or create it if it doesn't exist)
+   - Check for `CLAUDE.md` or `.claude/CLAUDE.md`
+   - If neither exists, create `.claude/CLAUDE.md`
+
+2. **Review recent changes**
+   - Look at git history for major changes
+   - Review current project structure
+   - Note any new patterns or conventions
+
+3. **Update the file**
+   - Add new sections for new features/modules
+   - Update structure diagrams
+   - Document new conventions or patterns
+   - Update any outdated information
+   - Add notes about recent major changes
+
+4. **Keep it concise but comprehensive**
+   - Focus on what's important for understanding the codebase
+   - Don't duplicate documentation that exists elsewhere (link to it)
+   - Highlight things that aren't obvious from the code alone
+
+## Remember
+
+- CLAUDE.md is a living document - it should evolve with the codebase
+- Focus on information that helps understand the big picture
+- Be specific enough to be useful, but high-level enough to stay relevant
+- Update it proactively, not just when asked
+- Think about what would help someone (or AI) new to the codebase get oriented quickly
+
diff --git a/hooks/hooks.json b/hooks/hooks.json
new file mode 100644
index 0000000..0ff64a2
--- /dev/null
+++ b/hooks/hooks.json
@@ -0,0 +1,16 @@
+{
+  "PostToolUse": [
+    {
+      "name": "Update CLAUDE.md after major changes",
+      "matcher": "(Write|Edit|Delete|Refactor).*[5-9]\\d+|[1-9]\\d{2,}",
+      "description": "Automatically prompts to update CLAUDE.md when significant code changes are detected",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "/update-claude"
+        }
+      ]
+    }
+  ]
+}
+
diff --git a/plugin.lock.json b/plugin.lock.json
new file mode 100644
index 0000000..5690c5d
--- /dev/null
+++ b/plugin.lock.json
@@ -0,0 +1,53 @@
+{
+  "$schema": "internal://schemas/plugin.lock.v1.json",
+  "pluginId": "gh:ananddtyagi/claude-code-marketplace:plugins/experienced-engineer",
+  "normalized": {
+    "repo": null,
+    "ref": "refs/tags/v20251128.0",
+    "commit": "5794ba9dfac9691998be98ef22b641223f4f1cd3",
+    "treeHash": "ca5ce1d85d16f4110b9c72c46584f751f1d293d30a19ff541dc5383957434477",
+    "generatedAt": "2025-11-28T10:13:40.332326Z",
+    "toolVersion": "publish_plugins.py@0.2.0"
+  },
+  "origin": {
+    "remote": "git@github.com:zhongweili/42plugin-data.git",
+    "branch": "master",
+    "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
+    "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
+  },
+  "manifest": {
+    "name": "experienced-engineer",
+    "description": "A comprehensive plugin with specialized engineering subagents and productivity commands for software teams",
+    "version": "1.0.0"
+  },
+  "content": {
+    "files": [
+      {
+        "path": "README.md",
+        "sha256": "374639a6dccf904502ab9deefcb114b8df9907fbc47cdc299d6abd8fd952fdaf"
+      },
+      {
+        "path": "hooks/hooks.json",
+        "sha256": "a326153f93e6f5df96c4dd1ad293570a7ff277bd6fd1d34054d55eac51678c01"
+      },
+      {
+        "path": ".claude-plugin/plugin.json",
+        "sha256": "a7efceacf5a9e1e9ba49cda87e4ae4677231e9f5a9711545e25e31b8ef4fa2a6"
+      },
+      {
+        "path": "commands/code-explain.md",
+        "sha256": "ee1ae1bab2d61e0f2c42de04a80339ce8e081d4de683642818d1fcb99315ccd5"
+      },
+      {
+        "path": "commands/update-claude.md",
+        "sha256": "2228b7828f160637de7b865598938fecc9a9feffa769199e70a1115645faf71c"
+      }
+    ],
+    "dirSha256": "ca5ce1d85d16f4110b9c72c46584f751f1d293d30a19ff541dc5383957434477"
+  },
+  "security": {
+    "scannedAt": null,
+    "scannerVersion": null,
+    "flags": []
+  }
+}
\ No newline at end of file