[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M72XVT00A7BSXT918ZTT9X2Z":3,"skill-same:01M72XVT00A7BSXT918ZTT9X2Z":45},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":18,"linkOnly":19,"markdownContent":20,"markdownBody":21,"frontMatter":22,"refName":23,"commitSha":24,"skillDirectory":25,"forksCount":26,"repositoryHtmlUrl":27,"repositoryHomepageUrl":28,"ownerHtmlUrl":29,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":30,"install":31,"resources":44},"01M72XVT00A7BSXT918ZTT9X2Z","python-error-handling",null,"Python error handling patterns including input validation, exception hierarchies, and partial failure handling. Use when implementing validation logic, designing exception strategies, handling batch processing failures, or building robust APIs.","steph-frtech\u002Fclaude-code-up","steph-frtech","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F198466323?v=4","01M72XD213FVQA2QXRGTJFKHE1","01M72XD227AANJ993SQTNZB1CK",1,"MIT","https:\u002F\u002Fgithub.com\u002Fsteph-frtech\u002Fclaude-code-up\u002Fblob\u002Fmain\u002F.claude\u002Fmarketplaces\u002Fwshobson\u002Fplugins\u002Fpython-development\u002Fskills\u002Fpython-error-handling\u002FSKILL.md",[],[],"2026-11-10 22:39:42",false,"---\nname: python-error-handling\ndescription: Python error handling patterns including input validation, exception hierarchies, and partial failure handling. Use when implementing validation logic, designing exception strategies, handling batch processing failures, or building robust APIs.\n---\n\n# Python Error Handling\n\nBuild robust Python applications with proper input validation, meaningful exceptions, and graceful failure handling. Good error handling makes debugging easier and systems more reliable.\n\n## When to Use This Skill\n\n- Validating user input and API parameters\n- Designing exception hierarchies for applications\n- Handling partial failures in batch operations\n- Converting external data to domain types\n- Building user-friendly error messages\n- Implementing fail-fast validation patterns\n\n## Core Concepts\n\n### 1. Fail Fast\n\nValidate inputs early, before expensive operations. Report all validation errors at once when possible.\n\n### 2. Meaningful Exceptions\n\nUse appropriate exception types with context. Messages should explain what failed, why, and how to fix it.\n\n### 3. Partial Failures\n\nIn batch operations, don't let one failure abort everything. Track successes and failures separately.\n\n### 4. Preserve Context\n\nChain exceptions to maintain the full error trail for debugging.\n\n## Quick Start\n\n```python\ndef fetch_page(url: str, page_size: int) -> Page:\n    if not url:\n        raise ValueError(\"'url' is required\")\n    if not 1 \u003C= page_size \u003C= 100:\n        raise ValueError(f\"'page_size' must be 1-100, got {page_size}\")\n    # Now safe to proceed...\n```\n\n## Fundamental Patterns\n\n### Pattern 1: Early Input Validation\n\nValidate all inputs at API boundaries before any processing begins.\n\n```python\ndef process_order(\n    order_id: str,\n    quantity: int,\n    discount_percent: float,\n) -> OrderResult:\n    \"\"\"Process an order with validation.\"\"\"\n    # Validate required fields\n    if not order_id:\n        raise ValueError(\"'order_id' is required\")\n\n    # Validate ranges\n    if quantity \u003C= 0:\n        raise ValueError(f\"'quantity' must be positive, got {quantity}\")\n\n    if not 0 \u003C= discount_percent \u003C= 100:\n        raise ValueError(\n            f\"'discount_percent' must be 0-100, got {discount_percent}\"\n        )\n\n    # Validation passed, proceed with processing\n    return _process_validated_order(order_id, quantity, discount_percent)\n```\n\n### Pattern 2: Convert to Domain Types Early\n\nParse strings and external data into typed domain objects at system boundaries.\n\n```python\nfrom enum import Enum\n\nclass OutputFormat(Enum):\n    JSON = \"json\"\n    CSV = \"csv\"\n    PARQUET = \"parquet\"\n\ndef parse_output_format(value: str) -> OutputFormat:\n    \"\"\"Parse string to OutputFormat enum.\n\n    Args:\n        value: Format string from user input.\n\n    Returns:\n        Validated OutputFormat enum member.\n\n    Raises:\n        ValueError: If format is not recognized.\n    \"\"\"\n    try:\n        return OutputFormat(value.lower())\n    except ValueError:\n        valid_formats = [f.value for f in OutputFormat]\n        raise ValueError(\n            f\"Invalid format '{value}'. \"\n            f\"Valid options: {', '.join(valid_formats)}\"\n        )\n\n# Usage at API boundary\ndef export_data(data: list[dict], format_str: str) -> bytes:\n    output_format = parse_output_format(format_str)  # Fail fast\n    # Rest of function uses typed OutputFormat\n    ...\n```\n\n### Pattern 3: Pydantic for Complex Validation\n\nUse Pydantic models for structured input validation with automatic error messages.\n\n```python\nfrom pydantic import BaseModel, Field, field_validator\n\nclass CreateUserInput(BaseModel):\n    \"\"\"Input model for user creation.\"\"\"\n\n    email: str = Field(..., min_length=5, max_length=255)\n    name: str = Field(..., min_length=1, max_length=100)\n    age: int = Field(ge=0, le=150)\n\n    @field_validator(\"email\")\n    @classmethod\n    def validate_email_format(cls, v: str) -> str:\n        if \"@\" not in v or \".\" not in v.split(\"@\")[-1]:\n            raise ValueError(\"Invalid email format\")\n        return v.lower()\n\n    @field_validator(\"name\")\n    @classmethod\n    def normalize_name(cls, v: str) -> str:\n        return v.strip().title()\n\n# Usage\ntry:\n    user_input = CreateUserInput(\n        email=\"user@example.com\",\n        name=\"john doe\",\n        age=25,\n    )\nexcept ValidationError as e:\n    # Pydantic provides detailed error information\n    print(e.errors())\n```\n\n### Pattern 4: Map Errors to Standard Exceptions\n\nUse Python's built-in exception types appropriately, adding context as needed.\n\n| Failure Type | Exception | Example |\n|--------------|-----------|---------|\n| Invalid input | `ValueError` | Bad parameter values |\n| Wrong type | `TypeError` | Expected string, got int |\n| Missing item | `KeyError` | Dict key not found |\n| Operational failure | `RuntimeError` | Service unavailable |\n| Timeout | `TimeoutError` | Operation took too long |\n| File not found | `FileNotFoundError` | Path doesn't exist |\n| Permission denied | `PermissionError` | Access forbidden |\n\n```python\n# Good: Specific exception with context\nraise ValueError(f\"'page_size' must be 1-100, got {page_size}\")\n\n# Avoid: Generic exception, no context\nraise Exception(\"Invalid parameter\")\n```\n\n## Advanced Patterns\n\n### Pattern 5: Custom Exceptions with Context\n\nCreate domain-specific exceptions that carry structured information.\n\n```python\nclass ApiError(Exception):\n    \"\"\"Base exception for API errors.\"\"\"\n\n    def __init__(\n        self,\n        message: str,\n        status_code: int,\n        response_body: str | None = None,\n    ) -> None:\n        self.status_code = status_code\n        self.response_body = response_body\n        super().__init__(message)\n\nclass RateLimitError(ApiError):\n    \"\"\"Raised when rate limit is exceeded.\"\"\"\n\n    def __init__(self, retry_after: int) -> None:\n        self.retry_after = retry_after\n        super().__init__(\n            f\"Rate limit exceeded. Retry after {retry_after}s\",\n            status_code=429,\n        )\n\n# Usage\ndef handle_response(response: Response) -> dict:\n    match response.status_code:\n        case 200:\n            return response.json()\n        case 401:\n            raise ApiError(\"Invalid credentials\", 401)\n        case 404:\n            raise ApiError(f\"Resource not found: {response.url}\", 404)\n        case 429:\n            retry_after = int(response.headers.get(\"Retry-After\", 60))\n            raise RateLimitError(retry_after)\n        case code if 400 \u003C= code \u003C 500:\n            raise ApiError(f\"Client error: {response.text}\", code)\n        case code if code >= 500:\n            raise ApiError(f\"Server error: {response.text}\", code)\n```\n\n### Pattern 6: Exception Chaining\n\nPreserve the original exception when re-raising to maintain the debug trail.\n\n```python\nimport httpx\n\nclass ServiceError(Exception):\n    \"\"\"High-level service operation failed.\"\"\"\n    pass\n\ndef upload_file(path: str) -> str:\n    \"\"\"Upload file and return URL.\"\"\"\n    try:\n        with open(path, \"rb\") as f:\n            response = httpx.post(\"https:\u002F\u002Fupload.example.com\", files={\"file\": f})\n            response.raise_for_status()\n            return response.json()[\"url\"]\n    except FileNotFoundError as e:\n        raise ServiceError(f\"Upload failed: file not found at '{path}'\") from e\n    except httpx.HTTPStatusError as e:\n        raise ServiceError(\n            f\"Upload failed: server returned {e.response.status_code}\"\n        ) from e\n    except httpx.RequestError as e:\n        raise ServiceError(f\"Upload failed: network error\") from e\n```\n\n### Pattern 7: Batch Processing with Partial Failures\n\nNever let one bad item abort an entire batch. Track results per item.\n\n```python\nfrom dataclasses import dataclass\n\n@dataclass\nclass BatchResult[T]:\n    \"\"\"Results from batch processing.\"\"\"\n\n    succeeded: dict[int, T]  # index -> result\n    failed: dict[int, Exception]  # index -> error\n\n    @property\n    def success_count(self) -> int:\n        return len(self.succeeded)\n\n    @property\n    def failure_count(self) -> int:\n        return len(self.failed)\n\n    @property\n    def all_succeeded(self) -> bool:\n        return len(self.failed) == 0\n\ndef process_batch(items: list[Item]) -> BatchResult[ProcessedItem]:\n    \"\"\"Process items, capturing individual failures.\n\n    Args:\n        items: Items to process.\n\n    Returns:\n        BatchResult with succeeded and failed items by index.\n    \"\"\"\n    succeeded: dict[int, ProcessedItem] = {}\n    failed: dict[int, Exception] = {}\n\n    for idx, item in enumerate(items):\n        try:\n            result = process_single_item(item)\n            succeeded[idx] = result\n        except Exception as e:\n            failed[idx] = e\n\n    return BatchResult(succeeded=succeeded, failed=failed)\n\n# Caller handles partial results\nresult = process_batch(items)\nif not result.all_succeeded:\n    logger.warning(\n        f\"Batch completed with {result.failure_count} failures\",\n        failed_indices=list(result.failed.keys()),\n    )\n```\n\n### Pattern 8: Progress Reporting for Long Operations\n\nProvide visibility into batch progress without coupling business logic to UI.\n\n```python\nfrom collections.abc import Callable\n\nProgressCallback = Callable[[int, int, str], None]  # current, total, status\n\ndef process_large_batch(\n    items: list[Item],\n    on_progress: ProgressCallback | None = None,\n) -> BatchResult:\n    \"\"\"Process batch with optional progress reporting.\n\n    Args:\n        items: Items to process.\n        on_progress: Optional callback receiving (current, total, status).\n    \"\"\"\n    total = len(items)\n    succeeded = {}\n    failed = {}\n\n    for idx, item in enumerate(items):\n        if on_progress:\n            on_progress(idx, total, f\"Processing {item.id}\")\n\n        try:\n            succeeded[idx] = process_single_item(item)\n        except Exception as e:\n            failed[idx] = e\n\n    if on_progress:\n        on_progress(total, total, \"Complete\")\n\n    return BatchResult(succeeded=succeeded, failed=failed)\n```\n\n## Best Practices Summary\n\n1. **Validate early** - Check inputs before expensive operations\n2. **Use specific exceptions** - `ValueError`, `TypeError`, not generic `Exception`\n3. **Include context** - Messages should explain what, why, and how to fix\n4. **Convert types at boundaries** - Parse strings to enums\u002Fdomain types early\n5. **Chain exceptions** - Use `raise ... from e` to preserve debug info\n6. **Handle partial failures** - Don't abort batches on single item errors\n7. **Use Pydantic** - For complex input validation with structured errors\n8. **Document failure modes** - Docstrings should list possible exceptions\n9. **Log with context** - Include IDs, counts, and other debugging info\n10. **Test error paths** - Verify exceptions are raised correctly\n","# Python Error Handling\n\nBuild robust Python applications with proper input validation, meaningful exceptions, and graceful failure handling. Good error handling makes debugging easier and systems more reliable.\n\n## When to Use This Skill\n\n- Validating user input and API parameters\n- Designing exception hierarchies for applications\n- Handling partial failures in batch operations\n- Converting external data to domain types\n- Building user-friendly error messages\n- Implementing fail-fast validation patterns\n\n## Core Concepts\n\n### 1. Fail Fast\n\nValidate inputs early, before expensive operations. Report all validation errors at once when possible.\n\n### 2. Meaningful Exceptions\n\nUse appropriate exception types with context. Messages should explain what failed, why, and how to fix it.\n\n### 3. Partial Failures\n\nIn batch operations, don't let one failure abort everything. Track successes and failures separately.\n\n### 4. Preserve Context\n\nChain exceptions to maintain the full error trail for debugging.\n\n## Quick Start\n\n```python\ndef fetch_page(url: str, page_size: int) -> Page:\n    if not url:\n        raise ValueError(\"'url' is required\")\n    if not 1 \u003C= page_size \u003C= 100:\n        raise ValueError(f\"'page_size' must be 1-100, got {page_size}\")\n    # Now safe to proceed...\n```\n\n## Fundamental Patterns\n\n### Pattern 1: Early Input Validation\n\nValidate all inputs at API boundaries before any processing begins.\n\n```python\ndef process_order(\n    order_id: str,\n    quantity: int,\n    discount_percent: float,\n) -> OrderResult:\n    \"\"\"Process an order with validation.\"\"\"\n    # Validate required fields\n    if not order_id:\n        raise ValueError(\"'order_id' is required\")\n\n    # Validate ranges\n    if quantity \u003C= 0:\n        raise ValueError(f\"'quantity' must be positive, got {quantity}\")\n\n    if not 0 \u003C= discount_percent \u003C= 100:\n        raise ValueError(\n            f\"'discount_percent' must be 0-100, got {discount_percent}\"\n        )\n\n    # Validation passed, proceed with processing\n    return _process_validated_order(order_id, quantity, discount_percent)\n```\n\n### Pattern 2: Convert to Domain Types Early\n\nParse strings and external data into typed domain objects at system boundaries.\n\n```python\nfrom enum import Enum\n\nclass OutputFormat(Enum):\n    JSON = \"json\"\n    CSV = \"csv\"\n    PARQUET = \"parquet\"\n\ndef parse_output_format(value: str) -> OutputFormat:\n    \"\"\"Parse string to OutputFormat enum.\n\n    Args:\n        value: Format string from user input.\n\n    Returns:\n        Validated OutputFormat enum member.\n\n    Raises:\n        ValueError: If format is not recognized.\n    \"\"\"\n    try:\n        return OutputFormat(value.lower())\n    except ValueError:\n        valid_formats = [f.value for f in OutputFormat]\n        raise ValueError(\n            f\"Invalid format '{value}'. \"\n            f\"Valid options: {', '.join(valid_formats)}\"\n        )\n\n# Usage at API boundary\ndef export_data(data: list[dict], format_str: str) -> bytes:\n    output_format = parse_output_format(format_str)  # Fail fast\n    # Rest of function uses typed OutputFormat\n    ...\n```\n\n### Pattern 3: Pydantic for Complex Validation\n\nUse Pydantic models for structured input validation with automatic error messages.\n\n```python\nfrom pydantic import BaseModel, Field, field_validator\n\nclass CreateUserInput(BaseModel):\n    \"\"\"Input model for user creation.\"\"\"\n\n    email: str = Field(..., min_length=5, max_length=255)\n    name: str = Field(..., min_length=1, max_length=100)\n    age: int = Field(ge=0, le=150)\n\n    @field_validator(\"email\")\n    @classmethod\n    def validate_email_format(cls, v: str) -> str:\n        if \"@\" not in v or \".\" not in v.split(\"@\")[-1]:\n            raise ValueError(\"Invalid email format\")\n        return v.lower()\n\n    @field_validator(\"name\")\n    @classmethod\n    def normalize_name(cls, v: str) -> str:\n        return v.strip().title()\n\n# Usage\ntry:\n    user_input = CreateUserInput(\n        email=\"user@example.com\",\n        name=\"john doe\",\n        age=25,\n    )\nexcept ValidationError as e:\n    # Pydantic provides detailed error information\n    print(e.errors())\n```\n\n### Pattern 4: Map Errors to Standard Exceptions\n\nUse Python's built-in exception types appropriately, adding context as needed.\n\n| Failure Type | Exception | Example |\n|--------------|-----------|---------|\n| Invalid input | `ValueError` | Bad parameter values |\n| Wrong type | `TypeError` | Expected string, got int |\n| Missing item | `KeyError` | Dict key not found |\n| Operational failure | `RuntimeError` | Service unavailable |\n| Timeout | `TimeoutError` | Operation took too long |\n| File not found | `FileNotFoundError` | Path doesn't exist |\n| Permission denied | `PermissionError` | Access forbidden |\n\n```python\n# Good: Specific exception with context\nraise ValueError(f\"'page_size' must be 1-100, got {page_size}\")\n\n# Avoid: Generic exception, no context\nraise Exception(\"Invalid parameter\")\n```\n\n## Advanced Patterns\n\n### Pattern 5: Custom Exceptions with Context\n\nCreate domain-specific exceptions that carry structured information.\n\n```python\nclass ApiError(Exception):\n    \"\"\"Base exception for API errors.\"\"\"\n\n    def __init__(\n        self,\n        message: str,\n        status_code: int,\n        response_body: str | None = None,\n    ) -> None:\n        self.status_code = status_code\n        self.response_body = response_body\n        super().__init__(message)\n\nclass RateLimitError(ApiError):\n    \"\"\"Raised when rate limit is exceeded.\"\"\"\n\n    def __init__(self, retry_after: int) -> None:\n        self.retry_after = retry_after\n        super().__init__(\n            f\"Rate limit exceeded. Retry after {retry_after}s\",\n            status_code=429,\n        )\n\n# Usage\ndef handle_response(response: Response) -> dict:\n    match response.status_code:\n        case 200:\n            return response.json()\n        case 401:\n            raise ApiError(\"Invalid credentials\", 401)\n        case 404:\n            raise ApiError(f\"Resource not found: {response.url}\", 404)\n        case 429:\n            retry_after = int(response.headers.get(\"Retry-After\", 60))\n            raise RateLimitError(retry_after)\n        case code if 400 \u003C= code \u003C 500:\n            raise ApiError(f\"Client error: {response.text}\", code)\n        case code if code >= 500:\n            raise ApiError(f\"Server error: {response.text}\", code)\n```\n\n### Pattern 6: Exception Chaining\n\nPreserve the original exception when re-raising to maintain the debug trail.\n\n```python\nimport httpx\n\nclass ServiceError(Exception):\n    \"\"\"High-level service operation failed.\"\"\"\n    pass\n\ndef upload_file(path: str) -> str:\n    \"\"\"Upload file and return URL.\"\"\"\n    try:\n        with open(path, \"rb\") as f:\n            response = httpx.post(\"https:\u002F\u002Fupload.example.com\", files={\"file\": f})\n            response.raise_for_status()\n            return response.json()[\"url\"]\n    except FileNotFoundError as e:\n        raise ServiceError(f\"Upload failed: file not found at '{path}'\") from e\n    except httpx.HTTPStatusError as e:\n        raise ServiceError(\n            f\"Upload failed: server returned {e.response.status_code}\"\n        ) from e\n    except httpx.RequestError as e:\n        raise ServiceError(f\"Upload failed: network error\") from e\n```\n\n### Pattern 7: Batch Processing with Partial Failures\n\nNever let one bad item abort an entire batch. Track results per item.\n\n```python\nfrom dataclasses import dataclass\n\n@dataclass\nclass BatchResult[T]:\n    \"\"\"Results from batch processing.\"\"\"\n\n    succeeded: dict[int, T]  # index -> result\n    failed: dict[int, Exception]  # index -> error\n\n    @property\n    def success_count(self) -> int:\n        return len(self.succeeded)\n\n    @property\n    def failure_count(self) -> int:\n        return len(self.failed)\n\n    @property\n    def all_succeeded(self) -> bool:\n        return len(self.failed) == 0\n\ndef process_batch(items: list[Item]) -> BatchResult[ProcessedItem]:\n    \"\"\"Process items, capturing individual failures.\n\n    Args:\n        items: Items to process.\n\n    Returns:\n        BatchResult with succeeded and failed items by index.\n    \"\"\"\n    succeeded: dict[int, ProcessedItem] = {}\n    failed: dict[int, Exception] = {}\n\n    for idx, item in enumerate(items):\n        try:\n            result = process_single_item(item)\n            succeeded[idx] = result\n        except Exception as e:\n            failed[idx] = e\n\n    return BatchResult(succeeded=succeeded, failed=failed)\n\n# Caller handles partial results\nresult = process_batch(items)\nif not result.all_succeeded:\n    logger.warning(\n        f\"Batch completed with {result.failure_count} failures\",\n        failed_indices=list(result.failed.keys()),\n    )\n```\n\n### Pattern 8: Progress Reporting for Long Operations\n\nProvide visibility into batch progress without coupling business logic to UI.\n\n```python\nfrom collections.abc import Callable\n\nProgressCallback = Callable[[int, int, str], None]  # current, total, status\n\ndef process_large_batch(\n    items: list[Item],\n    on_progress: ProgressCallback | None = None,\n) -> BatchResult:\n    \"\"\"Process batch with optional progress reporting.\n\n    Args:\n        items: Items to process.\n        on_progress: Optional callback receiving (current, total, status).\n    \"\"\"\n    total = len(items)\n    succeeded = {}\n    failed = {}\n\n    for idx, item in enumerate(items):\n        if on_progress:\n            on_progress(idx, total, f\"Processing {item.id}\")\n\n        try:\n            succeeded[idx] = process_single_item(item)\n        except Exception as e:\n            failed[idx] = e\n\n    if on_progress:\n        on_progress(total, total, \"Complete\")\n\n    return BatchResult(succeeded=succeeded, failed=failed)\n```\n\n## Best Practices Summary\n\n1. **Validate early** - Check inputs before expensive operations\n2. **Use specific exceptions** - `ValueError`, `TypeError`, not generic `Exception`\n3. **Include context** - Messages should explain what, why, and how to fix\n4. **Convert types at boundaries** - Parse strings to enums\u002Fdomain types early\n5. **Chain exceptions** - Use `raise ... from e` to preserve debug info\n6. **Handle partial failures** - Don't abort batches on single item errors\n7. **Use Pydantic** - For complex input validation with structured errors\n8. **Document failure modes** - Docstrings should list possible exceptions\n9. **Log with context** - Include IDs, counts, and other debugging info\n10. **Test error paths** - Verify exceptions are raised correctly\n",{"name":5,"description":7},"main","900bb95bbe72cdb94af6f5a620aa5081264b7b6d",".claude\u002Fmarketplaces\u002Fwshobson\u002Fplugins\u002Fpython-development\u002Fskills\u002Fpython-error-handling",0,"https:\u002F\u002Fgithub.com\u002Fsteph-frtech\u002Fclaude-code-up","https:\u002F\u002Fgithub.com\u002Fsteph-frtech\u002Fclaude-code-up#readme","https:\u002F\u002Fgithub.com\u002Fsteph-frtech","2026-05-16 00:03:30",{"source":8,"skillName":5,"commands":32,"prompt":42,"zipAvailable":43},[33,36,39],{"tool":34,"command":35},"npx","npx skills add steph-frtech\u002Fclaude-code-up --skill python-error-handling",{"tool":37,"command":38},"bunx","bunx skills add steph-frtech\u002Fclaude-code-up --skill python-error-handling",{"tool":40,"command":41},"pnpm","pnpm dlx skills add steph-frtech\u002Fclaude-code-up --skill python-error-handling","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fsteph-frtech\u002Fclaude-code-up\u002Fblob\u002Fmain\u002F.claude\u002Fmarketplaces\u002Fwshobson\u002Fplugins\u002Fpython-development\u002Fskills\u002Fpython-error-handling\u002FSKILL.md",true,[],[46,53,60,67,74,81],{"skillNo":47,"name":48,"nameZh":6,"description":49,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":50,"categories":51,"keywords":52,"publishedAt":18},"01M72Y1BY6X8TX3DS19Y04NEBQ","example","One-line summary of what this skill does","https:\u002F\u002Fgithub.com\u002Fsteph-frtech\u002Fclaude-code-up\u002Fblob\u002Fmain\u002Fskills\u002Fexample\u002FSKILL.md",[],[],{"skillNo":54,"name":55,"nameZh":6,"description":56,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":57,"categories":58,"keywords":59,"publishedAt":18},"01M72Y1A38EYR8S9P1MBYDAQTW","writing-plans","Use when you have a spec or requirements for a multi-step task, before touching code","https:\u002F\u002Fgithub.com\u002Fsteph-frtech\u002Fclaude-code-up\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fsuperpowers__writing-plans\u002FSKILL.md",[],[],{"skillNo":61,"name":62,"nameZh":6,"description":63,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":18},"01M72Y174QSV1B5NV1E4KWHQBR","using-git-worktrees","Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback","https:\u002F\u002Fgithub.com\u002Fsteph-frtech\u002Fclaude-code-up\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fsuperpowers__using-git-worktrees\u002FSKILL.md",[],[],{"skillNo":68,"name":69,"nameZh":6,"description":70,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":71,"categories":72,"keywords":73,"publishedAt":18},"01M72Y14SQRHHMKG316HGB2CGK","test-driven-development","Use when implementing any feature or bugfix, before writing implementation code","https:\u002F\u002Fgithub.com\u002Fsteph-frtech\u002Fclaude-code-up\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fsuperpowers__test-driven-development\u002FSKILL.md",[],[],{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":18},"01M72Y127BCPRH3BRKPJC3Q3G2","systematic-debugging","Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes","https:\u002F\u002Fgithub.com\u002Fsteph-frtech\u002Fclaude-code-up\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fsuperpowers__systematic-debugging\u002FSKILL.md",[],[],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":18},"01M72Y1090GJA6B67KPD60WPHH","subagent-driven-development","Use when executing implementation plans with independent tasks in the current session","https:\u002F\u002Fgithub.com\u002Fsteph-frtech\u002Fclaude-code-up\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fsuperpowers__subagent-driven-development\u002FSKILL.md",[],[]]