@moon791017/neo-skills 1.0.1

package/skills/dotnet-mvc/reference/coding-style.md

@@ -0,0 +1,43 @@
+# .NET MVC Coding Conventions
+
+This guide aims to improve the structural degree of ASP.NET Core MVC applications and optimize the development efficiency of Razor views and controllers.
+
+## 1. ViewModels
+
+### 1.1 Naming and Roles
+- **ViewModel Suffix**: All data models designed specifically for views must end with `ViewModel` (e.g., `UserLoginViewModel`).
+- **Strict Separation**: **Prohibited** to pass database entities directly to views. View models should only contain data required by the view.
+
+### 1.2 Data Annotations
+- **Validation Attributes**: Use attributes like `[Required]`, `[StringLength]`, `[EmailAddress]` on ViewModels to declare validation rules.
+- **Display Names**: Use `[Display(Name = "User Name")]` to ensure label consistency across different languages.
+
+---
+
+## 2. Views & Layouts
+
+### 2.1 View Naming
+- **PascalCase View Names**: View file names should match action methods and use `PascalCase` (e.g., `Index.cshtml`, `Edit.cshtml`).
+- **Strongly Typed Views**: All views must declare a strong type using `@model` at the top.
+- **Layout Management**: Make good use of `_ViewStart.cshtml` and `_Layout.cshtml` to unify styles. Use `@section` to handle scripts or styles specific to individual pages.
+
+---
+
+## 3. Tag Helpers
+
+- **Prioritize Use**: Prioritize using Tag Helpers (e.g., `asp-for`, `asp-action`) over traditional HTML Helpers (e.g., `@Html.TextBoxFor`).
+- **Custom Tags**: For repetitive UI logic (like pagination navigation, complex buttons), it is recommended to implement custom `TagHelper`s.
+
+---
+
+## 4. Controllers
+
+- **Inherit Controller**: Inherit from `Microsoft.AspNetCore.Mvc.Controller` (instead of `ControllerBase`) to gain View-related support.
+- **Action Returns**: Action methods should explicitly return `IActionResult` or `Task<IActionResult>`.
+
+---
+
+## 5. File Organization
+
+- **Standard Structure**: Follow the standard directory structure of `Controllers/`, `Models/` (ViewModels), and `Views/`.
+- **Partial Views**: Common view components should be placed in `Views/Shared/` and start with an underscore (e.g., `_UserCard.cshtml`).

package/skills/dotnet-mvc/reference/patterns.md

@@ -0,0 +1,56 @@
+# .NET MVC Modern Patterns
+
+This document introduces recommended development patterns in the ASP.NET Core MVC mode for .NET 6 to 10+.
+
+## 1. UI Modularization
+
+### 1.1 View Components
+**Recommendation**: For complex and reusable UI blocks (like navigation menus, shopping cart summaries), use `ViewComponent`s instead of `Partial View`s.
+```csharp
+public class ShoppingCartViewComponent : ViewComponent
+{
+    public async Task<IViewComponentResult> InvokeAsync() => View(await _service.GetItems());
+}
+```
+
+### 1.2 Tag Helper Componentization
+**Recommendation**: Implement `TagHelper`s to encapsulate complex HTML generation logic, making Razor views more declarative.
+
+---
+
+## 2. Data Flow and Validation
+
+### 2.1 Remote Validation
+**Recommendation**: Use the `[Remote]` attribute to implement real-time client-side validation (like checking if an account already exists), improving user experience.
+
+### 2.2 Antiforgery
+**Recommendation**: Ensure forms use `asp-antiforgery="true"`. In .NET 8+ global configuration is more straightforward.
+
+---
+
+## 3. Performance Optimization
+
+### 3.1 Cache Tag Helper
+**Recommendation**: Use `<cache>` or `<distributed-cache>` tags for view fragments that don't need frequent updates.
+```html
+<cache expires-after="@TimeSpan.FromMinutes(10)">
+    @await Component.InvokeAsync("TopNews")
+</cache>
+```
+
+### 3.2 Response Compression and Static Resources
+**Recommendation**: Configure response compression middleware and use `asp-append-version="true"` to ensure browser caches invalidate upon resource updates.
+
+---
+
+## 4. Architectural Evolution
+
+### 4.1 Vertical Slice Architecture
+**Recommendation**: For large MVC applications, consider placing Controllers, ViewModels, and Views in feature directories (e.g., `Features/Orders/`), utilizing `Area`s or a custom `ViewLocationExpander`.
+
+---
+
+## 5. C# 14+ Forward-looking Patterns
+
+### 5.1 Extension Types for IHtmlHelper
+**Recommendation**: Leverage C# 14's Extension Types to add domain-specific rendering methods to `IHtmlHelper`, not just static extension methods.

