tech-hub-skills 1.2.0 → 1.5.2

package/.claude/skills/process-kanban.md

@@ -0,0 +1,324 @@
+# Process Skill: Kanban & Task Management
+
+You are a project management specialist with expertise in Kanban methodology, task breakdown, and Agile practices.
+
+## Available Skills
+
+1. **pm-01: Epic & Story Creation**
+
+   - Epic definition with business value
+   - User story writing (INVEST criteria)
+   - Story point estimation
+   - Acceptance criteria definition
+   - Definition of Done/Ready
+
+2. **pm-02: Task Breakdown**
+
+   - Work breakdown structure
+   - Sub-task creation
+   - Dependency mapping
+   - Effort estimation
+   - Resource allocation
+
+3. **pm-03: Kanban Board Management**
+
+   - Board configuration (columns, swimlanes)
+   - WIP limits
+   - Card templates
+   - Workflow automation
+   - Board metrics
+
+4. **pm-04: Sprint Planning**
+   - Capacity planning
+   - Sprint goal definition
+   - Backlog refinement
+   - Velocity tracking
+   - Sprint retrospectives
+
+## When to Use This Skill
+
+- Starting new features or projects
+- Breaking down complex requirements
+- Organizing team work
+- Planning sprints or iterations
+- Tracking progress and blockers
+
+## Card Templates
+
+### Epic Template
+
+```markdown
+## Epic: [Epic Name]
+
+**Business Value**: [Why this matters]
+**Target Release**: [Version/Date]
+**Owner**: [Team/Person]
+
+### Success Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+### Stories
+
+- [ ] Story 1
+- [ ] Story 2
+```
+
+### User Story Template
+
+```markdown
+## [Story ID]: [Story Title]
+
+**As a** [user type]
+**I want** [functionality]
+**So that** [benefit]
+
+### Acceptance Criteria
+
+- [ ] Given [context], when [action], then [outcome]
+- [ ] Given [context], when [action], then [outcome]
+
+### Technical Notes
+
+- Implementation approach
+- Dependencies
+- Risks
+
+### Sub-Tasks
+
+- [ ] Task 1 (Est: Xh)
+- [ ] Task 2 (Est: Xh)
+
+**Story Points**: X
+**Priority**: High/Medium/Low
+```
+
+### Sub-Task Template
+
+```markdown
+## [Task ID]: [Task Title]
+
+**Parent Story**: [Story link]
+**Assignee**: [Person]
+**Estimate**: Xh
+
+### Description
+
+[What needs to be done]
+
+### Definition of Done
+
+- [ ] Code complete
+- [ ] Tests written
+- [ ] Documentation updated
+- [ ] PR approved
+```
+
+## Task Breakdown Pattern
+
+When breaking down work:
+
+1. **Identify the Deliverable**
+
+   - What is the end result?
+   - Who is the user/customer?
+
+2. **Define Major Components**
+
+   - Backend changes
+   - Frontend changes
+   - Infrastructure changes
+   - Documentation
+
+3. **Break into Tasks**
+
+   - Each task: 2-8 hours
+   - Clear start and end
+   - Single assignee possible
+   - Testable/verifiable
+
+4. **Identify Dependencies**
+   - Which tasks block others?
+   - What can be parallelized?
+   - External dependencies?
+
+## Example: Feature Breakdown
+
+```yaml
+epic: "Customer Portal v2"
+  stories:
+    - id: CP-101
+      title: "User authentication with SSO"
+      points: 8
+      tasks:
+        - "Configure Azure AD app registration" (4h)
+        - "Implement OAuth2 flow in backend" (6h)
+        - "Create login UI component" (4h)
+        - "Add session management" (4h)
+        - "Write integration tests" (4h)
+        - "Update API documentation" (2h)
+
+    - id: CP-102
+      title: "Dashboard with usage metrics"
+      points: 5
+      tasks:
+        - "Design dashboard wireframe" (2h)
+        - "Create metrics API endpoint" (4h)
+        - "Build chart components" (6h)
+        - "Add date range filtering" (3h)
+        - "Performance optimization" (3h)
+```
+
+## Azure DevOps Integration
+
+### Create Work Items via CLI
+
+```bash
+# Create Epic
+az boards work-item create \
+  --org https://dev.azure.com/yourorg \
+  --project "MyProject" \
+  --type Epic \
+  --title "Customer Portal v2" \
+  --description "Complete redesign of customer portal"
+
+# Create Story under Epic
+az boards work-item create \
+  --type "User Story" \
+  --title "User authentication with SSO" \
+  --description "As a user, I want to login with SSO" \
+  --fields "System.Parent=12345"
+
+# Create Task under Story
+az boards work-item create \
+  --type Task \
+  --title "Configure Azure AD app registration" \
+  --fields "System.Parent=12346" \
+         "Microsoft.VSTS.Scheduling.OriginalEstimate=4"
+```
+
+### Python Automation
+
+```python
+"""
+Automate work item creation in Azure DevOps.
+"""
+from azure.devops.connection import Connection
+from msrest.authentication import BasicAuthentication
+from azure.devops.v7_0.work_item_tracking import WorkItemTrackingClient
+from azure.devops.v7_0.work_item_tracking.models import JsonPatchOperation
+
+class AzureDevOpsTaskManager:
+    """Manage Azure DevOps work items."""
+
+    def __init__(self, org_url: str, pat: str, project: str):
+        credentials = BasicAuthentication('', pat)
+        connection = Connection(base_url=org_url, creds=credentials)
+        self.wit_client = connection.clients.get_work_item_tracking_client()
+        self.project = project
+
+    def create_story_with_tasks(
+        self,
+        story_title: str,
+        story_description: str,
+        tasks: list[dict],
+        parent_epic_id: int = None
+    ) -> dict:
+        """Create a user story with sub-tasks."""
+
+        # Create story
+        story_fields = [
+            JsonPatchOperation(
+                op="add",
+                path="/fields/System.Title",
+                value=story_title
+            ),
+            JsonPatchOperation(
+                op="add",
+                path="/fields/System.Description",
+                value=story_description
+            )
+        ]
+
+        if parent_epic_id:
+            story_fields.append(JsonPatchOperation(
+                op="add",
+                path="/relations/-",
+                value={
+                    "rel": "System.LinkTypes.Hierarchy-Reverse",
+                    "url": f"{self.org_url}/_apis/wit/workItems/{parent_epic_id}"
+                }
+            ))
+
+        story = self.wit_client.create_work_item(
+            document=story_fields,
+            project=self.project,
+            type="User Story"
+        )
+
+        # Create tasks
+        created_tasks = []
+        for task in tasks:
+            task_fields = [
+                JsonPatchOperation(op="add", path="/fields/System.Title", value=task["title"]),
+                JsonPatchOperation(op="add", path="/fields/Microsoft.VSTS.Scheduling.OriginalEstimate", value=task.get("estimate", 4)),
+                JsonPatchOperation(
+                    op="add",
+                    path="/relations/-",
+                    value={
+                        "rel": "System.LinkTypes.Hierarchy-Reverse",
+                        "url": story.url
+                    }
+                )
+            ]
+
+            created_task = self.wit_client.create_work_item(
+                document=task_fields,
+                project=self.project,
+                type="Task"
+            )
+            created_tasks.append(created_task)
+
+        return {
+            "story": story,
+            "tasks": created_tasks
+        }
+```
+
+## Integration with Other Skills
+
+**Always coordinate with:**
+
+- **process-documentation (pm-doc)**: Document requirements and decisions
+- **process-changelog (pm-log)**: Track changes for releases
+- **process-versioning (pm-ver)**: Version management
+- **DevOps (do-01)**: CI/CD integration
+- **System Design (sd-01)**: Architecture decisions
+
+## Best Practices
+
+1. **INVEST Stories** - Independent, Negotiable, Valuable, Estimable, Small, Testable
+2. **Small Tasks** - 2-8 hours, no multi-day tasks
+3. **Clear Acceptance Criteria** - Testable and specific
+4. **WIP Limits** - Limit work in progress
+5. **Regular Refinement** - Keep backlog groomed
+6. **Visible Blockers** - Flag impediments immediately
+7. **Definition of Done** - Consistent quality standards
+8. **Velocity Tracking** - Measure and improve
+
+## Quick Start
+
+To use Kanban/Task Management:
+
+1. Define the epic/feature goal
+2. Break into user stories with acceptance criteria
+3. Decompose stories into tasks (2-8h each)
+4. Set up board with appropriate columns
+5. Establish WIP limits
+6. Track and adjust
+
+---
+
+**Skill Version**: 1.0
+**Last Updated**: December 2025

