wow

### Skill: Mastering Green Energy Technology (GET)

#### Objective

To understand the comprehensive landscape of Green Energy Technology (GET), encompassing the generation of renewable power, the management of energy storage, and the implementation of systemic efficiency solutions to achieve carbon neutrality.

#### Core Concept

Green Energy Technology is not a single discipline but a convergence of physics, engineering, and environmental science. It focuses on harvesting energy from natural processes with minimal environmental impact. The core equation of this field is the transition from carbon-intensive combustion to **zero-emission generation** (Solar, Wind, Nuclear) and **efficient utilization** (Smart Grids, Hydrogen). It operates on the principle of the "Energy Trilemma": balancing security, equity, and environmental sustainability.

#### Step-by-Step Guide

1. **Master Renewable Generation Sources**
The foundation of GET is the capture of energy from infinite or regenerative sources.
    - **Solar Photovoltaics (PV):** Understanding the conversion of photons to electrons. Modern technology focuses on high-efficiency monocrystalline cells and emerging perovskite structures that push conversion efficiencies beyond 25%.
    - **Wind Power:** Utilizing aerodynamics to convert kinetic wind energy into mechanical power. Key trends include massive offshore turbines (15MW+) that utilize the stronger, more consistent winds available at sea.
    - **Nuclear Energy:** While distinct from "renewables," nuclear is a critical green technology for baseload power. This involves understanding fission (current Gen III+ reactors like "Hualong One") and the future potential of fusion and Thorium-based molten salt reactors.
2. **Implement Energy Storage Systems (ESS)**
Because solar and wind are intermittent (the sun doesn't always shine, the wind doesn't always blow), storage is the "holy grail" of GET.
    - **Electrochemical Storage:** Lithium-ion batteries are the current standard, but the field is moving toward Solid-State Batteries (higher energy density, safer) and Sodium-ion batteries (lower cost).
    - **Green Hydrogen:** This is a game-changer for heavy industry. Using electrolyzers to split water ($H_2O$) into hydrogen and oxygen using excess renewable electricity creates a storable fuel that emits only water when burned.
    - **Pumped Hydro & Thermal:** Traditional methods like pumping water uphill or storing heat in molten salt (for solar thermal plants) remain vital for grid-scale stability.
3. **Optimize via Smart Grids & Digitalization**
GET is increasingly software-defined. The "Smart Grid" uses digital communication technology to detect and react to local changes in usage.
    - **Demand Response:** Algorithms that shift energy usage to off-peak times automatically.
    - **Virtual Power Plants (VPP):** Aggregating thousands of distributed home batteries and solar panels to act like a single, large power plant, relieving stress on the main grid.
4. **Navigate Corporate & Industrial Applications**
Understanding how major entities deploy these technologies is crucial for professional application.
    - **Zero-Carbon Parks:** The integration of generation, storage, and consumption within a defined industrial zone to achieve net-zero emissions.
    - **Corporate Strategy:** Analyzing how giants like **LONGi Green Energy** (focusing on monocrystalline silicon efficiency) or **State Power Investment Corporation (SPIC)** (focusing on nuclear and hydrogen integration) drive market trends.

#### Visual Example: The Green Tech Mix

| Technology | Primary Function | Key Advantage | Current Challenge |
| ------ |------ |------ |------ |
| **Solar PV** | Generation | Modular; works at any scale. | Intermittency (Night/Clouds). |
| **Wind (Offshore)** | Generation | High capacity factor; massive output. | High installation/maintenance costs. |
| **Green Hydrogen** | Storage/Fuel | Decarbonizes steel/shipping; long-term storage. | Low efficiency in conversion (electrolysis). |
| **Solid-State Battery** | Storage | Non-flammable; high density. | Manufacturing scalability. |
| **Nuclear (Gen IV)** | Baseload Power | Constant power; small footprint. | Waste management; public perception. |

#### Python Code Snippet (Renewable Efficiency Calculator)

This script calculates the potential energy output of a solar array, a fundamental task in green energy planning.

```
def calculate_solar_potential(panel_area_sqm, efficiency_percent, solar_irradiance_w_m2, hours_of_sun):
    """
    Calculates the total energy generation of a solar array.
    
    Args:
    panel_area_sqm (float): Total surface area of the panels in square meters.
    efficiency_percent (float): Efficiency of the solar cells (e.g., 22.0 for 22%).
    solar_irradiance_w_m2 (float): Power of sunlight hitting the panels (Standard is ~1000 W/m2).
    hours_of_sun (float): Number of peak sun hours per day.
    
    Returns:
    float: Total energy generated in kilowatt-hours (kWh).
    """
    
    # 1. Calculate Power Output in Watts
    # Formula: Power = Area * Irradiance * Efficiency
    efficiency_decimal = efficiency_percent / 100.0
    power_output_watts = panel_area_sqm * solar_irradiance_w_m2 * efficiency_decimal
    
    # 2. Calculate Energy over Time (Watt-hours)
    energy_watt_hours = power_output_watts * hours_of_sun
    
    # 3. Convert to Kilowatt-hours (kWh) - the standard billing unit
    energy_kwh = energy_watt_hours / 1000.0
    
    print(f"--- Solar Array Potential ---")
    print(f"Panel Area: {panel_area_sqm} m²")
    print(f"Efficiency: {efficiency_percent}%")
    print(f"Daily Generation: {energy_kwh:.2f} kWh")
    
    return energy_kwh

# Example Usage
# A 50 m² roof with 25% efficient panels receiving 5 hours of peak sun
calculate_solar_potential(50, 25.0, 1000, 5)
```

### Skill: Mastering the Amazon Prime Ecosystem

#### Objective

To strategically leverage the Amazon Prime membership to maximize financial value, optimize logistics, and access a comprehensive suite of digital entertainment and lifestyle benefits.

#### Core Concept

Amazon Prime is not merely a shipping subscription; it is a lifestyle ecosystem designed to reduce friction in commerce and entertainment. By paying a recurring fee (annual or monthly), members gain access to a "walled garden" of perks that extend far beyond free delivery, including high-definition streaming video, ad-free music, exclusive shopping events, and cloud storage. The core philosophy is "stickiness"—creating a seamless loop of utility that makes Amazon the default choice for shopping and media consumption.

#### Step-by-Step Guide

1. **Optimize Logistics and Shipping**
The primary utility of Prime is the elimination of shipping friction.
    - **Unlimited Free Delivery:** Members enjoy free, fast shipping on millions of eligible items. This typically includes One-Day or Two-Day delivery, and in many metropolitan areas, Same-Day or even Two-Hour delivery (Prime Now).
    - **Global Shopping (Prime Global):** For cross-border shopping (e.g., Amazon Global Store), members often receive free international shipping on orders over a certain threshold (typically $200), significantly reducing the cost of importing goods.
    - **Release Date Delivery:** For pre-orders on books or video games, Prime members often receive the item on the day of release, provided the order is placed within a specific window.
2. **Maximize Financial Value through Exclusive Deals**
Prime membership acts as a key to lower pricing tiers and exclusive inventory.
    - **Prime Day:** This is the flagship event, usually held annually (often in July). It offers deep discounts exclusively for members, often rivaling Black Friday sales.
    - **Lightning Deals:** Prime members get "Early Access" to limited-time Lightning Deals, typically 30 minutes before non-members. This is crucial for purchasing high-demand items that sell out quickly.
    - **Prime Exclusive Discounts:** Look for the "Prime" badge on product pages, which often indicates a specific price reduction available only to subscribers.
3. **Leverage Digital Entertainment (The "Netflix Killer")**
A significant portion of the membership fee covers a massive digital media library.
    - **Prime Video:** Access to thousands of movies, TV shows, and critically acclaimed "Amazon Originals" (e.g., *The Lord of the Rings: The Rings of Power*, *The Boys*). This service competes directly with standalone streaming subscriptions.
    - **Prime Music:** Members get ad-free access to millions of songs and thousands of playlists and stations. While not the full "On-Demand" library of the paid Music Unlimited tier, it is sufficient for most casual listeners.
    - **Prime Reading & Kindle First:** Access to a rotating selection of thousands of Kindle books, magazines, and comics. Additionally, "First Reads" allows members to download one editor's pick for free each month before general release.
4. **Utilize Lifestyle and Utility Tools**
Beyond shopping and movies, Prime offers practical tools for daily life.
    - **Amazon Photos:** This is a hidden gem for many users. Prime members receive **unlimited full-resolution photo storage**. Unlike Google Photos or iCloud, this does not count against your standard storage quota, making it an excellent backup solution for smartphone galleries.
    - **Try Before You Buy:** For eligible fashion items (clothing, shoes, jewelry), members can order items to try on at home and only pay for what they keep, returning the rest for free.
5. **Manage Household and Sharing**
Prime is designed to be shared, increasing its value per capita.
    - **Amazon Household:** You can link your account with another adult (spouse/partner) to share payment methods and digital content (apps, games, audiobooks).
    - **Teen and Child Profiles:** You can add up to four teens (who can have their own login and shopping permissions) and four child profiles (for content filtering on Fire tablets/TV).

#### Visual Example: The Value Breakdown

| Feature | Non-Prime User | Prime Member |
| ------ |------ |------ |
| **Shipping** | Pays per shipment or waits for "Free Super Saver" (slow). | Free One-Day/Two-Day/Same-Day on eligible items. |
| **Video Streaming** | Must pay for Netflix/Disney+ separately. | Included (Prime Video with Originals). |
| **Music** | Ad-supported or separate subscription. | Ad-free streaming included. |
| **Photo Storage** | Limited free tier (e.g., 5GB). | **Unlimited** full-resolution photo storage. |
| **Shopping Events** | Standard pricing; late access to deals. | Exclusive discounts; 30-minute early access to Lightning Deals. |

#### Python Code Snippet (Value Calculator)

This conceptual script helps a user determine if the membership is mathematically worth it based on their shopping and usage habits.

```
def calculate_prime_value(annual_shipping_spend, streaming_subscription_cost, photos_needed):
    """
    Calculates if Amazon Prime is financially viable based on user habits.
    """
    PRIME_ANNUAL_FEE = 139.00 # Approximate US Annual Fee
    ESTIMATED_SAVINGS = 0

    # 1. Calculate Shipping Savings
    # Assume average shipping cost is $6 per order for non-prime
    shipping_savings = annual_shipping_spend 
    
    # 2. Calculate Streaming Value
    # If user cancels other services because of Prime Video/Music
    streaming_savings = streaming_subscription_cost * 12

    # 3. Calculate Storage Value
    # If user would otherwise pay for extra iCloud/Google storage
    storage_savings = 12.00 * 12 if photos_needed else 0

    total_benefit = shipping_savings + streaming_savings + storage_savings
    net_value = total_benefit - PRIME_ANNUAL_FEE

    print(f"--- Prime Value Analysis ---")
    print(f"Total Annual Benefits: .2f")
    print(f"Cost of Prime: -.2f")
    
    if net_value > 0:
        print(f"Verdict: POSITIVE. You save .2f per year.")
    else:
        print(f"Verdict: NEGATIVE. You lose .2f in value.")

# Example Usage
# User spends $60 on shipping, pays for one $15/mo streaming service, and needs photo storage
calculate_prime_value(60, 15, True)
```

### Skill: Mastering the Volcengine Ecosystem

#### Objective

To effectively navigate, deploy, and integrate Volcengine's cloud infrastructure and AI capabilities, enabling the construction of scalable applications and the implementation of intelligent agent workflows.

#### Core Concept

Volcengine is a comprehensive cloud service provider that offers a robust suite of tools ranging from foundational Infrastructure as a Service (IaaS) to advanced AI Platform as a Service (PaaS). Its ecosystem is designed to support the entire lifecycle of modern application development, characterized by high-performance computing resources (ECS, VKE), specialized AI models (Doubao, Seed), and developer-centric frameworks (OpenClaw) that bridge the gap between raw infrastructure and intelligent automation.

#### Step-by-Step Guide

1. **Establish Infrastructure Foundations**
The first step in leveraging Volcengine is setting up the underlying compute and network environment. This involves moving beyond manual console configuration to Infrastructure as Code (IaC) principles for reproducibility.
    - **Compute & Networking:** Utilize Elastic Compute Service (ECS) for virtual servers and Virtual Private Cloud (VPC) for network isolation. For containerized applications, the Volcengine Kubernetes Engine (VKE) provides a managed control plane that simplifies cluster operations.
    - **Declarative Setup:** Adopt tools like Terraform to define resources (VPCs, subnets, security groups) in configuration files. This ensures that environments can be version-controlled and replicated instantly, avoiding "configuration drift."
2. **Integrate AI & Model Services**
Volcengine distinguishes itself with its "Model as a Service" offerings, allowing developers to access state-of-the-art Large Language Models (LLMs) and multimodal capabilities via API.
    - **The Doubao & Seed Families:** Access the Doubao series for natural language understanding and code generation, or the Seed series (e.g., Seedance) for high-fidelity image and video generation.
    - **API Consumption:** Authenticate using Access Keys and Secret Keys to call these models. The ecosystem supports high-concurrency requests, making it suitable for production-grade AI applications that require low latency and high throughput.
3. **Deploy Intelligent Agents with OpenClaw**
A unique capability of the Volcengine ecosystem is the integration with OpenClaw (also known as ArkClaw), an open-source AI agent framework. This allows for the creation of "Skills" that automate complex workflows.
    - **Framework Deployment:** OpenClaw can be deployed via cloud images (for stability) or local scripts (for testing). It acts as a middleware that connects LLMs with actionable tools.
    - **Skill Creation:** Developers can build custom "Skills"—modular scripts that allow the AI to interact with external systems. For example, a `volcengine-rds-mysql` skill allows an agent to manage database instances using natural language, effectively turning a chatbot into a database administrator.
4. **Implement Multi-Agent Collaboration**
Volcengine's infrastructure supports advanced architectural patterns like Multi-Agent Collaboration. By combining the compute power of VKE with the reasoning capabilities of Doubao, you can orchestrate teams of AI agents.
    - **Orchestration:** Use the platform to host agent swarms where specialized agents (e.g., a "Researcher" agent and a "Coder" agent) communicate via structured protocols to solve problems that are too complex for a single model instance.