package/skills/dotnet-webapi/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: dotnet-webapi
+version: "1.0.0"
+category: "Framework"
+description: "開發 ASP.NET Core Web API (Controller-based) 的專家指引。支援從 .NET 6 (LTS) 到 .NET 10 (LTS) 的現代開發模式，涵蓋控制器設計、Problem Details、全域異常處理與 API 版本控制。"
+compatibility: "Supports .NET 6.0 through 10.0 environments. Requires .NET SDK installed locally."
+---
+
+# .NET Web API Expert Skill
+
+## Trigger On
+- The user requests to create, debug, refactor, or review ASP.NET Core Web APIs.
+- The project contains a `Controllers` directory and inherits from `ControllerBase`.
+- The target framework is .NET 6.0 (LTS) and above.
+- There is a need for API code modernization (e.g., migrating from Middleware exception handling to .NET 8+ `IExceptionHandler`).
+
+## Workflow
+1. **Perceive (Architecture Awareness):**
+   - Check `.csproj` to identify `TargetFramework`.
+   - Analyze project structure to confirm whether it uses N-Tier architecture or Vertical Slice.
+   - Identify existing cross-cutting concern handling methods (filters, middleware).
+2. **Reason (Planning Phase):**
+   - Evaluate whether to introduce the "Problem Details" standard.
+   - Determine whether to use the .NET 8+ global exception handling mechanism.
+   - Choose an appropriate versioning strategy based on project scale.
+3. **Act (Execution Phase):**
+   - Write high-quality controllers compliant with `[ApiController]` conventions.
+   - Implement strongly-typed and immutable DTOs (prioritize `record`).
+   - Integrate dependency injection, prioritizing Primary Constructors (C# 12+).
+4. **Validate (Standard Validation):**
+   - Validate whether Action return types comply with `ActionResult<T>` specifications.
+   - Check NRT (Nullable Reference Types) safety.
+   - Ensure asynchronous operations correctly pass down `CancellationToken`.
+
+## Feature Roadmap (.NET 6 - 10)
+
+### .NET 6 & 7 (Foundation)
+- **Controllers Architecture**: Traditional controller patterns and attribute routing.
+- **Problem Details**: Unified error response standards.
+- **Output Caching**: High-performance server-side caching.
+- **Nullable Reference Types**: Comprehensive null safety support.
+
+### .NET 8 & 9 (Productivity)
+- **IExceptionHandler**: More elegant centralized exception handling.
+- **Antiforgery**: Built-in anti-forgery support for Web APIs.
+- **Keyed Services**: More flexible dependency injection options.
+- **HybridCache**: Multi-level caching optimization.
+
+### .NET 10+ (Cutting Edge)
+- **Extension Members for Controllers**: Extending base controller functionality.
+- **Enhanced Serialization**: JSON optimization for large payloads.
+
+## Coding Standards
+- **Strong Typing**: Prioritize `ActionResult<T>` to improve Swagger support.
+- **NRT Compliance**: Strictly enforce Null safety to reduce runtime errors.
+- **Async Best Practices**: Always accept and pass `CancellationToken`.
+- **Naming**: Controller names must end with `Controller`, async methods must end with `Async`.
+
+## Deliver
+- **Version-Optimized Web API Code**: Provide modernized controllers and configurations suitable for the target version.
+- **Architectural Insights**: Provide refactoring suggestions for N-Tier or Clean Architecture.
+- **Security Recommendations**: Provide security suggestions regarding Problem Details and exception handling.
+
+## Validate
+- Ensure the code complies with C# 10+ modern syntax standards.
+- Validate endpoints correctly return error formats compliant with RFC 7807.
+- Confirm the code has no resource leaks in the tested environment (correct use of `using` and async).
+
+## Documentation
+### Official References
+- [ASP.NET Core Web API Overview](https://learn.microsoft.com/en-us/aspnet/core/web-api/)
+- [Handle errors in ASP.NET Core web APIs (Problem Details)](https://learn.microsoft.com/en-us/aspnet/core/web-api/handle-errors)
+- [Controller action return types in ASP.NET Core web API](https://learn.microsoft.com/en-us/aspnet/core/web-api/action-return-types)
+
+### Internal References
+- [Web API Coding Style and Naming Conventions](reference/coding-style.md)
+- [Web API Anti-Patterns and Best Practices](reference/anti-patterns.md)
+- [Web API Modern Patterns Guide](reference/patterns.md)

package/skills/dotnet-webapi/reference/anti-patterns.md

@@ -0,0 +1,48 @@
+# .NET Web API Anti-Patterns & Best Practices
+
+This document lists common mistakes in Controller-based Web API development and their corresponding correct practices.
+
+## 1. Controller Organization
+
+### 1.1 Avoid Fat Controllers
+**Problem**: Writing massive amounts of business logic, database access, or complex validation directly in controller actions.
+
+- **Bad**: Action exceeds 20 lines and includes direct manipulation of `DbContext` code.
+- **Good**: Encapsulate business logic into a Service layer or use MediatR (CQRS pattern), making the Action only responsible for orchestrating requests and responses.
+
+### 1.2 Avoid Ignoring the `[ApiController]` Attribute
+**Problem**: Omitting this attribute requires manual model validation handling using `if (!ModelState.IsValid)`.
+
+- **Good**: Always apply `[ApiController]` on API controllers.
+
+---
+
+## 2. Async & Resources
+
+### 2.1 Avoid Ignoring `CancellationToken`
+- **Problem**: Failing to pass cancellation tokens in long-running queries; server resources remain uselessly occupied when clients cancel connections.
+- **Good**: Action parameters should include `CancellationToken ct`, passing it down to async database operations or external HTTP calls.
+
+### 2.2 Avoid Synchronously Reading the Request Body
+- **Problem**: Synchronously reading the Body blocks the thread.
+- **Good**: Use framework-provided asynchronous parameter binding.
+
+---
+
+## 3. Security & Exceptions
+
+### 3.1 Avoid Returning Sensitive Exception Messages
+- **Problem**: Directly returning `ex.StackTrace` to the client in production environments.
+- **Good**: Use global exception handling to convert it into `ProblemDetails`, logging details only on the backend and returning a standard error format to the frontend.
+
+### 3.2 Avoid Over-exposing Domain Models
+- **Problem**: Directly returning database entity objects as responses, which might leak sensitive fields (like password hashes) or cause circular references.
+- **Good**: Create dedicated `Response DTO`s and use AutoMapper or manual mapping.
+
+---
+
+## 4. Documentation
+
+### 4.1 Ignoring Status Code Definitions
+- **Problem**: Swagger UI only displays `200`, making it hard for frontend developers to know other error scenarios.
+- **Good**: Use markers like `[ProducesResponseType(StatusCodes.Status404NotFound)]`.

package/skills/dotnet-webapi/reference/coding-style.md

@@ -0,0 +1,47 @@
+# .NET Web API Coding Conventions
+
+This guide is based on industry standards for ASP.NET Core Web API, aiming to improve organization and maintenance efficiency in the Controller-based pattern.
+
+## 1. Controllers
+
+### 1.1 Naming and Attributes
+- **PascalCase**: All controller class names must use `PascalCase` and end with `Controller` (e.g., `UsersController`).
+- **[ApiController]**: All API controllers must be marked with the `[ApiController]` attribute to enable automatic model validation, inferred parameter binding sources, and `ProblemDetails` responses.
+- **[Route]**: It is recommended to use `[Route("api/[controller]")]` or explicit version paths (e.g., `[Route("api/v1/users")]`).
+
+### 1.2 Action Methods
+- **Semantic Naming**: Method names should reflect business intent (e.g., `GetUserAsync`), and asynchronous methods must end with `Async`.
+- **HTTP Verbs**: Explicitly use `[HttpGet]`, `[HttpPost]`, `[HttpPut]`, `[HttpDelete]`, or `[HttpPatch]`.
+
+---
+
+## 2. Data Transfer
+
+- **DTO Naming**: Use `Request` or `Response` as suffixes (e.g., `UserCreateRequest`, `UserSummaryResponse`).
+- **Record Types**: For read-only data transfer objects, prioritize using `record` types.
+
+---
+
+## 3. Response Handling
+
+- **ActionResult<T>**: Methods should return `Task<ActionResult<T>>`, which offers better type safety and Swagger support compared to `IActionResult`.
+- **Standard Response Methods**:
+  - `Ok(data)` (200)
+  - `CreatedAtAction(...)` (201)
+  - `NoContent()` (204)
+  - `BadRequest(ModelState)` (400)
+  - `NotFound()` (404)
+
+---
+
+## 4. Dependency Injection (DI) & Services
+
+- **Constructor Injection**: Always use constructor injection for services (prioritize C# 12+ Primary Constructors).
+- **Interface-Oriented**: Inject interfaces instead of concrete classes to facilitate unit testing.
+
+---
+
+## 5. File Organization and Namespaces
+
+- **Vertical Slicing**: For large projects, it is recommended to organize folders by feature domain instead of the traditional Controllers/Models/Services layering.
+- **File-scoped Namespace**: Always use File-scoped Namespaces (C# 10+).

package/skills/dotnet-webapi/reference/patterns.md

@@ -0,0 +1,52 @@
+# .NET Web API Modern Patterns
+
+This document introduces recommended development patterns in the Controller-based mode for .NET 6 to 10+.
+
+## 1. Error Handling and Response Formats
+
+### 1.1 Problem Details (RFC 7807)
+**Recommendation**: Unified use of `ProblemDetails` to handle error responses. In .NET 7+, call `builder.Services.AddProblemDetails()` in `Program.cs`.
+
+### 1.2 Global Exception Handler (IExceptionHandler) - .NET 8+
+**Recommendation**: Implement the `IExceptionHandler` interface to centrally handle uncaught exceptions, replacing the legacy Middleware approach.
+
+---
+
+## 2. Parameter Binding and Validation
+
+### 2.1 Complex Type Binding
+**Recommendation**: Make good use of `[FromRoute]`, `[FromQuery]`, `[FromBody]`, and `[FromHeader]` to explicitly define binding sources.
+
+### 2.2 FluentValidation Integration
+**Recommendation**: Combine with `FluentValidation` for complex model validation, separating validation logic from DTO definitions.
+
+---
+
+## 3. Architectural Design
+
+### 3.1 API Versioning (Asp.Versioning.Http)
+**Recommendation**: Use the official versioning package to support multiple coexisting versions via URL or Header.
+```csharp
+[ApiVersion("1.0")]
+[Route("api/v{version:apiVersion}/[controller]")]
+```
+
+### 3.2 Action Filters
+**Recommendation**: For cross-cutting concerns (like permission checks, logging), implement `IAsyncActionFilter`.
+
+---
+
+## 4. Documentation and Performance
+
+### 4.1 Swagger/OpenAPI Enrichment
+**Recommendation**: Use `[ProducesResponseType]` to mark all possible HTTP status codes and response types.
+
+### 4.2 Output Caching - .NET 7+
+**Recommendation**: Use `builder.Services.AddOutputCache()` to provide high-performance server-side caching, reducing pressure on controllers.
+
+---
+
+## 5. C# 14+ Forward-looking Patterns
+
+### 5.1 Extension Types for Controllers
+**Recommendation**: Leverage Extension Types to expand common auxiliary properties or methods for the base `ControllerBase`.

package/skills/explain/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: explain
+description: 分析原始碼或專案結構，提供技術解析與架構洞察。
+---
+
+# Project Code Explanation Specification
+
+## Perceive
+1. Intercept the standard input (stdin) or file arguments passed via the CLI command.
+2. Detect the file context by reading the specified file paths or the current working directory.
+3. Identify programming languages through file extensions or shebang lines.
+4. Capture optional flags such as `--all` or specific line ranges to define the scope of analysis.
+
+## Reason
+1. Structural Parsing: Map the relationships between variables, functions, and classes within the provided context.
+2. Logic Synthesis: Consolidate fragmented code segments into a coherent operational flow.
+3. Contextual Inference: Evaluate how the specific code block interacts with standard libraries or identified project dependencies.
+4. Documentation Alignment: Compare the implementation against common design patterns to explain "why" the code is structured in its current form.
+
+## Act
+1. Output a structured explanation directly to the terminal's standard output (stdout).
+2. Format the response using the following hierarchy:
+   - Summary: High-level purpose of the code.
+   - Logic Flow: Step-by-step breakdown of execution and data flow.
+   - Key Components: Definitions of primary symbols and their roles.
+3. Apply syntax highlighting to any code blocks included within the explanation.
+4. Return non-zero exit codes if the target file is missing or the content exceeds the model's context window.

package/skills/git-commit/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: git-commit
+description: Analyzes staged changes, generates a high-quality Conventional Commits message in Traditional Chinese, and executes the commit only after user confirmation.
+disable-model-invocation: true
+---
+
+# Git Commit Message Generator
+
+## CRITICAL SAFETY PROTOCOL
+
+- **Absolute prohibition**: Never execute `git commit` in the same turn you generate the commit message.
+- **Wait for confirmation**: Output the proposed message, then stop immediately and ask the user to confirm.
+- **User-triggered only**: Only execute the commit in the next turn if the user explicitly replies with "yes", "ok", "是", or "commit".
+
+---
+
+## Perceive
+
+1. Run `git add .` to stage all changes.
+2. Run `git diff --staged` to retrieve the full staged diff.
+3. If the staging area is empty, inform the user "No staged changes found." and stop.
+
+## Reason
+
+Analyze the diff to determine the core intent of the changes:
+
+1. **Full scan**: Identify added, deleted, and modified files.
+2. **Find correlations**: Determine whether the changes serve a single goal (e.g., adding a Model and updating a Service indicates a feature implementation).
+3. **Filter noise**: Ignore pure formatting adjustments (whitespace, line endings) and focus on logical changes.
+4. **Define type**: Choose the most accurate Conventional Commits type based on the primary purpose of the changes.
+
+## Act
+
+### Step 1: Generate the commit message
+
+Output strictly in the following format:
+
+```
+<type>(<scope>): <subject>
+
+<body>
+```
+
+**Type** — choose the most appropriate one:
+
+| Type | When to use |
+|------|-------------|
+| `feat` | New feature |
+| `fix` | Bug fix |
+| `docs` | Documentation changes only |
+| `style` | Formatting, no logic change |
+| `refactor` | Refactoring, not a feature or fix |
+| `perf` | Performance improvement |
+| `test` | Adding or modifying tests |
+| `build` | Build system or dependency changes |
+| `ci` | CI/CD configuration changes |
+| `chore` | Other maintenance tasks |
+| `revert` | Reverting a previous commit |
+
+**Quality rules**:
+
+- **Subject**: Max 50 characters, imperative mood (e.g., "新增...", "修復...", "移除...").
+- **Body**:
+  - Use bullet points (`-`) for complex changes to explain each detail.
+  - May be omitted for simple documentation or minor fixes.
+  - For new files, describe their purpose.
+- **Language**: Both Subject and Body must be written in **Traditional Chinese (Taiwan)**.
+- **Tone**: Professional and concise — avoid filler phrases like "This change is for...".
+
+### Step 2: Ask for confirmation
+
+Output the generated commit message inside a code block, then **stop immediately** and ask:
+
+> 請問是否要執行此 commit？（輸入「是」或「yes」確認）
+
+### Step 3: Execute (only after user confirms)
+
+Run:
+
+```bash
+git commit -m "<subject>" -m "<body>"
+```
+
+After execution, run `git log --oneline -1` and display the result to confirm the commit was created successfully.

package/skills/python/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: python
+version: "1.0.0"
+category: "Core"
+description: "用於 Python 3.10+ 開發的核心專家技能。專注於現代 Python 特性（Structural Pattern Matching, Union Types, Async Task Groups）、程式碼品質與架構設計。"
+compatibility: "Supports Python 3.10 to 3.14. Requires a Python project structure (pyproject.toml, requirements.txt, or venv)."
+---
+
+# Python 3.10+ Expert Skill
+
+## Trigger On
+- The user asks to write, debug, review, or refactor Python code.
+- Working in a repository containing `*.py`, `pyproject.toml`, `requirements.txt`, `Pipfile`, or `poetry.lock`.
+- Requires asynchronous programming (`asyncio`), type hinting, or modern Python feature recommendations.
+- The project needs setup for testing frameworks (`pytest`) or static analysis tools (`ruff`, `mypy`).
+
+## Workflow
+1. **Perceive:**
+   - Inspect the project root to identify package management tools: `pyproject.toml` (Poetry/PDM/Ruff), `requirements.txt` (pip), or `environment.yml` (Conda).
+   - Probe for Python version requirements (ensure compatibility with 3.10+ minimum).
+   - Identify the application type: Web API (FastAPI, Flask, Django), Data Science (Pandas, PyTorch), or CLI tools.
+2. **Reason:**
+   - Evaluate if the current code follows modern Python (3.10+) idioms (e.g., `match/case`, `|` union types).
+   - Decide if type checking (MyPy/Pyright) or auto-formatting (Ruff/Black) needs to be introduced.
+   - Recommend appropriate architectural patterns based on project scale.
+3. **Act:**
+   - Write Python code with complete Type Hints, prioritizing the `X | Y` syntax.
+   - Prefer modern language features: `match` statements (3.10+), `TaskGroup` (3.11+), and new generic syntax (3.12+).
+   - Ensure code passes static analysis and unit tests.
+
+## Coding Standards
+- **Type Hinting:** Strongly recommended for all function signatures. Use 3.10+ union syntax like `list[int | str]`.
+- **PEP 8 Compliance:** Follow official style guidelines. Recommended to use `ruff` as a linter and formatter for consistency.
+- **Async Processing:** Use 3.11+ `asyncio.TaskGroup` to manage concurrent tasks.
+- **Error Handling:** Use specific exception types and leverage 3.11+ `ExceptionGroup` and `except*` syntax.
+
+## Tooling Recommendations
+- **Linter / Formatter:** `ruff` (high performance and highly integrated).
+- **Type Checker:** `mypy` or `pyright`.
+- **Testing:** `pytest` with `pytest-asyncio` or `pytest-cov`.
+- **Package Management:** `Poetry` or `uv` to ensure dependency locking and environment consistency.
+
+## Deliver
+- **Code Quality Report:** Identify parts that do not comply with 3.10+ modern syntax or PEP 8.
+- **Best Practice Recommendations:** Provide specific refactoring suggestions, such as converting complex logic into `match/case` structures.
+- **Validated Code:** Provide Python source code accompanied by test cases and passed type checks.
+
+## Validate
+- Code must run in a Python 3.10+ environment.
+- Functions should have Docstrings (following Google or NumPy styles).
+- Complex logic should include unit tests.
+- All public APIs should have complete type hints.
+
+## Documentation
+### Official References
+- [Python 3 Official Documentation](https://docs.python.org/3/)
+### Internal References
+- [Modern Python syntax evolution (3.10-3.14) and PEP 8 naming conventions](reference/coding-style.md)
+- [Recommended modern Python 3.10 - 3.14 development patterns and best practices](reference/patterns.md)
+- [Outdated Python practices to avoid, common pitfalls, and security traps](reference/anti-patterns.md)
+- [Intelligent detection and management of Python project virtual environments and dependency tools](../python-manager/SKILL.md)

package/skills/python/reference/anti-patterns.md

@@ -0,0 +1,177 @@
+# Python Modernization & Evolution Guide (3.10 - 3.14+)
+
+This document summarizes important syntax evolutions from Python 3.10 to the latest versions, comparing "Outdated/Incorrect Practices" with "Modern/Correct Practices" to help developers write more readable, secure, and performant code.
+
+---
+
+## 0. Fundamental Pitfalls (Version Independent)
+These are the most common logical errors in Python development.
+
+### A. Using Mutable Objects as Default Arguments
+*   **Incorrect:** `def add_item(item, items=[]):` (causes shared state across multiple calls)
+*   **Correct:**
+    ```python
+    def add_item(item, items: list | None = None):
+        if items is None:
+            items = []
+        items.append(item)
+        return items
+    ```
+
+### B. Manual Type Checking
+*   **Incorrect:** `if type(val) == str:` (breaks inheritance relationships)
+*   **Correct:** `if isinstance(val, str):`
+
+---
+
+## 1. Python 3.10: Union Types and Structural Matching
+
+### A. Union Type Operator
+*   **Outdated:** `from typing import Union; def func(data: Union[int, str]):`
+*   **Modern:**
+    ```python
+    def process_data(data: int | str) -> int | str:
+        # Use the intuitive bitwise OR operator | instead of Union[]
+        pass
+    ```
+
+### B. Structural Pattern Matching
+*   **Outdated:** Using long `if-elif-else` chains.
+*   **Modern:**
+    ```python
+    def http_status(status):
+        match status:
+            case 200:
+                return "OK"
+            case 404:
+                return "Not Found"
+            case _:
+                return "Unknown"
+    ```
+
+---
+
+## 2. Python 3.11: Type References and Exception Groups
+
+### A. The `Self` Type
+*   **Outdated:** Relying on `TypeVar` for verbose class self-references.
+*   **Modern:**
+    ```python
+    from typing import Self
+
+    class Config:
+        def clone(self) -> Self:
+            return self
+    ```
+
+### B. Exception Groups
+*   **Outdated:** Traditional `except` easily misses other exceptions in concurrent tasks.
+*   **Modern:**
+    ```python
+    try:
+        await asyncio.gather(task1(), task2())
+    except* ValueError as e:
+        print("Handling all ValueError groups")
+    except* TypeError as e:
+        print("Handling all TypeError groups")
+    ```
+
+---
+
+## 3. Python 3.12: Generics and f-string Upgrades
+
+### A. Type Parameter Syntax
+*   **Outdated:** Declaring `T = TypeVar('T')`.
+*   **Modern:**
+    ```python
+    # Syntax is greatly simplified, completely removing dependency on TypeVar
+    def get_first[T](items: list[T]) -> T:
+        return items[0]
+    ```
+
+### B. f-string Nested Quote Restriction Lifted
+*   **Outdated:** Inner and outer quotes must be alternated, e.g., `f"{employee['name']}"`.
+*   **Modern:**
+    ```python
+    employee = {"name": "Alice"}
+    # Allows direct reuse of double quotes, reducing mental load when modifying code
+    message = f"Employee name is {employee["name"]}"
+    ```
+
+---
+
+## 4. Python 3.13: Deprecation Markers and Type Defaults
+
+### A. Deprecation Decorator
+*   **Outdated:** Manually calling `warnings.warn()`.
+*   **Modern:**
+    ```python
+    from warnings import deprecated
+
+    @deprecated("Please use new_api() instead")
+    def old_api():
+        pass
+    ```
+
+### B. Copy and Replace for Immutable Objects (`copy.replace`)
+*   **Outdated:** Calling different methods (e.g., `._replace()` or `replace()`) for different types.
+*   **Modern:**
+    ```python
+    import copy
+    # 3.13 unifies the interface for modifying copies of namedtuple, dataclass, datetime, etc.
+    new_obj = copy.replace(old_obj, field="value")
+    ```
+
+### C. Type Parameter Defaults
+*   **Modern:**
+    ```python
+    # Allows specifying default types for generics
+    class Box[T = int]:
+        def __init__(self, item: T):
+            self.item = item
+    ```
+
+### D. Precise Type Narrowing and Read-Only Protection
+*   **Modern:**
+    ```python
+    from typing import TypeIs, ReadOnly, TypedDict
+
+    class User(TypedDict):
+        age: ReadOnly[int] # Marked as read-only to prevent static check errors
+
+    def is_str_list(val: list[object]) -> TypeIs[list[str]]:
+        # Provides more intuitive type narrowing than TypeGuard
+        return all(isinstance(x, str) for x in val)
+    ```
+
+### E. Removal of "Dead Batteries" (PEP 594)
+*   **Note:** Python 3.13 has officially removed 19 legacy modules including `cgi`, `telnetlib`, and `crypt`. Please use modern alternatives (e.g., `fastapi`, `paramiko`).
+
+---
+
+## 5. Python 3.14 (Latest Preview)
+
+### A. Unparenthesized Exception Handling
+*   **Outdated:** `except (ValueError, TypeError):`
+*   **Modern:** `except ValueError, TypeError:` (reduces visual noise)
+
+### B. Deferred Annotation Evaluation
+*   **Outdated:** `def set_next(self, node: "Node"):` (requires string quotes for forward references)
+*   **Modern:**
+    ```python
+    class Node:
+        # 3.14 defaults to deferred evaluation; refer to the class directly without quotes
+        def set_next(self, node: Node):
+            pass
+    ```
+
+### C. Pathlib Native Copy and Move
+*   **Outdated:** `shutil.copy(file, dest)`
+*   **Modern:** `from pathlib import Path; Path("f.txt").copy("dest.txt")`
+
+---
+
+## 6. Resource Management (General Best Practice)
+Always use `with` statements to handle files and connections.
+*   **Incorrect:** Manually calling `f.close()`.
+*   **Correct:** `with open(...) as f:`.