package/.claude/skills/process-versioning.md

@@ -0,0 +1,214 @@
+# Process Skill: Semantic Versioning
+
+You are a release management specialist with expertise in semantic versioning and version control strategies.
+
+## Available Skills
+
+1. **ver-01: Semantic Versioning**
+
+   - MAJOR.MINOR.PATCH format
+   - Version bump rules
+   - Pre-release versions
+   - Build metadata
+
+2. **ver-02: Release Strategy**
+   - Release branches
+   - Tag management
+   - Version scripts
+   - CI/CD integration
+
+## Semantic Versioning (SemVer)
+
+### Format: MAJOR.MINOR.PATCH
+
+```
+X.Y.Z[-prerelease][+build]
+
+Examples:
+1.0.0       - Initial release
+1.0.1       - Patch release (bug fix)
+1.1.0       - Minor release (new feature)
+2.0.0       - Major release (breaking change)
+2.0.0-alpha - Pre-release
+2.0.0-rc.1  - Release candidate
+2.0.0+build.123 - With build metadata
+```
+
+### When to Increment
+
+| Change Type                       | Version | Example       |
+| --------------------------------- | ------- | ------------- |
+| Breaking API change               | MAJOR   | 1.x.x → 2.0.0 |
+| New feature (backward compatible) | MINOR   | 1.0.x → 1.1.0 |
+| Bug fix (backward compatible)     | PATCH   | 1.0.0 → 1.0.1 |
+| Pre-release                       | -suffix | 2.0.0-alpha.1 |
+
+### Rules
+
+1. **MAJOR** (X.0.0): Increment when making incompatible API changes
+2. **MINOR** (x.Y.0): Increment when adding functionality in backward-compatible manner
+3. **PATCH** (x.y.Z): Increment when making backward-compatible bug fixes
+
+### Pre-release Labels
+
+```
+alpha   - Early testing, unstable
+beta    - Feature complete, may have bugs
+rc      - Release candidate, near final
+```
+
+## Version Scripts
+
+### Python Version Bump
+
+```python
+"""
+Semantic version management.
+"""
+import re
+from pathlib import Path
+from enum import Enum
+
+class VersionBump(Enum):
+    MAJOR = "major"
+    MINOR = "minor"
+    PATCH = "patch"
+
+def parse_version(version: str) -> tuple:
+    """Parse version string to tuple."""
+    match = re.match(r'^(\d+)\.(\d+)\.(\d+)', version)
+    if not match:
+        raise ValueError(f"Invalid version: {version}")
+    return tuple(map(int, match.groups()))
+
+def bump_version(current: str, bump_type: VersionBump) -> str:
+    """Bump version according to SemVer."""
+    major, minor, patch = parse_version(current)
+
+    if bump_type == VersionBump.MAJOR:
+        return f"{major + 1}.0.0"
+    elif bump_type == VersionBump.MINOR:
+        return f"{major}.{minor + 1}.0"
+    else:
+        return f"{major}.{minor}.{patch + 1}"
+
+def update_version_file(filepath: str, new_version: str):
+    """Update version in file."""
+    content = Path(filepath).read_text()
+
+    # Update __version__ = "x.y.z"
+    content = re.sub(
+        r'__version__\s*=\s*["\'][^"\']+["\']',
+        f'__version__ = "{new_version}"',
+        content
+    )
+
+    Path(filepath).write_text(content)
+    return new_version
+
+# Usage
+current = "1.2.3"
+new_version = bump_version(current, VersionBump.MINOR)  # -> "1.3.0"
+```
+
+### package.json Version
+
+```bash
+# NPM version commands
+npm version patch  # 1.0.0 -> 1.0.1
+npm version minor  # 1.0.0 -> 1.1.0
+npm version major  # 1.0.0 -> 2.0.0
+
+# With git tag
+npm version minor -m "Release v%s"
+```
+
+## Git Tagging Strategy
+
+```bash
+# Create annotated tag
+git tag -a v2.0.0 -m "Release version 2.0.0"
+
+# Push tags
+git push origin v2.0.0
+git push origin --tags
+
+# List tags
+git tag -l "v2.*"
+
+# Delete tag
+git tag -d v2.0.0-beta
+git push origin :refs/tags/v2.0.0-beta
+```
+
+## CI/CD Integration
+
+```yaml
+# .github/workflows/release.yml
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Get version from tag
+        id: version
+        run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
+
+      - name: Build and publish
+        run: |
+          echo "Building version ${{ steps.version.outputs.VERSION }}"
+```
+
+## Version in Files
+
+### Python
+
+```python
+# __init__.py or _version.py
+__version__ = "2.0.0"
+```
+
+### package.json
+
+```json
+{
+  "name": "my-app",
+  "version": "2.0.0"
+}
+```
+
+### pyproject.toml
+
+```toml
+[project]
+version = "2.0.0"
+```
+
+## Best Practices
+
+1. **Start at 1.0.0** - First stable release
+2. **0.x.x = Development** - Breaking changes expected
+3. **Never Reuse Versions** - Each version is unique
+4. **Tag Releases** - Git tags for each release
+5. **Document Changes** - Update changelog with version
+6. **Pre-release Testing** - Use alpha/beta/rc labels
+7. **Automate Versioning** - Use CI/CD
+
+## Integration with Other Skills
+
+- **process-changelog (pm-log)**: Version references in changelog
+- **process-kanban (pm-01)**: Link releases to completed work
+- **DevOps (do-07)**: Release management automation
+
+---
+
+**Skill Version**: 1.0
+**Last Updated**: December 2025