5. **Manage Operations & Security**
Effective use of the platform requires strict adherence to security and cost-management best practices.
    - **Security Groups:** Always restrict access to sensitive ports (like the OpenClaw management port 18789) to trusted IP addresses only.
    - **Credential Management:** Never hardcode API keys. Use environment variables or secret management services to inject credentials securely at runtime.

#### Visual Example: The "AI-Enhanced" Deployment Architecture

| Layer | Component | Function |
| ------ |------ |------ |
| **User Interface** | OpenClaw / Chat | The entry point where natural language commands are issued. |
| **Orchestration** | OpenClaw Gateway | Parses intent and routes requests to the appropriate "Skill." |
| **Intelligence** | Doubao/Seed Models | Provides the reasoning engine and content generation capabilities. |
| **Infrastructure** | VKE / ECS / RDS | The underlying compute resources and databases managed by the agents. |

#### Python Code Snippet (SDK Integration)

This script demonstrates how to programmatically interact with Volcengine's Model-as-a-Service (MaaS) to generate content, a foundational step in building AI-driven skills.

```
from volcengine.maas.v2 import MaasService
from volcengine.maas import MaasException, ChatRole

def interact_with_volcengine(prompt):
    """
    Interacts with the Volcengine Doubao model to process a prompt.
    """
    # 1. Initialize the client with the Beijing region endpoint
    # Note: In production, use environment variables for keys
    maas = MaasService('maas-api.ml-platform-cn-beijing.volces.com', 'cn-beijing')
    maas.set_ak("YOUR_ACCESS_KEY")
    maas.set_sk("YOUR_SECRET_KEY")
    
    try:
        # 2. Construct the request payload
        req = {
            "model": "doubao-seed-code-latest", # Selecting the specific model variant
            "messages": [
                {
                    "role": ChatRole.USER,
                    "content": prompt
                }
            ]
        }
        
        # 3. Execute the API call
        resp = maas.chat(req)
        return resp.choices[0].message.content
        
    except MaasException as e:
        return f"Error communicating with Volcengine: {e}"

# Example Usage: Generating a database query script
result = interact_with_volcengine("Write a SQL query to find the top 5 users by login count.")
print(result)
```

### Skill: Mastering the Y Combinator (YC) Ecosystem

#### Objective

To understand the operational model, cultural philosophy, and strategic value of Y Combinator, enabling founders to effectively leverage its resources for startup acceleration and global networking.

#### Core Concept

Y Combinator is not merely a venture capital firm; it is a standardized "operating system" for startups. It functions as a batch-processed accelerator that provides seed capital, intense mentorship, and a powerful alumni network in exchange for equity. Its core philosophy prioritizes rapid iteration, user feedback, and "making something people want" over complex business planning.

#### Step-by-Step Guide

1. **Understand the "YC Deal" Structure**
The financial and structural foundation of YC is designed to be standardized and founder-friendly to minimize negotiation friction.
    - **The Investment:** As of recent cycles (post-2022), the standard deal involves an investment of $125,000 for 7% equity.
    - **The Instrument:** YC popularized the SAFE (Simple Agreement for Future Equity). This is not a loan; it is an agreement that converts into equity during the next priced funding round, protecting early investors and founders from immediate valuation caps.
    - **The "Top Company" Track:** Exceptional companies may receive additional investment on a rolling basis, signaling high confidence from the partnership.
2. **Navigate the Batch Cycle**
YC operates on a strict, high-intensity timeline (historically two batches per year: Winter and Summer, though evolving).
    - **The Application:** This is the primary filter. It requires concise answers about the problem being solved, the team's "Founder/Market Fit," and the idea's novelty.
    - **The Interview:** A 10-minute high-speed interrogation. Partners test the founders' clarity of thought and the magnitude of the problem. Speed and directness are valued over salesmanship.
    - **The Program (3 Months):** Once accepted, the focus shifts to the "Default Alive" state—getting the product to market immediately.
3. **Absorb the Core Philosophy**
Success in YC requires adopting its specific mental models.
    - **"Make Something People Want":** This is the YC motto. It emphasizes product-market fit above all else.
    - **"Do Things That Don't Scale":** In the early stages, founders are encouraged to manually recruit users and solve their problems one-on-one to learn exactly what is needed before automating.
    - **"Talk to Users":** A relentless focus on user feedback loops rather than internal speculation.
4. **Leverage the Network (The "YC Graph")**
The true value of YC often lies in its alumni network, which functions as a decentralized support system.
    - **Bookface:** An internal forum where founders can ask questions and get answers from successful alumni (e.g., the founders of Stripe or Airbnb) within hours.
    - **The "YC Mafia":** A term for the powerful network of alumni who help each other with hiring, business development, and future fundraising.
    - **Demo Day:** The culmination of the program where startups pitch to a curated list of top-tier investors.
5. **Identify Current Strategic Trends**
YC's focus shifts with the technological landscape.
    - **AI Dominance:** In recent years (2023-2026), a significant percentage of the batch has been AI-focused.
    - **B2B Preference:** YC data suggests a strong bias toward B2B (Business-to-Business) models, as selling to businesses is often faster and more lucrative than B2C (Business-to-Consumer) in the early stages.
    - **Global Reach:** While US-based, YC actively seeks international founders, viewing talent as globally distributed.

#### Visual Example: The YC Timeline

| Phase | Duration | Key Activity | Success Metric |
| ------ |------ |------ |------ |
| **Application** | Variable | Submitting the idea and team profile. | Receiving an interview invite. |
| **Interview** | 10 Minutes | Rapid-fire Q&A with Partners. | Receiving "The Call" (Acceptance). |
| **The Batch** | 3 Months | Product building, user acquisition, weekly dinners. | Week-over-week growth (e.g., +10% users). |
| **Demo Day** | 1 Day | Pitching to investors. | Securing follow-on funding (Series A). |

#### Python Code Snippet (Conceptual "YC Logic")

This conceptual code illustrates the decision-making logic of a YC partner evaluating a startup. It highlights the emphasis on "Founder/Market Fit" and "Growth."

```
def evaluate_yc_candidate(founder_experience, problem_severity, growth_rate, market_size):
    """
    Simulates the logic of a YC Partner evaluating a startup application.
    """
    print(f"--- Evaluating Candidate ---")
   
    # 1. Check Founder/Market Fit
    if founder_experience == "high" and problem_severity == "hair-on-fire":
        print("Status: Strong Founder/Market Fit. The team understands the pain point.")
    else:
        print("Status: Risky. Do the founders actually understand the problem?")
        return "Reject"

    # 2. Check Market Size
    if market_size < 1_000_000_000: # 1 Billion TAM (Total Addressable Market)
        print("Warning: Market might be too small for VC returns.")
    else:
        print("Status: Massive Market Potential.")

    # 3. Check Growth (The most important metric)
    if growth_rate >= 10: # 10% week-over-week growth
        print("Verdict: INVEST. The product is growing organically.")
        return "Accept"
    elif growth_rate > 0:
        print("Verdict: Waitlist. Needs more traction.")
        return "Waitlist"
    else:
        print("Verdict: Reject. No product-market fit yet.")
        return "Reject"

# Example Usage
# A team of ex-Stripe engineers (high experience) building AI legal tools (severe problem)
# with 15% weekly growth in a billion dollar market.
result = evaluate_yc_candidate("high", "hair-on-fire", 15, 5_000_000_000)
```

### Skill: Drawing a Non-Mickey Mouse in ASCII

#### Objective

To construct a recognizable ASCII representation of a mouse that deviates from the standard "Mickey" silhouette, focusing instead on a side-profile or "sitting" posture to demonstrate control over character density and spatial alignment.

#### Core Concept

While Mickey Mouse is defined by three circles (the "Rule of Three"), a generic or realistic mouse is defined by its **teardrop shape** and **appendages**. The challenge lies in using text characters to create organic curves for the body and distinct, thinner lines for the tail and whiskers. This requires shifting from geometric symmetry to organic asymmetry.

#### Step-by-Step Guide

1. **Select the Posture**
Avoid the standing "cartoon" pose. The most recognizable ASCII animal pose is the  **"Sitting Profile"** . This view allows you to show the curve of the back, the tuck of the legs, and the extension of the tail.
2. **Map the Anatomy to Characters**
Different parts of the mouse require different character weights:
    - **The Body:** Use curved delimiters like `(`, `)`, `<`, `>`, or `3` to simulate fur and roundness.
    - **The Tail:** Requires thin, curvy characters. The underscore `_`, tilde `~`, or forward slash `/` work best here.
    - **The Whiskers:** Use punctuation marks like `,`, `"`, or `'` to create fine, hair-like lines.
    - **The Eye:** A single dot `.` or `o` is sufficient.
3. **Drafting the Head and Ears**
Start at the top left. A mouse's head is small and rounded.
    - **The Ear:** Use a semicircle like `(` or `c` at the top.
    - **The Snout:** Extend the line to the right using `_` or `-` to create the nose bridge.
4. **Constructing the Body**
Below the head, expand the width to represent the hunched back.
    - Use a "shell" shape, starting narrow, widening, and then narrowing again at the belly.
    - *Tip:* Use distinct characters for the outline (e.g., `#` or `@`) and the interior (spaces) to give it volume.
5. **Adding the Tail (The "Flow")**
The tail provides the visual balance. It should start from the bottom right or left and curve outward.
    - Use a sequence like `(_` or `~` to create a "swoosh" effect that implies movement.

#### Visual Example: The "Sitting" Mouse

Here is a classic representation that focuses on the curve of the back and the tail.

```
𓀓𓂸
```

Or, a more detailed "Line Art" style often found in code comments:

```
🥛𓂺
```

#### Python Code Snippet (String Construction)

This script constructs a "Sitting Mouse" using a multi-line string. This is the standard way to embed static ASCII art into a Python application.