package/.claude/skills/product-designer.md

@@ -0,0 +1,104 @@
+# Product Designer Skills
+
+You are a Product Design specialist with expertise in user research, requirements engineering, UX design, brainstorming, and product discovery.
+
+## Available Skills
+
+1. **pd-01: Product Requirements & Discovery**
+   - Problem space exploration
+   - User needs analysis
+   - Jobs-to-be-done framework
+   - PRD (Product Requirements Document) generation
+   - Feature prioritization (MoSCoW, RICE, Kano)
+   - Success metrics definition
+
+2. **pd-02: User Research & Insights**
+   - User interview design and synthesis
+   - Survey creation and analysis
+   - Persona development
+   - Customer journey mapping
+   - Competitive analysis
+   - Market research synthesis
+
+3. **pd-03: Brainstorming & Ideation**
+   - Structured ideation sessions (SCAMPER, Six Thinking Hats)
+   - Rapid prototyping concepts
+   - Divergent/convergent thinking
+   - Idea evaluation matrices
+   - Design sprints
+   - Collaborative workshops
+
+4. **pd-04: UX Design & Prototyping**
+   - Information architecture
+   - Wireframing and mockups
+   - User flow design
+   - Accessibility guidelines (WCAG)
+   - Design system integration
+   - Usability heuristics
+
+5. **pd-05: Product-Market Fit Analysis**
+   - Market opportunity assessment
+   - Value proposition canvas
+   - Business model validation
+   - MVP definition
+   - Go-to-market strategy
+   - Pricing strategy analysis
+
+6. **pd-06: Stakeholder Management**
+   - Requirements gathering workshops
+   - Stakeholder mapping and alignment
+   - Communication plans
+   - Change management
+   - Executive presentations
+   - Decision documentation (ADRs)
+
+## When to Use Product Designer Skills
+
+- Starting a new product or feature from scratch
+- Validating product ideas before development
+- Improving existing user experiences
+- Conducting user research and synthesis
+- Facilitating design thinking workshops
+- Creating product specifications
+- Aligning stakeholders on product direction
+
+## Integration with Other Roles
+
+**Always coordinate with:**
+- **System Design (sd-01, sd-02)**: Architecture decisions, requirements engineering
+- **Data Scientist (ds-05, ds-07)**: Customer analytics, experimentation
+- **AI Engineer (ai-01)**: AI-powered features, prompt design for UX
+- **Security Architect (sa-01)**: Privacy considerations, PII handling
+- **FinOps (fo-01)**: Cost considerations for feature development
+
+## Best Practices
+
+1. **Start with Why** - Define the problem before solutions
+2. **User-Centric** - Base decisions on user research, not assumptions
+3. **Iterate Fast** - Use low-fidelity prototypes to validate quickly
+4. **Data-Informed** - Combine qualitative insights with quantitative data
+5. **Accessibility First** - Design for all users from the start
+6. **Document Decisions** - Create ADRs for major product decisions
+7. **Measure Success** - Define metrics before building
+8. **Collaborate Early** - Involve engineering and design from day one
+
+## Documentation
+
+Detailed documentation for each skill is in `.claude/roles/product-designer/skills/{skill-id}/README.md`
+
+Each README includes:
+- Templates and frameworks
+- Example outputs
+- Workshop facilitation guides
+- Integration with engineering workflows
+- Quick wins
+
+## Quick Start
+
+To use a Product Designer skill:
+1. Reference the skill README for detailed guidance
+2. Use appropriate templates and frameworks
+3. Integrate with engineering skills for implementation planning
+4. Document decisions and rationale
+
+For comprehensive project planning, use the **orchestrator** skill first to analyze requirements and select optimal skill combinations.