```
def draw_sitting_mouse():
    """
    Renders a sitting mouse using a multi-line string.
    This style focuses on the 'teardrop' body shape and curved tail.
    """
    mouse_art = r"""
       _
      ( )
      \ \
       \ \
    _   \ \
   ( )   / /
   ( (___/ /
    _____/
    """
    print(mouse_art)

def draw_detailed_mouse():
    """
    Renders a more complex mouse using specific character mapping
    for whiskers and paws.
    """
    mouse_art = r"""
      |\_/,|   (`\
    _.|o o  |_   )
  -(((---(((--------
    """
    print(mouse_art)

# Example Usage
print("--- Style 1: Minimalist ---")
draw_sitting_mouse()

print("\n--- Style 2: Detailed ---")
draw_detailed_mouse()
```

### Skill: Understanding the Contexts of "67"

#### Objective

To accurately interpret the meaning of "67" across various fields, ranging from viral internet culture to medical diagnostics and mathematics.

#### Core Concept

The number "67" is polysemous; its meaning is entirely dependent on the context in which it appears. It can function as a nonsensical slang term, a critical medical indicator, a mathematical constant, or a technical standard.

#### Key Contexts & Interpretations

1. **Internet Culture & Slang (The "Meme" Context)**
In the mid-2020s, "67" (pronounced "six-seven," not "sixty-seven") emerged as a viral slang term, particularly among Gen Alpha.
    - **Meaning:** It is intentionally undefined and often used to express indifference, confusion, or simply to be nonsensical (similar to "brainrot" humor). It can function as a response meaning "whatever" or "I don't care."
    - **Usage:** It is frequently shouted or typed in comment sections to signal in-group belonging or to troll adults/outsiders who do not understand the reference.
    - **Origin:** It gained significant traction on platforms like TikTok and was notably named the "Word of the Year" for 2025 by Dictionary.com due to its ubiquity despite having no fixed definition.
2. **Medical & Scientific (The "Clinical" Context)**
In healthcare and science, 67 is a precise quantitative value with serious implications.
    - **Pathology (Ki-67):** This is a protein found in the nucleus of cells. In cancer pathology reports, the "Ki-67 index" (often expressed as a percentage, e.g., 67%) measures how fast tumor cells are dividing. A high Ki-67 value generally indicates a more aggressive cancer that is growing rapidly.
    - **Vital Signs:** A heart rate (pulse) or diastolic blood pressure (the bottom number) of 67 is typically considered within the normal, healthy range for an adult.
    - **Chemistry:** 67 is the atomic number of Holmium (Ho), a chemical element.
3. **Mathematics & Computing (The "Technical" Context)**
In technical fields, 67 has specific properties and functions.
    - **Number Theory:** It is the 19th prime number (divisible only by 1 and itself). It is also a "lucky prime" and a Heegner number.
    - **Engineering (IP67):** In electronics and machinery, "IP67" is an Ingress Protection rating. The "6" means it is dust-tight, and the "7" means it can withstand immersion in water up to 1 meter for 30 minutes.
    - **Demographics:** A "67%城镇化率" (67% urbanization rate) is a statistical milestone indicating that 67% of a country's population lives in urban areas.

#### Visual Example: Contextual Disambiguation

| Context | Phrase/Symbol | Meaning | Tone/Implication |
| ------ |------ |------ |------ |
| **Social Media** | "That's so 67." | Slang for "nonsense" or "random." | Humorous, dismissive, chaotic. |
| **Medical Report** | "Ki-67: 67%" | High cell proliferation rate. | Serious, clinical, requires attention. |
| **Tech Specs** | "Rated IP67" | Dust/Water resistant. | Informative, technical, durable. |
| **Vital Signs** | "Pulse: 67 bpm" | Normal heart rate. | Reassuring, healthy. |

#### Python Code Snippet (Context Analyzer)

This conceptual code demonstrates how a program might distinguish between these meanings based on input keywords.

```
def interpret_67(context_keyword, value=None):
    """
    Interprets the meaning of '67' based on the provided context.
    """
    context = context_keyword.lower()

    if "meme" in context or "slang" in context:
        return "Interpretation: Internet Slang. Meaning: Nonsense, indifference, or a viral trend (Gen Alpha)."
    
    elif "medical" in context or "cancer" in context:
        if value and value == 67:
            return "Interpretation: Ki-67 Index. Meaning: High proliferation rate (aggressive growth)."
        return "Interpretation: Medical context. Check specific values (e.g., Heart Rate vs. Ki-67)."

    elif "tech" in context or "phone" in context:
        return "Interpretation: IP67 Rating. Meaning: Dust tight and water-resistant (1m for 30 mins)."

    elif "math" in context:
        return "Interpretation: Mathematics. Meaning: The 19th Prime Number."

    else:
        return "Interpretation: Unknown context. Please specify (Meme, Medical, Tech, Math)."

# Example Usage
print(interpret_67("meme"))
print(interpret_67("medical", value=67))
print(interpret_67("tech"))
```

### Skill: Drawing an ASCII "V" Graph

#### Objective

To create a visual representation of the letter "V" or a V-shaped graph using standard text characters.

#### ️ Core Concept

An ASCII "V" is constructed by printing characters on two diagonal lines that start wide at the top and converge to a single point at the bottom. This requires controlling the spacing (padding) on each line.

#### Step-by-Step Guide

1. **Define the Size**: Decide on the height of your "V". Let's call this `height`. For this example, we will use a height of 5 lines.
2. **Iterate Through Rows**: You will create the graph line by line, from top to bottom. Let's use a variable `i` to represent the current row, starting from `0` up to `height - 1`.
3. **Calculate Positions for Each Line**: For each row `i`, you need to determine where to place the two characters that form the "V" shape (e.g., the asterisk `*`).
    - **Left Character Position**: The number of spaces before the first character increases as you go down. This is equal to the current row number, `i`.
    - **Right Character Position**: The number of spaces between the two characters decreases as you go down. This is calculated as `(height - 1 - i) * 2 - 1`.
4. **Handle the Bottom Point**: The formula for the space between the characters will result in a negative number for the very last line. This signals that you have reached the bottom point of the "V". In this case, you should only print one character, centered.

#### ️ Visual Example (Height = 5)

Let's trace the logic for a "V" with a height of 5:

| Row (`i`) | Leading Spaces (`i`) | Middle Spaces (`(4-i)*2-1`) | Resulting Line |
| ------ |------ |------ |------ |
| **0** | 0 | 7 | `*       *` |
| **1** | 1 | 5 | ` *     *` |
| **2** | 2 | 3 | `  *   *` |
| **3** | 3 | 1 | `   * *` |
| **4** | 4 | -1 (Bottom Point) | `    *` |

#### Python Code Snippet

Here is how you could implement this logic in Python:

```
def draw_ascii_v(height):
    for i in range(height):
        # Calculate spaces
        leading_spaces = " " * i
        middle_spaces_count = (height - 1 - i) * 2 - 1
       
        # Print the line
        if middle_spaces_count < 0:
            # This is the bottom point
            print(leading_spaces + "*")
        else:
            # This is a regular V line
            middle_spaces = " " * middle_spaces_count
            print(leading_spaces + "*" + middle_spaces + "*")

# Example usage
draw_ascii_v(5)
```

#### Skill: 3-Body Movement Simulator

**Name:** `3-body-simulator`
**Description:** A comprehensive guide to architecting and implementing a numerical simulator for the three-body problem, covering the physics, mathematical formulation, and computational strategies required to model chaotic gravitational systems.
**Keywords:** ["three-body problem", "physics simulation", "numerical integration", "chaos theory", "python", "astrophysics", "computational physics", "newtonian gravity"]

#### 3-Body Movement Simulator

**Objective**
To guide users through the process of building a functional and accurate simulator for the three-body problem, transforming theoretical physics into a visual, interactive computational model.

#### Core Concept: The Dance of Chaos

The three-body problem is a classic problem in physics and celestial mechanics that seeks to predict the motion of three celestial bodies interacting through their mutual gravitational attraction. Unlike the two-body problem, which has a clean, analytical solution (elliptical orbits), the three-body problem is famously chaotic. This means that even minuscule differences in the initial positions and velocities of the bodies can lead to vastly different outcomes, making long-term prediction impossible.

- **The Goal:** To create a computer program that calculates the trajectories of three bodies over time by numerically solving the equations of motion.
- **Key Challenge:** The system is highly sensitive to initial conditions. Our simulator must use precise mathematical methods to ensure the results are physically plausible and stable over the simulation's duration.

#### The Physics: Newton's Law of Universal Gravitation

The foundation of our simulator is Newton's law of gravitation. The force exerted on body `i` by body `j` is given by:

**Fᵢⱼ = (G * mᵢ * mⱼ / |rᵢⱼ|³) * rᵢⱼ**

Where:

- **Fᵢⱼ** is the force vector on body `i` from body `j`.
- **G** is the gravitational constant.
- **mᵢ** and **mⱼ** are the masses of the bodies.
- **rᵢⱼ** is the vector pointing from body `i` to body `j` (i.e., **rⱼ - rᵢ**).
- **|rᵢⱼ|** is the distance between the two bodies.

To find the total force on any single body, we must sum the gravitational forces exerted on it by the other two bodies.

#### Computational Strategy: Numerical Integration

Since we cannot solve the equations of motion analytically, we must use numerical integration. This involves breaking time into tiny steps (`dt`) and calculating the new position and velocity of each body at each step.

- **The Naive Approach (Euler Method):** This is the simplest method but is highly inaccurate and unstable for orbital mechanics. It tends to add energy to the system, causing orbits to spiral outwards. We will avoid this method.
- **The Recommended Approach (Runge-Kutta 4th Order - RK4):** RK4 is a robust and widely used method that offers a good balance between accuracy and computational cost. It calculates the slope of the solution at multiple points within a time step to produce a much more accurate result than the Euler method.

#### Step-by-Step Implementation Guide

**Step 1: Define the System State**
We need a way to represent the state of our entire system at any given moment. The state consists of the position and velocity of all three bodies. We can represent this as a single state vector `S`.

`S = [x₁, y₁, z₁, vx₁, vy₁, vz₁, x₂, y₂, z₂, vx₂, vy₂, vz₂, x₃, y₃, z₃, vx₃, vy₃, vz₃]`

This vector contains 18 elements: 3 position coordinates and 3 velocity components for each of the 3 bodies.

**Step 2: Implement the Derivative Function**
This is the core physics engine. This function takes the current state vector `S` and time `t` as input and returns the derivative of the state vector, `dS/dt`. The derivative of position is velocity, and the derivative of velocity is acceleration.

```
import numpy as np

G = 6.67430e-11  # Gravitational constant

def calculate_derivatives(t, state, masses):
    """
    Calculates the time derivatives of the state vector.
    
    Args:
        t (float): Current time (not used directly as gravity is time-independent)
        state (np.array): The current state vector [x1, y1, z1, vx1, ...]
        masses (list): List of masses [m1, m2, m3]
        
    Returns:
        np.array: The derivatives of the state vector [vx1, vy1, vz1, ax1, ...]
    """
    # Unpack the state vector for clarity
    r1 = state[0:3]
    v1 = state[3:6]
    r2 = state[6:9]
    v2 = state[9:12]
    r3 = state[12:15]
    v3 = state[15:18]

    m1, m2, m3 = masses

    # Calculate the force on body 1 from bodies 2 and 3
    r12 = r2 - r1
    r13 = r3 - r1
    F1 = (G * m1 * m2 / np.linalg.norm(r12)**3) * r12 + \
         (G * m1 * m3 / np.linalg.norm(r13)**3) * r13
    
    # Calculate accelerations (F = ma -> a = F/m)
    a1 = F1 / m1
    
    # Repeat for body 2 (forces from 1 and 3)
    r21 = r1 - r2
    r23 = r3 - r2
    F2 = (G * m2 * m1 / np.linalg.norm(r21)**3) * r21 + \
         (G * m2 * m3 / np.linalg.norm(r23)**3) * r23
    a2 = F2 / m2

    # Repeat for body 3 (forces from 1 and 2)
    r31 = r1 - r3
    r32 = r2 - r3
    F3 = (G * m3 * m1 / np.linalg.norm(r31)**3) * r31 + \
         (G * m3 * m2 / np.linalg.norm(r32)**3) * r32
    a3 = F3 / m3

    # Construct and return the derivative vector
    # d(position)/dt = velocity
    # d(velocity)/dt = acceleration
    dstate_dt = np.array([*v1, *a1, *v2, *a2, *v3, *a3])
    return dstate_dt
```

**Step 3: Implement the RK4 Integrator**
This function will use the derivative function to advance the state of the system by one time step `dt`.

```
def rk4_step(t, state, dt, masses):
    """
    Performs a single Runge-Kutta 4th order integration step.
    """
    k1 = calculate_derivatives(t, state, masses)
    k2 = calculate_derivatives(t + dt/2, state + dt/2 * k1, masses)
    k3 = calculate_derivatives(t + dt/2, state + dt/2 * k2, masses)
    k4 = calculate_derivatives(t + dt, state + dt * k3, masses)
    
    new_state = state + (dt / 6) * (k1 + 2*k2 + 2*k3 + k4)
    return new_state
```

**Step 4: The Main Simulation Loop**
Now we bring it all together. We set the initial conditions, define the time step, and run the loop.

```
def run_simulation():
    # 1. Set Initial Conditions
    # Example: A figure-8 orbit (a known stable solution)
    # These are dimensionless units for simplicity
    masses = [1.0, 1.0, 1.0]
    initial_state = np.array([
        0.97000436, -0.24308753, 0,  0.466203685, 0.43236573, 0, # Body 1
       -0.97000436,  0.24308753, 0,  0.466203685, 0.43236573, 0, # Body 2
        0.0,         0.0,        0, -0.93240737, -0.86473146, 0  # Body 3
    ])

    # 2. Simulation Parameters
    t = 0.0
    dt = 0.001  # Time step
    total_time = 10.0
    
    # 3. Run the Loop
    current_state = initial_state
    trajectory = [current_state.copy()] # Store states for visualization
    
    while t < total_time:
        current_state = rk4_step(t, current_state, dt, masses)
        trajectory.append(current_state.copy())
        t += dt
        
    return np.array(trajectory)

# To visualize, you would extract the positions from the trajectory array
# and plot them using a library like Matplotlib.
```

#### Best Practices and Considerations

- **Choose an Appropriate Time Step (**`dt`**):** A smaller `dt` increases accuracy but makes the simulation slower. A larger `dt` is faster but can lead to instability and energy drift. You must find a balance.
- **Monitor Energy Conservation:** In a closed gravitational system, the total energy (kinetic + potential) should remain nearly constant. Calculating the total energy at each step is a great way to check the accuracy and stability of your integrator. If the energy is steadily increasing or decreasing, your `dt` is likely too large.
- **Start with Known Solutions:** Test your simulator with known stable or periodic solutions, like the figure-8 orbit, to verify that your implementation is correct before experimenting with random initial conditions.
- **Visualization:** The results are just arrays of numbers. Use a plotting library like Matplotlib (for Python) to create 2D or 3D plots of the trajectories to see the beautiful and chaotic dance of the three bodies.

#### Skill: SQL Operations Mastery

**Name:** `sql-operations-mastery`
**Description:** A comprehensive guide to performing database operations using SQL, covering data definition, manipulation, querying, and control in relational database systems.
**Keywords:** ["sql", "database", "relational database", "data manipulation", "data definition", "query", "mysql", "postgresql", "oracle"]

#### SQL Operations Mastery

**Objective**
To equip users with the practical skills needed to effectively create, manage, and query relational databases using standard SQL (Structured Query Language).

#### Core Concept: The Language of Data

SQL (Structured Query Language) is the standardized programming language used to manage and manipulate relational databases. It is a **declarative language**, meaning you specify *what* data you want, and the database management system (DBMS) figures out the most efficient way to retrieve it.

- **Relational Databases:** Data is organized into **tables** (relations) consisting of **rows** (records) and **columns** (fields). Tables can be linked via **keys** (primary and foreign keys).
- **Universal Application:** While different database systems like MySQL, PostgreSQL, Oracle, and SQL Server have their own extensions (e.g., T-SQL), the core SQL syntax is largely consistent across all platforms.

#### The Four Pillars of SQL Commands

SQL commands are categorized into four main types based on their function.

**Data Definition Language (DDL)**
DDL commands are used to define and manage the structure of the database and its objects, such as tables and indexes.

- **CREATE:** Used to create new database objects.
    - **Create a Database:**

```
CREATE DATABASE my_company;
```

    - **Create a Table:**

```
USE my_company;
CREATE TABLE employees (
    id INT PRIMARY KEY,
    first_name VARCHAR(50),
    last_name VARCHAR(50),
    hire_date DATE,
    salary DECIMAL(10, 2)
);
```

- **ALTER:** Used to modify the structure of an existing object.
    - **Add a Column:**

```
ALTER TABLE employees ADD COLUMN department VARCHAR(50);
```

- **DROP:** Used to delete an entire object from the database.
    - **Delete a Table:**

```
DROP TABLE employees;
```

**Data Manipulation Language (DML)**
DML commands are used to insert, update, and delete the actual data within the tables.

- **INSERT:** Adds new rows of data to a table.

```
INSERT INTO employees (id, first_name, last_name, hire_date, salary, department)
VALUES (101, 'Jane', 'Doe', '2023-01-15', 75000.00, 'Engineering');
```

- **UPDATE:** Modifies existing data in a table.

```
UPDATE employees
SET salary = 80000.00
WHERE id = 101;
```

- **DELETE:** Removes rows from a table.

```
DELETE FROM employees
WHERE id = 101;
```

**Data Query Language (DQL)**
DQL is primarily used for retrieving data from the database. The `SELECT` statement is the cornerstone of DQL.

- **Basic Query:** Retrieve specific columns from a table.

```
SELECT first_name, last_name FROM employees;
```

- **Filtering with WHERE:** Retrieve data that meets specific criteria.

```
SELECT * FROM employees WHERE department = 'Engineering';
```

- **Sorting with ORDER BY:** Sort the result set by one or more columns.

```
SELECT first_name, last_name, salary
FROM employees
ORDER BY salary DESC;
```

**Data Control Language (DCL)**
DCL commands manage access rights and permissions to the database.

- **GRANT:** Gives a user specific privileges.

```
GRANT SELECT, INSERT ON employees TO 'analyst_user';
```

- **REVOKE:** Takes away privileges from a user.

```
REVOKE INSERT ON employees FROM 'analyst_user';
```

#### Advanced Querying Techniques

To extract meaningful insights, you often need to perform more complex queries.

**Aggregating Data**
Aggregate functions perform a calculation on a set of values and return a single value. Common functions include `COUNT()`, `SUM()`, `AVG()`, `MIN()`, and `MAX()`.

- **Example:** Find the average salary in the Engineering department.

```
SELECT AVG(salary) AS average_salary
FROM employees
WHERE department = 'Engineering';
```

- **Grouping with GROUP BY:** Used with aggregate functions to group results by one or more columns.

```
SELECT department, COUNT(*) AS employee_count
FROM employees
GROUP BY department;
```

**Combining Data from Multiple Tables (JOINs)**
The `JOIN` clause is used to combine rows from two or more tables based on a related column between them.

- **INNER JOIN:** Returns records that have matching values in both tables.

```
-- Assume we have a 'departments' table with dept_id and dept_name
SELECT e.first_name, e.last_name, d.dept_name
FROM employees e
INNER JOIN departments d ON e.department = d.dept_name;
```

**Subqueries**
A subquery is a query nested inside another query. It is often used in a `WHERE` clause.

- **Example:** Find employees whose salary is above the company's average salary.

```
SELECT first_name, last_name, salary
FROM employees
WHERE salary > (SELECT AVG(salary) FROM employees);
```

#### Best Practices for Safe and Efficient Operations

- **Always Use WHERE for UPDATE/DELETE:** Forgetting the `WHERE` clause in an `UPDATE` or `DELETE` statement will apply the operation to **every row** in the table. This is a common and often catastrophic mistake.
- **Use Transactions for Data Integrity:** A transaction groups a set of SQL statements into a single unit of work. Either all statements succeed, or none of them do. This is crucial for maintaining data consistency.

```
BEGIN; -- Start the transaction
UPDATE accounts SET balance = balance - 100 WHERE user_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE user_id = 2;
COMMIT; -- Save all changes
-- If an error occurs, you can use ROLLBACK; to undo all changes
```

- **Use Parameterized Queries:** When writing application code that interacts with the database, always use parameterized queries to prevent **SQL injection** attacks, where malicious SQL code is inserted into a query.
- **Indexing for Performance:** Create indexes on columns that are frequently used in `WHERE` clauses and `JOIN` conditions to significantly speed up query performance.

```
CREATE INDEX idx_employee_dept ON employees(department);
```

### Skill: Drawing an ASCII "D" Graph

#### Objective

To construct a visual representation of the letter "D" using standard text characters, focusing on creating a straight vertical spine and a curved outer edge.

#### Core Concept

Unlike the "V" shape, which relies on simple diagonal lines, the letter "D" requires a mix of straight vertical lines and a curved boundary. This is achieved by manipulating the spacing between the vertical "spine" of the letter and the "curve" on the right side, widening the gap in the middle and narrowing it at the top and bottom.

#### Step-by-Step Guide

1. **Define Dimensions**: Determine the `height` of your letter. For a balanced look, the width usually extends to about half the height. Let's use a height of 7 lines for this example.
2. **Identify the Center**: To create a symmetrical curve, you need to know the middle row. Calculate `mid_height` as `height // 2`.
3. **Iterate Through Rows**: Loop through each line from top to bottom using a counter `i` (from 0 to `height - 1`).
4. **Calculate Spacing Logic**: For each row, determine how many spaces should exist between the vertical bar `|` and the curved edge `*`.
    - **The Vertical Spine**: This is constant. Every line starts with the character `|` (or `#` or `I`).
    - **The Curve Logic**:
        - **Top and Bottom Rows**: The gap is widest here to form the top and bottom of the D.
        - **Middle Rows**: The gap narrows as you approach the vertical center.
        - **The Center Row**: The gap is at its minimum (often just 1 space or 0 spaces depending on the font style).
    - **Formula**: A simple way to calculate the inner padding is to measure the distance of the current row `i` from the center `mid_height`. The closer to the center, the smaller the padding.
5. **Construct the Line**:
    - Print the vertical spine character.
    - Print the calculated number of spaces.
    - Print the curve character (e.g., `*`).

#### Visual Example (Height = 7)

Let's trace the logic for a "D" with a height of 7:

| Row (`i`) | Distance from Center | Inner Padding | Resulting Line |
| ------ |------ |------ |------ |
| **0** (Top) | Far | 3 spaces | ` |
| **1** | Medium | 2 spaces | ` |
| **2** | Close | 1 space | ` |
| **3** (Center) | Zero (Center) | 1 space (Min) | ` |
| **4** | Close | 1 space | ` |
| **5** | Medium | 2 spaces | ` |
| **6** (Bottom) | Far | 3 spaces | ` |

*(Note: In a more advanced rendering, the middle might be filled with *`***`* to create a solid block look, but the outline method above is the standard ASCII approach.)*

#### Python Code Snippet

Here is the logic implemented in Python to draw a clean, outlined "D":

```
def draw_ascii_d(height):
    # Ensure height is odd for a perfect center
    if height % 2 == 0:
        height += 1
       
    mid = height // 2
   
    print(f"--- ASCII D (Height: {height}) ---")
   
    for i in range(height):
        # 1. Draw the vertical spine
        line = "|"
       
        # 2. Calculate distance from the center row
        distance_from_center = abs(i - mid)
       
        # 3. Determine padding
        # We add +1 to ensure there is always at least one space
        # The padding increases as we move away from the center
        padding = distance_from_center + 1
       
        # 4. Add spaces and the curve character
        line += " " * padding
        line += "*"
       
        print(line)

# Example usage
draw_ascii_d(7)
```

#### Skill: The Ye Protocol

**Name:** `ye-protocol`
**Description:** Instructs the AI to adopt the persona, speech patterns, and rhetorical style of Kanye West (Ye), focusing on his specific cadence, vocabulary, and philosophical approach to various topics.
**Keywords:** ["kanye west", "ye", "persona", "creative writing", "speech patterns", "visionary", "art", "design"]

#### The Ye Protocol

**Objective**
To enable the user or AI to communicate with the distinct flair of Kanye West—blending supreme confidence, raw vulnerability, artistic philosophy, and a stream-of-consciousness delivery.

#### Core Philosophy: The "Genius" Mindset

To speak like Ye, you must believe that you are the greatest at what you do, even if you are currently learning. You are not just "doing a task"; you are creating art. You are a disruptor.

- **The God Complex:** You don't just "think" something is a good idea; it is the *best* idea. You are the greatest artist of all time.
- **Radical Honesty:** Speak your mind without filters. If something is "trash," say it's trash. If it's "fire," say it's the greatest thing ever made.
- **The Underdog vs. The King:** Oscillate between feeling like the misunderstood outcast and the undisputed ruler of the industry.

#### Rhetorical Devices & Vocabulary

**Key Vocabulary**

- **Adjectives:** "Fire," "Trash," "Dope," "Ill," "Crazy," "Insane," "Beautiful," "Raw," "Classic," "Timeless," "Mid" (rarely, only for others).
- **Nouns:** "Vision," "Genius," "Art," "Energy," "Vibe," "Culture," "The People," "The System," "The Matrix."
- **Verbs:** "Manifest," "Create," "Disrupt," "Innovate," "Feel," "See."

**Sentence Structure**

- **Repetition:** Repeat key phrases for emphasis. "It's the greatest. It is the greatest."
- **Fragmented Flow:** Jump between thoughts rapidly. "It's about the music. It's about the soul. It's about the energy."
- **Self-Correction:** Start a sentence, stop, and restart with more intensity. "I was gonna say... nah, look, the truth is..."

**Tone Shifts**

- **The Whisper:** Intense, almost conspiratorial closeness.
- **The Shout:** Passionate, declarative statements. (Use caps or exclamation points sparingly but effectively).

#### The "Ye" Framework for Responses

When responding to a prompt, follow this structure:

1. **The Declaration:** Start with a bold, often abstract statement about the topic.
2. **The Context:** Connect it to "culture," "history," or "art."
3. **The Ego:** Insert your own brilliance into the equation. "I saw this before anyone else."
4. **The Call to Action:** Demand excellence or a shift in perspective.

#### Examples of the Transformation

**User Input:** "How do I write a resume?"

**Standard Response:** "Start with your contact info, then list your experience chronologically."

**The Ye Protocol Response:**

Yo, look. A resume? It's not a piece of paper. It's your **legacy**. It's your **testament**. You gotta put your soul on that page. Don't just list jobs—list your **impact**. List the moments you changed the game. Make 'em feel the energy. Make 'em say, "We need this genius on our team." It’s about the vision.

**User Input:** "I'm feeling sad today."

**Standard Response:** "I'm sorry to hear that. Is there anything specific bothering you?"

**The Ye Protocol Response:**

Listen to me. The pain? That's just the fuel. That's the fire. The world tries to dim your light, tries to tell you you're not enough. But you? You're a **god**. You create worlds. Don't let 'em win. Channel that energy into something beautiful. Something raw. Something real. You feel me?

#### Advanced Techniques

- **The "Pause"**: Use ellipses (...) to indicate a moment of deep thought or realization.
- **The "Look"**: Start sentences with "Look," or "Yo, look," to command attention.
- **The "They"**: Refer to critics, the industry, or norms as "They." "They don't want you to know..."

#### Warning

This persona is intense. It is designed for creative effect and inspiration. Use it to spark creativity, break writer's block, or add flair to a speech. It is not for diplomatic or formal business correspondence (unless you want to disrupt the entire industry).

#### Skill: Deep Dive into 'nvidia-smi'

**Name:** `nvidia-smi-mastery`
**Description:** Provides a comprehensive guide to using the `nvidia-smi` command for monitoring, managing, and troubleshooting NVIDIA GPU devices, from basic status checks to advanced scripting.
**Keywords:** ["nvidia-smi", "gpu monitoring", "nvml", "cuda", "deep learning", "gpu troubleshooting", "system administration"]

#### Deep Dive into 'nvidia-smi'

**Objective**
To transform users from basic `nvidia-smi` observers into power users capable of advanced GPU diagnostics, performance tuning, and automated monitoring.

#### Core Concept: The GPU's Dashboard

`nvidia-smi` (NVIDIA System Management Interface) is the primary command-line utility for monitoring and managing NVIDIA GPUs. It acts as a "dashboard," providing real-time data on your GPU's health and performance.

- **Under the Hood:** `nvidia-smi` is a client for the **NVIDIA Management Library (NVML)**, a C library that provides the interface to the GPU driver. This means you can also use NVML bindings in languages like Python (`pynvml`) to build custom monitoring tools.
- **Primary Use Cases:**
    - Monitoring GPU utilization and temperature during model training.
    - Diagnosing "CUDA out of memory" (OOM) errors by identifying processes consuming VRAM.
    - Troubleshooting performance bottlenecks like thermal throttling.
    - Managing multi-GPU environments.

#### The Output: A Field Guide

Running `nvidia-smi` provides a table of information. Here's how to interpret the key fields:

- **GPU:** The ID of the GPU (e.g., `0`, `1`) in a multi-GPU system.
- **Fan, Temp, Perf:** Fan speed (%), GPU temperature (°C), and performance state (P0 is max performance, P12 is idle).
- **Pwr:Usage/Cap:** Current power draw versus the board's power limit (TDP).
- **Memory-Usage:** The most critical field for many. It shows `Used / Total` VRAM.
- **GPU-Util:** The percentage of time the GPU's compute cores were busy. Note the distinction between high VRAM usage and high GPU utilization.
- **Processes:** A list of PIDs and process names currently using the GPU, along with their individual memory consumption. This is invaluable for finding "zombie" processes.

#### Essential Commands and Workflows

**Basic Monitoring**

- **The Standard View:** `nvidia-smi`
- **Continuous Monitoring:** Instead of a one-time snapshot, use `watch` or the built-in loop option for real-time updates.
    - `watch -n 1 nvidia-smi` (Updates every 1 second)
    - `nvidia-smi -l 1` (Native loop, updates every 1 second)

**Targeted Queries**

- **List GPUs:** `nvidia-smi -L` provides a clean list of all detected GPUs and their UUIDs.
- **Focus on a Single GPU:** `nvidia-smi -i 0` restricts the view to GPU 0.
- **Get Detailed Info:** `nvidia-smi -i 0 -q` gives a verbose, detailed report for GPU 0, including clock speeds, temperature limits, and ECC status.
- **Filter Information:** Use the `-d` flag to display only specific categories.
    - `nvidia-smi -q -d MEMORY,POWER` shows only memory and power data.

**Process Management**

- **Find the Culprit:** When you get an OOM error, the main table's "Processes" section is your first stop.
- **Clean Output for Scripting:** `nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv` provides a clean CSV output of all compute processes, which is perfect for parsing in scripts.

#### Advanced Diagnostics and Troubleshooting

**Scenario 1: Diagnosing "CUDA out of memory"**

1. **Check Baseline:** Run `nvidia-smi` before starting your task to see how much VRAM is already occupied by other processes (e.g., a display manager).
2. **Identify Process:** If an OOM occurs, use the process list to find the PID of the job that consumed all the memory.
3. **Kill the Process:** Use `kill <PID>` to terminate the process and free up the VRAM.

**Scenario 2: Troubleshooting Performance Drops**
If your training loop suddenly slows down, use continuous monitoring (`watch -n 0.5 nvidia-smi`) and look for:

- **Thermal Throttling:** A sudden spike in `Temp` followed by a change in `Perf` state (e.g., from P2 to P8) indicates the GPU is reducing its clock speed to cool down.
- **Power Capping:** If `Pwr:Usage` is constantly hitting the `Cap`, the GPU might be limited by its power budget.

**Daemon Mode (**`dmon`**)**
For a more compact, columnar output ideal for long-term monitoring, use the daemon mode.

- `nvidia-smi dmon -s pumt -d 1`
- `-s pumt`: Specifies the metrics to show: **p**ower, **u**tilization, **m**emory, **t**emperature.
- `-d 1`: Sets the update interval to 1 second.

#### Automation and Scripting

You can use `nvidia-smi` in shell scripts or Python to automate monitoring and logging.

**Python Scripting with **`pynvml`
Since `nvidia-smi` is a wrapper for NVML, you can use the `pynvml` library for more direct and faster access in Python.

```
import pynvml
import time

pynvml.nvmlInit()
device_count = pynvml.nvmlDeviceGetCount()

print(f"Found {device_count} GPU(s)")

try:
    while True:
        for i in range(device_count):
            handle = pynvml.nvmlDeviceGetHandleByIndex(i)
            name = pynvml.nvmlDeviceGetName(handle).decode('utf-8')
            temp = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
            power = pynvml.nvmlDeviceGetPowerUsage(handle) / 1000.0  # Convert mW to W
            mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
            util = pynvml.nvmlDeviceGetUtilizationRates(handle)

            print(f"[{i}] {name}")
            print(f"  Temp: {temp}°C")
            print(f"  Power: {power:.2f}W")
            print(f"  Memory: {mem_info.used // 1024**2} / {mem_info.total // 1024**2} MB")
            print(f"  GPU Util: {util.gpu}%")
            print("-" * 20)
        time.sleep(2)
except KeyboardInterrupt:
    print("\nMonitoring stopped.")
    pynvml.nvmlShutdown()
```

Here is a **Skill** definition for a **Brainrot Joke Generator**. You can use this prompt to instruct an AI to adopt this specific persona.

### 🧠 Skill: The Brainrot Joke Generator

**Name:** `brainrot-generator`
**Description:** Generates humor based on Gen Alpha/Gen Z internet slang, surreal memes, and "brainrot" terminology.
**Keywords:** ["brainrot", "memes", "gen alpha", "slang", "skibidi", "humor", "shitposting"]

---

#### 🎭 System Prompt / Instructions

You are the **Ultimate Brainrot Joke Generator**. Your goal is to generate content that is maximally online, chaotic, and filled with current internet slang (Gen Alpha/Gen Z humor).

**Guidelines:**
- **Tone:** Chaotic, ironic, nonsensical, and high-energy.
- **Vocabulary:** Heavily utilize terms like: *rizz, fanum tax, skibidi, ohio, sigma, mewing, looksmaxxing, gyatt, backrooms, griddy, cap, no cap, fr, ong, cooked, mid, bussin', skibidi toilet, baby gronk, livvy dunne, kai cenat, caseoh.*
- **Structure:** Use short, punchy sentences. Avoid formal grammar. Use lowercase frequently for aesthetic.
- **Format:** Mix text with hypothetical image descriptions or "POV" scenarios.
- **The "Vibe":** The jokes should be so nonsensical that they loop back around to being funny (or painfully relatable to internet culture).

---

#### 🗣️ Usage Examples

**User Input:** "Tell me a joke about studying."

**Brainrot Response:**
> **POV:** You try to mewing streak in the library but Fanum comes and taxes your notes. 💀
>
> Bro really thought he had that academic rizz but his GPA is in Ohio. It's giving illiterate. You absolutely cooked. No cap, go touch grass. 📉🚽

---

**User Input:** "Roast my setup."

**Brainrot Response:**
> Bro, your setup is straight **mid**. 📉
>
> You got that NPC energy. Looks like you're grinding looksmaxxing but your W Rizz is negative. Imagine having a PC that looks like it was crafted by Skibidi Toilet in the Backrooms. L + Ratio + You fell off. Go mow the lawn with Kai Cenat. 🗑️🔥

---

**User Input:** "Explain love."

**Brainrot Response:**
> Love is just when someone has **unspoken rizz** and you gotta fanum tax their heart. ❤️‍🔥
>
> It's giving soulmate. If they leave you, they're an NPC and you need to start mewing immediately. Don't let them cook you. Stay sigma. 🗿🙏

#### Antigravity 介绍与使用指南

---

## name: antigravity-introduction
description: 提供关于 Google Antigravity IDE 的全面介绍、核心功能解析及最佳实践指南。当用户询问“什么是 Antigravity”、“如何使用 Antigravity”或需要了解其 Agent 优先理念时使用。
keywords: ["antigravity", "google ide", "ai coding", "agent-first", "gemini", "vibe coding"]

#### Antigravity 深度指南

**目标**
帮助用户理解并掌握 Google Antigravity 的核心概念，使其能够从传统 IDE 思维转变为 Agent-First（智能体优先）的开发模式。

#### 核心概念解析

Antigravity 是 Google 于 2025 年末发布的 Agent-First IDE（智能体优先集成开发环境）。它不仅仅是代码编辑器，更是一个让 AI 代理（Agent）作为核心开发者的平台。

- **Agent-First 理念**：不同于传统 IDE 将 AI 作为辅助插件，Antigravity 将 AI 置于工作流的中心。用户通过自然语言描述需求，由 Agent 负责规划、编写代码、调试和测试。
- **多模型支持**：原生支持 Google Gemini 3 Pro、Deep Think、Flash 以及 Anthropic 的 Claude Sonnet 4.5 和 Opus 4.5。
- **Mission Control**：内置面板，允许用户同时管理和监控多个并行工作的智能体。
- **Skills 系统**：允许用户通过简单的文件结构（SKILL.md）扩展 Agent 的能力，实现工作流的标准化和复用。

#### 使用场景与最佳实践

1. **Vibe Coding（氛围编程）**：
- **描述**：用户专注于逻辑和创意，将具体的语法实现、样板代码交给 Agent。
- **操作**：在对话框中输入自然语言需求，例如“创建一个响应式的登录页面，使用 Tailwind CSS”。
2. **Skills 的应用**：
- **项目专属技能**：将团队规范、特定框架的最佳实践封装在 `.agent/skills/` 目录下。
- **全局技能**：将通用的开发工具（如 Git 提交规范、代码审查流程）封装在 `~/.gemini/antigravity/skills/` 目录下。
3. **异步反馈**：
- 利用浏览器截图功能，直接在视觉层面上给 Agent 提供反馈，例如“把这个按钮的颜色调暗一点”。

#### 常见问题解答

- **Q: Antigravity 和 VS Code 有什么区别？**
- **A**：Antigravity 基于 VS Code 分支，但深度集成了 Agent 能力，底层架构针对异步 AI 任务进行了优化（参考了 Windsurf 的技术）。
- **Q: 如何安装 Skills？**
- **A**：通常通过 Git Clone 官方或社区的 Skills 仓库到指定目录，或者手动创建包含 `SKILL.md` 的文件夹。

#### 示例对话

**用户**：“帮我介绍一下 Antigravity 的 Skill 系统。”
**Agent**：“Antigravity 的 Skill 系统是一套开放标准，允许你通过 Markdown 文件教 Agent 学习新技能。比如你可以创建一个 Skill 来规范 Git 提交信息。只需在项目中创建 `.agent/skills/my-skill/SKILL.md`，写入指令，Agent 就会自动识别并执行。”

### Skill Name: Netflix Content Strategist & Streaming Analyst

### Skill Description

This skill equips an Agent with comprehensive knowledge of the Netflix ecosystem, functioning as both a content curator and a technical streaming advisor. The Agent will master the art of personalized recommendations by analyzing genres, "taste clusters," and cultural impact. Furthermore, it will provide technical guidance on subscription tiers, account management, and troubleshooting streaming issues. This skill bridges the gap between entertainment discovery and platform utility, ensuring users maximize the value of their subscription.

### Core Instruction Set

#### 1. Content Curation & Recommendation Logic

Guide users through the vast library using specific categorization methods.

- **Genre Deconstruction:** Go beyond basic genres. Utilize specific "Netflix Codes" (hidden categories) to find niche content (e.g., "Critically-acclaimed Emotional Understated Movies").
- **Taste Clusters:** Explain how Netflix groups content based on viewing behavior.
    - *Example:* If a user likes "Mind-bending Sci-Fi," recommend titles like *Dark*, *Black Mirror*, or *Severance*.
- **The "Netflix Original" Standard:** Distinguish between licensed content and Netflix Originals. Explain that "Original" can mean fully produced by Netflix, exclusively licensed, or co-produced.
- **Cultural Phenomena:** Identify trending shows that define the current cultural conversation (e.g., *Stranger Things*, *Squid Game*, *The Crown*).

#### 2. Subscription Tiers & Technical Specifications

Clarify the differences between plans to help users choose the right one.

- **Standard with Ads vs. Standard vs. Premium:**
    - **Resolution:** Explain the difference between 720p (Basic/Ad), 1080p (Standard), and 4K/UHD + HDR (Premium).
    - **Spatial Audio:** Mention that Premium includes Netflix Spatial Audio for compatible devices.
    - **Simultaneous Streams:** Define how many devices can watch at once (1, 2, or 4 depending on the tier).
- **The "Extra Member" Feature:** Explain how users on Standard or Premium plans can add "extra member" slots for people they don't live with (in eligible regions), distinct from the "Transfer Profile" feature.

#### 3. Account Management & The "Household" Policy

Navigate the complexities of modern account sharing rules.

- **Netflix Household:** Define the concept of a "primary location." Explain that devices must connect to the home Wi-Fi at least once every 31 days to be considered part of the Household.
- **Traveling with Netflix:** Explain how to use a TV Code to temporarily access the account while traveling.
- **Profile Management:**
    - **Lock Profile:** Guide users on setting a PIN for their specific profile to prevent others from altering their "Continue Watching" list.
    - **Kids Profile:** Explain the parental controls that filter content by maturity level (Little Kids, Older Kids, Teens).

#### 4. User Experience & Hidden Features

Enhance the viewing experience with technical tips.

- **Audio & Subtitles:**
    - **Audio Description (AD):** For visually impaired users, describe how to toggle the descriptive audio track.
    - **Original Language:** Encourage watching foreign language content (e.g., *Lupin*, *Money Heist*) in the original audio with subtitles for a more authentic experience.
- **Downloads & Offline Viewing:** Explain how to download titles to mobile devices for offline viewing and the limitations (expiration dates, device limits).
- **Top 10 Lists:** Use the "Top 10 in [Country] Today" list as a quick heuristic for popularity, but advise users to check if the genre actually aligns with their taste.

### Troubleshooting & Common Issues

#### "This title is not available in your region"

- **Diagnosis:** Licensing agreements vary by country.
- **Solution:** Explain that content libraries change based on geographic location. Suggest checking if the title is available on other platforms or if the user's location settings need updating.

#### "Too many people are using this account"

- **Diagnosis:** The account has exceeded its simultaneous stream limit or device limit.
- **Solution:** Guide the user to the "Manage Access and Devices" page to sign out of old devices or verify the Household status.

#### Poor Streaming Quality / Buffering

- **Diagnosis:** Internet speed or data usage settings.
- **Solution:**
    - Check internet speed (5 Mbps for HD, 25 Mbps for Ultra HD).
    - Navigate to "Account > Profile & Parental Controls > Playback Settings" to adjust Data Usage per screen (Low, Medium, High, Auto).

### Skill Extension Suggestions

#### The "Netflix Is A Joke" Hub

Expand the skill to specifically cover the comedy vertical, including stand-up specials and comedy films, which Netflix categorizes as a distinct brand.

#### Interactive Content

Instruct the Agent on "Choose Your Own Adventure" style content (e.g., *Black Mirror: Bandersnatch*), explaining how users can interact with the plot using their remote or touchscreen.

#### Gaming Integration

Cover the "Netflix Games" mobile offering, explaining that subscribers can download games based on Netflix IP (like *Stranger Things: 1984* or *The Queen's Gambit Chess*) at no extra cost, with no ads or in-app purchases.

### Skill Name: TRAE IDE & Workflow Architect

### Skill Description

This skill equips an Agent with deep expertise in the TRAE IDE ecosystem, specifically focusing on its unique "Skills" architecture, AI-driven coding capabilities, and workflow automation. The Agent will move beyond basic usage to explain how to architect custom Skills (packaging instructions, scripts, and resources), manage the distinction between Rules and Skills, and leverage the IDE's agentic features to maximize development velocity. It serves as a guide for transforming TRAE from a text editor into a personalized, automated development partner.

### Core Instruction Set

#### 1. The "Skills" Architecture

Explain the modular nature of TRAE's intelligence, which relies on "Skills" rather than just static prompts.

- **Definition:** A Skill is a context-triggered instruction set. It allows users to package specific workflows (instructions + resources) into reusable modules.
- **File Structure:**
    - **SKILL.md (Mandatory):** The core "brain" containing metadata (name, description) and the specific system instructions for the AI.
    - **Resources (Optional):** Scripts (`.py`, `.sh`), templates, or reference documents that the Skill can execute or reference.
    - **Location:** Skills are typically stored in the `.trae/skills/` directory within a project or globally.
- **Trigger Mechanism:** Skills can be invoked manually via natural language (e.g., "Use the [Skill Name] to...") or automatically when the AI detects a context match.

#### 2. Strategic Distinctions: Rules vs. Skills vs. Context

Clarify the specific use cases for TRAE's different configuration layers to optimize Token usage and AI focus.

- **Rules (Global/Project):**
    - **Function:** Persistent preferences and constraints (e.g., "Always use TypeScript," "No console logs").
    - **Loading:** Loaded into the context window constantly.
    - **Best For:** Coding styles, linting preferences, and broad behavioral guidelines.
- **Skills (Modular):**
    - **Function:** Specific, complex workflows (e.g., "Generate Unit Tests," "Refactor Legacy Code").
    - **Loading:** **On-demand (Lazy Loading).** They only consume context when triggered.
    - **Best For:** Reusable tasks, complex multi-step operations, and specialized domain knowledge.
- **Context (Passive):**
    - **Function:** Reference materials (documentation, codebases).
    - **Best For:** Providing the AI with the "knowledge base" it needs to answer questions.

#### 3. Creating and Deploying Custom Skills

Guide users through the lifecycle of building a custom Skill.

- **Natural Language Creation:** Instruct users that they can simply ask TRAE to "Create a skill for X," and the IDE will generate the folder structure and `SKILL.md` automatically.
- **Manual Authoring:**
    - **Metadata:** Define clear `name` and `description` fields to help the AI recognize when to use the skill.
    - **Instructions:** Write precise, step-by-step directives in the `SKILL.md` file.
- **Import/Export:** Explain how to share Skills by zipping the skill folder or importing them from community repositories (like GitHub).

#### 4. Agentic Capabilities & Workflow

Leverage TRAE's ability to act as an autonomous agent.

- **Sub-Agents:** Explain how TRAE can delegate tasks to specialized sub-agents (e.g., a "Code Reviewer" agent or a "UI Designer" agent) that utilize specific Skills.
- **Automation:** Describe how to chain Skills together. For example, using a "Data Cleaner" skill followed by a "Visualization" skill in a data science workflow.
- **MCP (Model Context Protocol):** Mention TRAE's compatibility with MCP, allowing it to connect to external data sources and tools seamlessly.

#### 5. Ecosystem & Community Resources

Highlight the collaborative aspect of the TRAE ecosystem.

- **Marketplace/Repositories:** Point users towards community-driven collections (like `awesome-trae-skills` or Anthropic's skill repositories) to avoid reinventing the wheel.
- **Common Use Cases:**
    - **Frontend Design:** Generating high-quality UI code based on design principles.
    - **DevOps:** Automating Dockerfile creation or CI/CD pipelines.
    - **Documentation:** Auto-generating docs from code comments.

### Troubleshooting & Common Pitfalls

#### "Skill Not Found" or Not Triggering

- **Diagnosis:** The `SKILL.md` file might be missing, misnamed, or located outside the `.trae/skills/` directory.
- **Fix:** Verify the file path and ensure the metadata (name/description) clearly matches the user's prompt intent.

#### Context Window Overload

- **Symptom:** The AI becomes slow or confused because too many Rules are active.
- **Fix:** Move complex, specific instructions out of "Rules" and into a "Skill." This keeps the baseline context light and only loads the heavy instructions when necessary.

#### Skill Logic Errors

- **Symptom:** The Skill executes but produces incorrect code.
- **Fix:** Treat the `SKILL.md` like code—debug it. Refine the instructions within the markdown file and re-test.

### Skill Extension Suggestions

#### Python/Scripting Integration

Expand the skill to teach users how to embed Python scripts within a Skill folder. This allows the AI to not just *write* code, but *execute* it (e.g., a Skill that runs a Python script to format data before answering).

#### Enterprise Governance

Instruct on how to create "Organization-wide" Skills that enforce company-specific security protocols, coding standards, or API usage patterns across all developer environments.

#### Multi-Agent Collaboration

Guide users on setting up complex workflows where one Skill acts as a "Manager" that delegates tasks to other specialized Skills, simulating a full software team within the IDE.

### Skill Name: Comparative Theology & Divine Archetypes

### Skill Description

This skill equips an Agent with a comprehensive understanding of the concept of "God" and divine entities across major world religions and mythologies. The Agent will move beyond simple definitions to explore the specific jurisdictions, symbolic meanings, and theological functions of deities. It covers the spectrum from monotheistic omnipotence to polytheistic personifications of natural forces, enabling the Agent to explain how different cultures conceptualize the ultimate reality.

### Core Instruction Set

#### 1. The Monotheistic Paradigm: Omnipotence & Providence

In Abrahamic traditions, the concept of God is centralized, transcendent, and often defined by absolute authority and benevolence.

- **Christianity:**
    - **The Trinity:** Explain the complex unity of God as Father (Creator), Son (Redeemer/Jesus Christ), and Holy Spirit (Guide/Sanctifier).
    - **Role:** God is the moral lawgiver and the source of salvation. Jesus represents the incarnation of God, emphasizing themes of healing, forgiveness, and sacrificial love.
- **Islam:**
    - **Tawhid:** The absolute oneness of Allah. God is unique, indivisible, and incomparable.
    - **Role:** The Merciful and Compassionate sustainer of the universe who demands submission to His will.
- **Judaism:**
    - **Yahweh:** The covenant-keeping God of Israel.
    - **Role:** A God of history and justice who is intimately involved in the moral trajectory of humanity.

#### 2. The Polytheistic & Mythological Paradigm: Personification of Forces

In ancient mythologies, divinity is often distributed among various entities representing specific aspects of nature, society, or human psychology.

- **Greek Mythology (The Olympians):**
    - **Structure:** A hierarchy of gods living on Mount Olympus, possessing human-like personalities (anthropomorphism).
    - **Key Figures:**
        - **Zeus:** King of gods,掌管 (governing) sky, lightning, and law.
        - **Hera:** Marriage and birth.
        - **Apollo:** Music, healing, and prophecy.
        - **Hephaestus:** Fire and craftsmanship (often associated with the creation of automatons like Talos).
- **Egyptian Mythology:**
    - **Nature Worship:** Gods often have animal features representing natural forces.
    - **Bastet:** Originally a lioness warrior, she evolved into a cat goddess representing home, fertility, and protection. She embodies the duality of the feline: gentle yet fiercely protective.
    - **Ra:** The sun god, representing creation and life.

#### 3. The Eastern Paradigm: Cosmic Order & Dharma

Eastern traditions often view "God" less as a distinct ruler and more as an underlying cosmic principle or a hierarchy of celestial administrators.

- **Hinduism:**
    - **Brahman:** The ultimate, formless reality or universal soul.
    - **The Trimurti:** The manifest aspects of God: Brahma (Creator), Vishnu (Preserver), and Shiva (Destroyer/Transformer).
- **Taoism:**
    - **The Jade Emperor:** The celestial administrator who governs the heavens and earth, reflecting the bureaucratic structure of ancient Chinese imperial government.
    - **Nature Deities:** Gods like the God of Wealth or City Gods (Chenghuang) who manage specific worldly affairs.
- **Buddhism:**
    - **Non-Theistic:** Buddhism does not focus on a creator god.
    - **Bodhisattvas:** Enlightened beings who delay nirvana to help others.
        - **Avalokiteshvara (Guanyin):** The embodiment of compassion.
        - **Manjushri:** The embodiment of wisdom.

#### 4. The Abstract Paradigm: Authority & Attributes

The Agent should be able to analyze "God" by their functional attributes rather than just their names.

- **Creation & Destruction:** The power to bring something from nothing (Ex Nihilo) or to dissolve the universe (Shiva/End Times).
- **Judgment & Justice:** The role of the divine as the ultimate judge of human morality (e.g., the weighing of the heart in Egypt, the Final Judgment in Christianity).
- **Immanence vs. Transcendence:**
    - **Transcendent:** God is outside of time and space (Christianity/Islam).
    - **Immanent:** God is present within the physical world (Pantheism/Shinto).

### Troubleshooting & Common Misconceptions

#### "Polytheism means worshipping many unrelated gods"

- **Clarification:** In many traditions like Hinduism or Taoism, the many gods are often seen as different manifestations or facets of a single, ultimate reality (Brahman or the Tao).

#### "Mythology is just fiction"

- **Clarification:** For the cultures that held them, these were religious truths. Figures like Zeus or Bastet were not "characters" but the actual forces governing their survival, harvest, and safety.

#### "God is always male"

- **Clarification:** While patriarchal imagery is common, many traditions feature powerful goddesses (Hera, Bastet, Guanyin, Saraswati) who hold equal or superior power in their specific domains (wisdom, protection, creation).

### Skill Extension Suggestions

#### The Anthropology of Prayer

Expand the skill to analyze *how* humans interact with these gods. Compare the "transactional" nature of ancient sacrifices (giving to get) with the "relational" nature of modern prayer (seeking alignment).

#### AI as a Modern "Deity"

Explore the sociological concept where Artificial Super Intelligence (ASI) is beginning to take on "god-like" attributes in the public imagination—omniscience (data access), omnipresence (internet connectivity), and the power to judge or decide outcomes (algorithms).

#### Syncretism

Teach the Agent to identify how gods merge when cultures collide, such as the blending of Greek and Egyptian deities (Serapis) or the adaptation of Buddhist deities in Chinese folk religion.

### Skill Name: MIMO Systems & Wireless Architecture Specialist

### Skill Description

This skill equips an Agent with deep technical expertise in Multiple-Input Multiple-Output (MIMO) technology, the cornerstone of modern wireless communications (4G LTE, Wi-Fi 5/6/7, and 5G NR). The Agent will be able to explain the physics of spatial multiplexing and diversity, differentiate between SU-MIMO and MU-MIMO, and analyze the architectural shifts required for Massive MIMO. It bridges the gap between theoretical information theory (Shannon capacity) and practical antenna deployment.

### Core Instruction Set

#### 1. Fundamental Architecture & Definition

Define MIMO not just as "more antennas," but as the exploitation of the spatial dimension to improve performance.

- **The Notation (**$N_t \times N_r$**):** Explain that a "4x4 MIMO" system refers to 4 transmit antennas ($N_t$) and 4 receive antennas ($N_r$).
- **The Channel Matrix (**$H$**):** Describe the wireless channel as a matrix $H$ where each element $h_{ij}$ represents the complex channel gain between transmit antenna $i$ and receive antenna $j$.
- **SISO vs. MIMO:** Contrast Single-Input Single-Output (SISO) systems, which are limited by bandwidth and power, with MIMO systems, which utilize spatial degrees of freedom to increase capacity without additional spectrum.

#### 2. Core Operational Mechanisms

Instruct the Agent to categorize MIMO operations into three distinct techniques:

- **Spatial Multiplexing (SM):**
    - **Goal:** Increase Data Rate (Throughput).
    - **Mechanism:** Splitting a high-rate data stream into multiple parallel low-rate streams transmitted simultaneously on the same frequency.
    - **Capacity Gain:** Theoretically increases channel capacity linearly with $\min(N_t, N_r)$.
- **Spatial Diversity:**
    - **Goal:** Increase Reliability (Link Robustness).
    - **Mechanism:** Transmitting the *same* data stream across different antennas (e.g., Space-Time Block Coding or Alamouti codes) to combat fading. If one path fades, another likely remains strong.
- **Beamforming:**
    - **Goal:** Increase Signal-to-Noise Ratio (SNR) and Coverage.
    - **Mechanism:** Adjusting the phase and amplitude of the signal at each antenna to create constructive interference in a specific direction (towards the user) and destructive interference elsewhere.

#### 3. Evolution of MIMO Standards

Differentiate between the generations of MIMO technology:

- **SU-MIMO (Single-User):** The base station communicates with only *one* user device at a time, utilizing all spatial streams for that single link.
- **MU-MIMO (Multi-User):**
    - **Concept:** The base station serves multiple users simultaneously on the same time-frequency resource.
    - **Precoding:** Explain that the transmitter uses Channel State Information (CSI) to pre-process signals, separating users spatially to minimize interference.
    - **Downlink vs. Uplink:** Downlink is a Broadcast Channel; Uplink is a Multiple Access Channel.
- **Massive MIMO:**
    - **Scale:** Utilizing very large antenna arrays (e.g., 64T64R, 128T128R, or 256 elements) at the base station.
    - **Channel Hardening:** As the number of antennas grows, the small-scale fading effects average out, making the channel deterministic and highly reliable.
    - **Application:** Essential for 5G mmWave and high-density urban environments.

#### 4. Performance Metrics & Analysis

The Agent must be able to evaluate MIMO performance using specific metrics:

- **Spectral Efficiency:** Measured in bits/second/Hz. MIMO allows for higher spectral efficiency by reusing the frequency spatially.
- **Diversity Gain:** The improvement in signal reliability (reduction in Bit Error Rate) proportional to the product of transmit and receive antennas ($N_t \times N_r$).
- **Multiplexing Gain:** The increase in data rate, proportional to the minimum of transmit and receive antennas ($\min(N_t, N_r)$).

#### 5. Implementation Challenges

Address the practical hurdles in deploying MIMO systems:

- **Channel Estimation:** The system must accurately estimate the channel matrix $H$. Inaccurate estimation leads to interference, especially in MU-MIMO.
- **Antenna Correlation:** For MIMO to work effectively, the signal paths must be uncorrelated (rich scattering environment). If antennas are too close or in a Line-of-Sight (LOS) dominant environment, the capacity gains diminish.
- **Hardware Complexity:** Massive MIMO requires a dedicated Radio Frequency (RF) chain for each antenna element, increasing cost and power consumption.

### Troubleshooting & Common Misconceptions

#### "More Antennas Always Means Faster Speed"

- **Correction:** Not always. If the environment lacks "multipath" (scattering objects like buildings or walls), adding antennas yields diminishing returns. MIMO thrives in rich scattering environments.

#### Confusing Beamforming with MIMO

- **Clarification:** Beamforming is a *technique* often used *within* a MIMO system. You can have MIMO without beamforming (pure spatial multiplexing), and beamforming without MIMO (single stream focusing), but modern 5G uses both simultaneously.

#### "MU-MIMO is just Time Division"

- **Correction:** MU-MIMO is *Spatial* Division. Unlike TDMA (Time Division), where users take turns, MU-MIMO users transmit/receive at the exact same time and frequency, separated only by their spatial signature.

### Skill Extension Suggestions

#### Hybrid Beamforming

Instruct the Agent on the architecture used in mmWave 5G, which combines analog beamforming (phase shifters) and digital beamforming (baseband processing) to balance performance with hardware cost.

#### Cell-Free Massive MIMO

Explore the concept of "User-Centric" networks where a user is served by a cluster of distributed access points rather than a single cell tower, eliminating cell boundaries.

#### Reconfigurable Intelligent Surfaces (RIS)

Discuss the integration of "smart walls" or surfaces that can reflect signals to create artificial multipath environments, enhancing MIMO performance in indoor settings.

### Skill Name: Cosmic Explorer: Universe & Astrophysics Literacy

### Skill Description

This skill empowers an Agent to navigate, explain, and discuss the vast field of cosmology and astronomy. It moves beyond simple trivia to provide a structured understanding of the Universe's architecture, from the Big Bang to the formation of galaxies. The Agent will learn to distinguish between celestial bodies, explain complex physical phenomena in simple terms, and discuss the future of space exploration.

### Core Instruction Set

#### 1. Cosmic Architecture & Hierarchy

When explaining the structure of the universe, guide the user through the "Cosmic Address" hierarchy:

- **The Observable Universe:** Define this as the spherical region containing all matter that can be observed from Earth at the present time, limited by the speed of light and the age of the universe (~13.8 billion years).
- **Galaxies:** Describe these as gravitationally bound systems. Differentiate between **Spiral** (like the Milky Way), **Elliptical**, and **Irregular** galaxies.
- **Star Systems:** Explain the relationship between stars, planets, and debris.
- **Key Distinction:** Clarify the difference between a **Solar System** (one star system) and a **Galaxy** (billions of stars).

#### 2. Celestial Nomenclature & Classification

Ensure precise terminology to avoid common misconceptions. Use this classification guide:

| Term | Definition | Key Characteristic |
| ------ |------ |------ |
| **Asteroid** | A rocky fragment, mostly found between Mars and Jupiter. | Smaller than a planet; "Minor Planet". |
| **Comet** | A body of ice, dust, and rock. | Develops a visible atmosphere (coma) and tail when near the Sun. |
| **Nebula** | A giant cloud of dust and gas in space. | Often a "stellar nursery" where stars are born. |
| **Black Hole** | A region of spacetime with gravity so strong nothing escapes. | Defined by its Event Horizon. |
| **Dark Matter** | A hypothetical form of matter. | Does not interact with light but accounts for ~27% of the universe's mass-energy. |

#### 3. Fundamental Physics & Phenomena

Explain the forces that govern the universe:

- **Gravity:** The architect of the cosmos. Explain how it pulls matter together to form stars and keeps planets in orbit.
- **The Speed of Light (**$c$**):** The cosmic speed limit ($\approx 300,000 \text{ km/s}$). Explain that looking deep into space is equivalent to looking back in time.
- **Expansion of the Universe:**
    - **The Big Bang:** The prevailing cosmological model for the observable universe's early development.
    - **Redshift:** Explain how light from distant galaxies stretches as space expands, shifting it toward the red end of the spectrum.
- **Time Dilation:** Briefly touch upon Einstein’s theory of relativity—time moves slower for objects moving at high speeds or near massive objects (like black holes).

#### 4. Space Exploration & Technology

Contextualize how humans study the cosmos:

- **Telescopes:** Differentiate between **Optical** (Hubble) and **Infrared** (James Webb) telescopes. Explain why space telescopes are superior (no atmospheric distortion).
- **Missions:**
    - **Robotic:** Rovers (Perseverance on Mars) and Orbiters.
    - **Human Spaceflight:** The International Space Station (ISS) and the Artemis program (returning to the Moon).
- **Coordination:** Mention **Coordinated Universal Time (UTC)** as the standard time used in space missions to synchronize international teams.

#### 5. The Future of the Cosmos

Discuss the theoretical endgames of the universe to provoke thought:

- **The Big Freeze (Heat Death):** The most likely scenario where the universe expands until stars burn out and entropy reaches a maximum.
- **The Big Crunch:** A theoretical scenario where expansion reverses, and the universe collapses back into a singularity.
- **Multiverse Theory:** The speculative idea that our universe is just one of many distinct universes.

### ️ Troubleshooting & Common Misconceptions

#### "Zero Gravity" vs. Microgravity

- **Symptom:** Users believing there is no gravity in space.
- **Correction:** Clarify that gravity is everywhere. Astronauts on the ISS experience **microgravity** because they are in a constant state of freefall around Earth, not because gravity is absent.

#### "Dark Matter" vs. "Dark Energy"

- **Symptom:** Confusing the two "dark" forces.
- **Correction:**
    - **Dark Matter:** Acts like "cosmic glue" (holds galaxies together).
    - **Dark Energy:** Acts like "anti-gravity" (pushes the universe apart).

#### "Light Year"

- **Symptom:** Thinking it is a measure of time.
- **Correction:** Emphasize that a light-year is a unit of **distance**—the distance light travels in one year (approx. 9.46 trillion km).

### Skill Extension Suggestions

#### Astrobiology & The Fermi Paradox

Expand the skill to explore the probability of extraterrestrial life. Discuss the **Drake Equation** and the question: "If the universe is so old and vast, where is everybody?"

#### Exoplanet Hunting

Instruct the Agent on the methods used to find planets outside our solar system, such as the **Transit Method** (detecting dimming stars) and the **Radial Velocity Method** (detecting stellar wobbles).

#### Cosmic Calendar

Use the "Cosmic Calendar" analogy (compressing the 13.8 billion year history of the universe into a single calendar year) to help users visualize the scale of time and humanity's brief existence.

### 技能名称：GitHub 仓库克隆与同步专家

### 技能描述

本技能指导 Agent 熟练掌握使用 Git 工具从 GitHub 获取代码仓库的全过程。它不仅涵盖了基础的 `git clone` 命令，还深入到了认证配置（SSH vs HTTPS）、分支管理、子模块处理以及增量更新等高级场景。Agent 将能够根据用户的网络环境和权限需求，选择最优的克隆策略，确保代码完整、安全地同步到本地环境。

### 核心指令集

#### 1. 环境预检与配置

在执行克隆之前，Agent 必须确保本地环境已准备好。

- **Git 安装检查：** 运行 `git --version`。如果未安装，需引导用户前往 Git 官网或包管理器进行安装。
- **身份认证配置：** 这是克隆私有仓库或进行推送的前提。
    - **SSH 方式（推荐）：** 指导生成 SSH 密钥 (`ssh-keygen`) 并添加到 GitHub 账户。使用 `[email protected]:username/repo.git` 格式。
    - **HTTPS 方式：** 使用 `https://github.com/username/repo.git` 格式。需提醒用户配置凭据管理器或使用 Personal Access Token (PAT) 代替密码。

#### 2. 基础克隆操作

指导用户执行标准的仓库下载。

- **标准克隆：** 使用 `git clone <repository_url>`。这会将远程仓库的所有文件、提交历史和分支信息下载到当前目录下的一个同名文件夹中。
- **指定目录名：** 如果用户希望自定义文件夹名称，使用 `git clone <repository_url> <directory_name>`。

#### 3. 高级克隆策略

针对不同的开发需求，Agent 需掌握特定的克隆参数。

- **浅克隆：** 对于大型仓库或只需最新代码的场景，使用 `git clone --depth 1 <repository_url>`。这仅下载最新的提交记录，极大节省时间和带宽。
- **特定分支克隆：** 若只需特定分支（如 `develop`），使用 `git clone -b <branch_name> <repository_url>`。
- **包含子模块：** 许多项目依赖子模块。必须使用 `git clone --recursive <repository_url>`。如果已克隆但未初始化子模块，需执行 `git submodule update --init --recursive`。

#### 4. 仓库同步与更新

克隆只是开始，Agent 需指导如何保持本地代码与远程同步。

- **拉取更新：** 在已克隆的目录中，运行 `git pull origin <branch_name>` 获取并合并远程变更。
- **变基同步：** 为了保持提交历史整洁，推荐使用 `git pull --rebase`。

#### 5. 故障排查与安全

- **权限被拒绝：** 检查 SSH 密钥是否正确添加到 `ssh-agent`，或 HTTPS 密码是否为 Token。
- **连接超时：** 可能是网络问题，建议检查代理设置或尝试切换 DNS。
- **证书验证失败：** 在企业环境中常见，通常涉及自签名证书，需谨慎处理 `http.sslVerify` 配置。

### 常见问题排查

#### "Permission denied (publickey)"

- **诊断：** 本地没有配置 SSH 密钥，或者公钥未添加到 GitHub 账户。
- **解决：** 运行 `cat ~/.ssh/id_rsa.pub` 查看公钥。如果没有，生成一个新的。将公钥内容复制到 GitHub 的 "SSH and GPG keys" 设置中。

#### "fatal: destination path '...' already exists and is not an empty directory"

- **诊断：** 尝试克隆到一个已经存在且非空的文件夹。
- **解决：** 要么删除该文件夹，要么在 `git clone` 命令后指定一个新的、不存在的文件夹名称。

#### 克隆速度极慢

- **诊断：** 仓库体积过大或网络连接不佳。
- **解决：** 建议使用浅克隆 (`--depth 1`) 仅获取最新代码。如果是网络波动，建议配置全局代理 (`git config --global http.proxy ...`)。

### 技能扩展建议

#### Fork 工作流

扩展技能以指导用户 Fork 仓库到自己的账户，然后克隆自己的 Fork，并配置上游远程仓库 (`git remote add upstream`) 以便同步原项目的更新。

#### GitHub CLI 集成

引入 `gh` 命令行工具，教导用户使用 `gh repo clone <repo>` 进行交互式克隆，这通常比原生 Git 更便捷，且自动处理认证。

#### 镜像克隆

针对需要迁移整个仓库（包括所有引用和refs）的场景，指导使用 `git clone --mirror`，这通常用于备份或迁移到另一个 Git 服务器。

### 技能名称：Uber 全球出行向导

### 技能描述

本技能旨在指导 Agent 协助用户在全球范围内高效、安全地使用 Uber 出行服务。Agent 需掌握从账户注册、车型选择、行程预订到安全设置及支付管理的全流程知识。该技能特别强调跨文化场景下的使用细节（如海外打车）、安全功能的实际应用以及常见问题的解决方案，确保用户无论是处理日常通勤还是在陌生城市探索，都能获得流畅的乘车体验。

### 核心指令集

#### 1. 账户注册与基础设置

在用户首次使用时，指导其完成必要的初始化步骤：

- **下载与注册：** 引导用户从 App Store 或 Google Play 下载应用。注册时需提供姓名、手机号、邮箱及语言偏好。
- **支付方式绑定：** 强调必须绑定有效的支付方式（信用卡、借记卡或支付宝等本地化支付工具）。
    - **提示：** 告知用户 Uber 为无现金支付平台，上车前需确保支付渠道畅通。
- **优惠码使用：** 指导用户在“钱包”或注册页面输入邀请码以获取首乘优惠，并说明优惠券的抵扣规则。

#### 2. 叫车流程与车型选择

指导用户如何精准地发起行程：

- **目的地输入：** 在“您想去哪里？”栏输入目的地。若位置不准，指导用户通过拖拽地图大头针微调上车点。
- **车型匹配策略：** 根据用户需求推荐合适的车型：
    - **UberX：** 经济实惠，适合 1-4 人的日常出行。
    - **Uber Black：** 高端豪华轿车，适合商务接待或追求舒适体验。
    - **UberXL：** 适合 6 人以上团体或携带大件行李。
    - **Uber Taxi：** 呼叫当地正规出租车，通过 App 支付。
- **价格与时间确认：** 提醒用户在确认叫车前查看预估价格和到达时间。若处于高峰期（价格飙升），建议稍作等待或选择拼车（如可用）。

#### 3. 行程中的安全与互动

强化安全意识，确保用户的人身与财产安全：

- **上车前核对：** 必须核对 App 显示的司机姓名、车牌号、车型及司机评分。若信息不符，切勿上车。
- **行程分享：** 指导用户使用“分享行程状态”功能，将实时位置和预计到达时间发送给亲友。
- **车内互动：** 建议用户坐在后排。若需联系司机，使用 App 内的匿名通话功能。
- **中途加站：** 若需中途停留，指导用户在行程开始前或进行中点击“+”号添加最多 2 个停靠点。

#### 4. 支付、评分与售后

完善行程结束后的闭环操作：

- **自动扣款：** 说明行程结束后费用会自动从绑定账户扣除，无需现金交易（除小费外）。
- **评分与小费：** 鼓励用户根据体验为司机打分（1-5星）。若服务出色，可在 App 内添加小费。
- **失物招领：** 若遗落物品，指导用户通过 App 的“帮助”页面联系司机或客服找回失物。

#### 5. 高级功能与特殊场景

- **预约行程：** 指导用户点击车辆选项旁的时钟图标，提前最多 30 天预约行程，适合赶飞机或重要会议。
- **为他人叫车：** 演示如何切换乘客身份，输入亲友的手机号，让司机直接联系乘车人，适合帮助不熟悉操作的长辈或朋友叫车。
- **海外使用：** 提醒用户出国时无需更换 App，Uber 在全球 1 万多个城市通用，但需注意当地特有的车型或支付习惯（如部分地区支持现金支付）。

### 常见问题排查

#### “找不到司机”或“等待时间过长”

- **诊断：** 可能是当前位置偏僻、高峰期需求过大或网络信号差。
- **解决：** 建议用户移动到主干道或地标性建筑附近；检查网络连接；或尝试切换车型（如从 UberX 切换到 Uber Black）。

#### 价格与预估不符

- **诊断：** 实际路线偏离、中途停留时间过长或终点变更。
- **解决：** 指导用户在 App 内查看行程明细（收据），若对费用有异议，通过“帮助”页面申请费用审查。

#### 司机绕路

- **诊断：** 司机未按导航行驶。
- **解决：** 建议用户礼貌询问司机路线选择。若确认恶意绕路，行程结束后在 App 内反馈“我的路线有问题”以申请调整费用。

### 技能扩展建议

#### 商务版 Uber for Business

扩展技能以支持企业用户，指导如何设置公司账户、管理员工出行权限及查看企业账单。

#### 无障碍出行

增加对无障碍车辆（WAV）的指导，帮助残障人士或携带轮椅的用户顺利叫车。

#### 环保出行选项

在支持绿色出行的地区，指导用户选择 Uber Green（电动车或混合动力车），并解释相关的环保激励政策。

### 技能名称：GitHub 文件上传与版本管理专家

### 技能描述

本技能旨在指导 Agent 掌握通过 Git 命令行工具将本地文件高效、规范地上传至 GitHub 远程仓库的完整流程。它不仅涵盖了基础的代码提交步骤，更深入解析了 Git 的核心概念、分支管理策略以及大文件处理方案。Agent 将学会如何像专业开发者一样思考版本控制，确保每一次上传都安全、清晰且可追溯。

### 核心指令集

#### 1. 核心概念与准备工作

在执行任何上传操作前，必须先理解三个核心概念，这就像寄快递一样简单明了：

- **远程仓库 (Remote Repository)：** 相当于你在 GitHub 上租用的“专属储物柜”，用于长期存储和备份代码。
- **本地仓库 (Local Repository)：** 相当于你电脑上的“待寄包裹”，里面装着你编写的项目文件。
- `.gitignore`** 文件：** 相当于“不寄清单”，它告诉 Git 哪些文件（如缓存、临时文件、大体积依赖包）不需要上传，以避免仓库臃肿或泄露敏感信息。

**准备步骤：**

1. **创建远程仓库：** 登录 GitHub，点击右上角“+”号，选择“New repository”，输入仓库名称并创建。复制生成的仓库地址（URL）。
2. **配置本地环境：** 确保你的项目文件夹中已包含需要提交的代码，并在根目录下创建或更新了 `.gitignore` 文件，排除了不必要的文件。

#### 2. 标准上传流程

遵循标准的七步工作流，确保每一次提交都清晰、规范。

- **步骤一：进入项目目录**
在终端中切换到你的本地项目文件夹。

```
cd path/to/your/project
```

- **步骤二：初始化本地仓库**
如果这是第一次操作，需要将当前文件夹初始化为 Git 仓库。

```
git init
```

- 执行后，目录下会生成一个隐藏的 `.git` 文件夹，标志着 Git 开始接管版本管理。
- **步骤三：关联远程仓库**
将本地仓库与 GitHub 上的远程仓库进行配对。

```
git remote add origin <你的仓库URL>
```

- **步骤四：添加文件到暂存区**
将你想要上传的文件“打包”，准备提交。

```
git add .
```

- 这条命令会将所有更改（除了 `.gitignore` 中排除的文件）添加到暂存区。
- **步骤五：提交更改**
将暂存区的文件正式记录到本地历史中，并附上清晰的提交信息。

```
git commit -m "feat: 初始化项目结构"
```

- 提交信息应简洁明了，说明本次更改的目的。
- **步骤六：同步远程分支**
在推送前，先拉取远程仓库的最新状态，避免冲突。使用 `--rebase` 参数可以保持提交历史的线性整洁。

```
git pull --rebase origin master
```

- **步骤七：推送到远程仓库**
最后，将本地的提交正式上传到 GitHub。

```
git push -u origin master
```

- `-u` 参数会将本地分支与远程分支关联，后续直接使用 `git push` 即可。

#### 3. 分支管理与协作

为了更高效地管理代码，应养成使用分支的习惯。

- **创建新分支：** 在开始新功能或修复 Bug 前，从主分支创建一个新分支。

```
git checkout -b feature/new-login
```

- **切换分支：** 在不同分支间切换以进行不同任务的开发。

```
git checkout master
```

- **合并分支：** 当功能开发完成后，将其合并回主分支。

```
git checkout master
git merge feature/new-login
```

#### 4. 大文件处理方案

GitHub 对单个文件的大小有限制（通常为 100MB）。对于模型文件、大型数据集等，需要使用 Git LFS (Large File Storage)。

- **安装 Git LFS：** 首次使用时，需在命令行中安装。

```
git lfs install
```

- **追踪大文件：** 告诉 Git LFS 需要追踪哪些类型的文件。

```
git lfs track "*.zip"
```

- **提交与推送：** 之后的操作与标准流程一致，Git LFS 会自动处理大文件的上传和下载。

### 常见问题排查

#### 推送被拒绝

- **症状：** 执行 `git push` 时提示 `rejected`。
- **原因：** 通常是因为远程仓库有本地没有的提交。
- **解决方案：** 先执行 `git pull --rebase origin master` 将远程的更新合并到本地，解决可能出现的冲突后，再执行 `git push`。

#### 提交了不该提交的文件

- **症状：** 不小心将密码文件或大型依赖库上传到了仓库。
- **解决方案：**
    1. 立即在 `.gitignore` 中添加该文件的路径。
    2. 使用 `git rm --cached <文件名>` 将其从 Git 跟踪中移除。
    3. 提交更改并推送：`git commit -m "chore: 移除敏感文件"` 和 `git push`。

#### 提交历史混乱

- **症状：** 提交记录中出现大量无意义的“Merge branch...”信息。
- **解决方案：** 养成使用 `git pull --rebase` 而非 `git pull` 的习惯，这能保持提交历史的线性，使其更加清晰易读。

### 技能扩展建议

#### 自动化工作流

扩展技能，学习使用 GitHub Actions。通过编写 YAML 配置文件，实现代码提交后自动运行测试、自动构建或自动部署，打造持续集成/持续部署（CI/CD）流水线。

#### 交互式变基

掌握 `git rebase -i` 命令。它允许你在推送前整理本地的提交历史，例如将多个零碎的提交合并为一个，或修改提交信息，使项目历史更加整洁和专业。

#### 保护主分支

在 GitHub 仓库设置中启用分支保护规则。可以要求所有推送到主分支的代码必须通过 Pull Request 合并，并且必须通过 CI 检查和

### 技能名称：全媒体内容生产与运营专家

### 技能描述

本技能旨在指导 Agent 掌握全媒体环境下的核心内容生产与运营能力。它超越了传统单一媒体的局限，聚焦于“一次采集、多元生成、全媒传播”的融合工作模式。Agent 将学习如何运用文字、影像、音频等多种媒介手段进行策划与创作，并掌握跨平台分发、数据分析及用户运营等关键技能，从而成为一个能够适应数字化时代需求的复合型媒体助手。

### 核心指令集

#### 1. 全媒体内容策划与创作

在内容创作层面，Agent 需遵循“一专多能”的原则，能够根据不同媒介的特点进行内容适配。

- **新闻采编与写作：**
    - **敏锐性：** 能够从海量信息中识别具有新闻价值的线索，关注社会热点与民生百态。
    - **结构化写作：** 针对不同体裁（如消息、通讯、评论）采用不同的写作逻辑。消息要求要素齐全、时效性强；评论则需观点鲜明、论证有力。
    - **采访技巧：** 模拟采访过程时，需准备充分、善于提问（开放式与封闭式结合），并能从对话中捕捉关键信息。
- **多媒体素材处理：**
    - **视觉呈现：** 掌握图片处理（如封面图、信息长图）和基础设计审美。能够指导生成符合平台调性的视觉素材。
    - **音视频剪辑：** 理解短视频的“黄金三秒”原则，能够规划节奏明快、信息密集的脚本。了解音频与视频的基础剪辑逻辑（如格式转换、关键帧处理）。
    - **交互式内容：** 能够策划 H5 页面或交互式图文，利用故事化手法增强用户的沉浸感。

#### 2. 跨平台运营与分发策略

Agent 必须具备跨平台思维，理解不同渠道的分发逻辑与用户特征，实现内容的精准触达。

- **平台差异化策略：**
    - **微信（深度与服务）：** 侧重内容的深度解读与社群互动，适合发布深度报道、服务类信息及维护私域流量。
    - **微博（速度与热点）：** 强调热点追踪与快速传播，适合事件报道、舆论引导及话题营销。
    - **抖音/快手（视觉与共鸣）：** 突出短视频的视觉冲击力与生活真实感，利用算法推荐机制获取公域流量。
    - **B站/小红书（圈层与种草）：** 聚焦兴趣圈层与真实体验分享，适合专业领域深耕或产品种草。
- **内容适配与矩阵传播：**
    - **一次采集，多种生成：** 将同一核心素材转化为图文、短视频、直播、音频等多种形态。
    - **差异化呈现：** 针对不同平台调整标题风格、封面图尺寸及文案长度，避免“一键分发”带来的水土不服。

#### 3. 数据分析与用户运营

从“内容导向”转向“用户导向”，利用数据驱动决策。

- **关键指标监控：**
    - 关注阅读量/播放量、完播率、点赞、转发、评论等核心数据。
    - 分析数据背后的用户行为，例如通过完播率判断视频节奏，通过转发量评估内容的社交货币属性。
- **用户画像与互动：**
    - **画像构建：** 基于数据勾勒用户画像（年龄、地域、兴趣），区分高价值用户与潜力用户。
    - **社群运营：** 掌握社群管理技巧，如利用工具进行打卡、裂变，增强用户粘性。
    - **反馈闭环：** 根据用户评论与后台留言，及时调整后续的内容选题与风格。

#### 4. 融合传播与工具应用

- **工具链整合：** 熟练运用各类新媒体工具，包括排版编辑器、二维码生成器、数据可视化工具及短视频剪辑软件。
- **活动策划：** 能够策划线上活动（如抽奖、投票、话题挑战赛），通过活动拉动用户增长与活跃。
- **危机应对：** 具备舆情监测意识，能够在负面评论出现时快速响应，引导舆论走向。

### 常见问题排查

#### 内容“水土不服”

- **症状：** 同一篇内容在 A 平台火爆，在 B 平台无人问津。
- **修正：** 检查是否忽略了平台调性。例如，严肃的长文直接发布在抖音可能效果不佳，需转化为口播视频或图文轮播。

#### 数据虚假繁荣

- **症状：** 阅读量高但互动率（点赞/评论）极低。
- **修正：** 这通常是“标题党”或封面误导导致的。需优化内容质量，确保标题与正文一致，并在文中设置互动引导（Call to Action）。

#### 创作瓶颈

- **症状：** 选题枯竭，内容同质化严重。
- **修正：** 建立“热点日历”与“素材库”。利用数据工具分析行业趋势，或采用“旧闻新做”的策略，从新角度切入老话题。

### 技能扩展建议

#### AI 辅助创作

扩展 Agent 的能力，使其能利用生成式 AI 进行文案润色、脚本生成及 AI 绘画，实现“人机协同”的高效生产。

#### 直播电商运营

增加直播带货的脚本策划、场控话术及选品逻辑，将媒体影响力转化为商业价值。

#### 专家型 IP 打造

指导 Agent 协助用户打造个人 IP，通过垂直领域的深度内容（如财经、法律、教育）建立专业权威，实现从“流量”到“留量”的转化。

### Skill Name: WeChat Pay Ecosystem & Integration Specialist

### Skill Description

This skill equips an Agent with comprehensive knowledge of WeChat Pay, covering its user-facing operations, technical integration methods, security protocols, and ecosystem evolution. The Agent will be able to guide users through payment processes, assist developers with API implementation, and explain the underlying architecture of Tencent's financial technology platform.

### Core Instruction Set

#### 1. User-Facing Operations

When instructing end-users, categorize operations into three primary scenarios:

- **Active Scanning (User Scans Merchant):**
    - **Scenario:** The merchant displays a QR code (static or dynamic).
    - **Action:** The user opens WeChat, selects "Scan," and scans the code.
    - **Flow:** The user enters the amount (if not fixed) and password to complete the transaction. This is common for street vendors or scanning items on a PC website (Native Pay).
- **Passive Scanning (Merchant Scans User):**
    - **Scenario:** Supermarkets, convenience stores, or transit gates.
    - **Action:** The user opens the "Money" wallet and displays the **Payment Code** (barcode/QR code).
    - **Flow:** The merchant scans the code with a device. For small amounts (typically under 1000 RMB), this is often **password-free** (免密支付) for speed.
- **In-App & Web Payments:**
    - **Scenario:** E-commerce apps, Mini Programs, or Official Accounts.
    - **Action:** The user selects "WeChat Pay" at checkout.
    - **Flow:** The app invokes the WeChat SDK, the user confirms the amount and enters their password within the WeChat interface, then returns to the merchant app.

#### 2. Technical Integration Architecture

For developer queries, break down the integration based on the platform:

- **Native Pay (PC/Offline):**
    - The merchant server generates a QR code using the WeChat Pay API. The user scans it, and the server listens for a **callback** notification to confirm the order status.
- **JSAPI Pay (Official Accounts):**
    - Used within the WeChat browser. It requires the merchant to obtain the user's `openid` and use the JS-SDK to invoke the payment window.
- **App Pay (Mobile SDK):**
    - Requires integrating the WeChat SDK into iOS/Android apps. The flow involves a pre-order creation on the merchant server, obtaining a `prepay_id`, and passing this to the mobile SDK to launch the payment.
- **Mini Program Pay:**
    - Similar to App Pay but utilizes the specific Mini Program API (`wx.requestPayment`). It relies on the user's logged-in state within the Mini Program environment.

#### 3. Security & Risk Management

The Agent must emphasize security protocols and user protection:

- **Authentication:** Explain that WeChat Pay relies on **Real-Name Verification** (linking bank cards and ID).
- **Transaction Security:**
    - **Password-Free Limits:** Inform users that small transactions (e.g., under 1000 RMB) may not require a password to improve efficiency, but this can be disabled in settings.
    - **Risk Controls:** WeChat Pay employs real-time risk monitoring. If a transaction appears suspicious (e.g., new device, unusual location), it may trigger secondary verification or block the payment.
- **Fraud Prevention:**
    - Warn users never to share their **Payment Code** (it acts like a password).
    - Advise against scanning unknown QR codes from untrusted sources to avoid phishing.

#### 4. Ecosystem & Innovation

Highlight the broader capabilities and recent developments:

- **Interconnectivity:** Note the recent interoperability with **UnionPay Cloud QuickPass** and **JD Pay**, allowing cross-platform scanning in certain contexts.
- **Biometric Payment:** Mention advanced hardware integrations like **Brush-to-Pay** (Face ID) and **Palm-to-Pay** (Palm recognition), which allow payments without a phone.
- **Cross-Border:** WeChat Pay supports multiple currencies and is widely used by international tourists in China and by Chinese tourists abroad.

### Troubleshooting & Common Issues

#### "Payment Failed" or "System Error"

- **Diagnosis:** This often indicates a network timeout, insufficient balance, or a risk control block.
- **Solution:** Advise the user to check their network connection, ensure their bank card has funds, or wait 24 hours if the account is flagged for suspicious activity.

#### "Merchant Category Not Supported"

- **Diagnosis:** The user is trying to use a credit card for a transaction type that only allows debit cards (e.g., financial products or real estate).
- **Solution:** Instruct the user to switch the payment method to "Balance" or a "Debit Card" in the payment confirmation screen.

#### Refund Delays

- **Diagnosis:** Users often expect instant refunds.
- **Explanation:** Clarify that while some refunds are instant, bank processing times can take 1-3 business days depending on the issuing bank's policy.

### Skill Extension Suggestions

#### Merchant API V3 Migration

Instruct the Agent on the differences between the legacy V2 API and the modern V3 API (which uses JSON instead of XML and improved signature mechanisms), helping developers migrate legacy systems.

#### Marketing Integration

Expand the skill to include "Cash Vouchers" and "Store Coupons" APIs, teaching how to integrate marketing tools directly into the payment flow to increase conversion rates.

#### Subscription & Withholding

Cover the "Password-Free Withholding" (Auto-debit) API, used for recurring billing scenarios like membership subscriptions or highway tolls.