[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6CXPBWAE7JP89RSWYCTMY5X":3,"skill-same:01M6CXPBWAE7JP89RSWYCTMY5X":62},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":27,"publishedAt":35,"linkOnly":36,"markdownContent":37,"markdownBody":38,"frontMatter":39,"refName":42,"commitSha":43,"skillDirectory":5,"forksCount":44,"repositoryHtmlUrl":45,"repositoryHomepageUrl":6,"ownerHtmlUrl":46,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":47,"install":48,"resources":61},"01M6CXPBWAE7JP89RSWYCTMY5X","system-design",null,"System design principles and patterns","ffsshhttiikk\u002Fopencode-agents-skills","ffsshhttiikk","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F226346827?v=4","01M6CWD9RR3Y7VRQX3MXYC8FYH","01M6CWD9WVPYAZW0J82G1VKGHY",3,"MIT","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fsystem-design\u002FSKILL.md",[17,22],{"categoryNo":18,"categoryName":19,"taxonomyType":20,"taxonomyTypeDesc":21},"01JBSEEDCAT000000000000015","视觉设计","SCENARIO","使用场景",{"categoryNo":23,"categoryName":24,"taxonomyType":25,"taxonomyTypeDesc":26},"01JBSEEDCAT000000000000032","设计师","PROFESSION","适用职业",[28,29,30,31,32,33,34],"design","system","system design","architecture","opencode","design principles","patterns","2026-11-10 10:12:30",false,"---\nname: system-design\ndescription: System design principles and patterns\nlicense: MIT\ncompatibility: opencode\nmetadata:\n  audience: developers\n  category: architecture\n---\n## What I do\n- Design scalable and reliable systems\n- Apply CAP theorem and trade-offs\n- Choose appropriate data storage solutions\n- Design for high availability and fault tolerance\n- Implement caching strategies\n- Handle rate limiting and throttling\n- Design APIs for scalability\n- Consider security from the start\n\n## When to use me\nWhen designing system architecture or reviewing high-level designs.\n\n## CAP Theorem\n```\n         Consistency + Partition Tolerance\n                     \u002F\\\n                    \u002F  \\\n                   \u002F    \\\n                  \u002F      \\\n                 \u002F   AP   \\\n                \u002F          \\\n               \u002F            \\\n              \u002F              \\\n             \u002F                \\\n            \u002F    Consistency   \\\n           \u002F      Availability \\\n          \u002F                    \\\n         \u002F----------------------\\\n        \u002F       CA              \\\n       \u002F                        \\\n      \u002F    Availability          \\\n     \u002F       Consistency         \\\n    \u002F______________________________\\\n\nChoose 2 of 3:\n- CP (Consistency + Partition Tolerance): Databases like MongoDB, Redis Cluster\n- AP (Availability + Partition Tolerance): DynamoDB, Cassandra, CouchDB\n- CA (Consistency + Availability): Not possible with network partitions\n```\n\n## High-Level Design Components\n\n### Load Balancer\n```\n                    ┌──────────────────────────────────────┐\n                    │         Load Balancer                 │\n                    │   (Nginx, AWS ALB, Cloudflare)        │\n                    └──────────────┬───────────────────────┘\n                                   │\n         ┌─────────────┬─────────────┼─────────────┬─────────────┐\n         ▼             ▼             ▼             ▼             ▼\n    ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐\n    │ App     │  │ App     │  │ App     │  │ App     │  │ App     │\n    │ Server  │  │ Server  │  │ Server  │  │ Server  │  │ Server  │\n    │ (x3)    │  │ (x3)    │  │ (x3)    │  │ (x3)    │  │ (x3)    │\n    └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘\n         │             │             │             │             │\n         └─────────────┴─────────────┼─────────────┴─────────────┘\n                                    │\n                    ┌───────────────┴───────────────┐\n                    │        Cache Layer             │\n                    │   (Redis Cluster, Memcached)   │\n                    └───────────────┬───────────────┘\n                                    │\n         ┌─────────────┬─────────────┼─────────────┬─────────────┐\n         ▼             ▼             ▼             ▼             ▼\n    ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐\n    │Primary  │  │Replica  │  │Replica  │  │Replica  │  │Replica  │\n    │DB       │  │DB       │  │DB       │  │DB       │  │DB       │\n    └─────────┘  └─────────┘  └─────────┘  └─────────┘  └─────────┘\n```\n\n## Caching Strategies\n\n### Cache-Aside Pattern\n```python\ndef get_user(user_id: str) -> Optional[User]:\n    \"\"\"Cache-aside: Check cache first, then database.\"\"\"\n    # 1. Check cache\n    cached = cache.get(f\"user:{user_id}\")\n    if cached:\n        return User.from_dict(cached)\n    \n    # 2. Fetch from database\n    user = database.get_user(user_id)\n    if user:\n        # 3. Store in cache with TTL\n        cache.set(f\"user:{user_id}\", user.to_dict(), ttl=3600)\n    \n    return user\n\n\ndef update_user(user_id: str, **kwargs) -> None:\n    \"\"\"On update: Invalidate cache, then update database.\"\"\"\n    # 1. Update database\n    database.update_user(user_id, **kwargs)\n    \n    # 2. Invalidate cache\n    cache.delete(f\"user:{user_id}\")\n```\n\n### Read-Through \u002F Write-Through\n```python\nclass CachedRepository:\n    def __init__(self, cache: Cache, db: Database) -> None:\n        self.cache = cache\n        self.db = db\n    \n    async def get(self, key: str) -> Optional[dict]:\n        \"\"\"Read-through cache.\"\"\"\n        # Check cache first\n        cached = await self.cache.get(key)\n        if cached:\n            return cached\n        \n        # Fetch from DB and cache\n        result = await self.db.query(key)\n        if result:\n            await self.cache.set(key, result, ttl=3600)\n        \n        return result\n    \n    async def set(self, key: str, value: dict) -> None:\n        \"\"\"Write-through: Write to cache and database.\"\"\"\n        await self.db.save(key, value)\n        await self.cache.set(key, value, ttl=3600)\n```\n\n### Write-Behind \u002F Write-Back\n```python\nclass WriteBehindCache:\n    \"\"\"Buffer writes and batch to database.\"\"\"\n    \n    def __init__(self, cache: Redis, db: Database) -> None:\n        self.cache = cache\n        self.db = db\n        self.write_buffer = []\n    \n    async def set(self, key: str, value: dict) -> None:\n        \"\"\"Write to cache immediately, queue for DB.\"\"\"\n        await self.cache.set(key, value)\n        await self.cache.lpush('write_buffer', json.dumps({\n            'key': key,\n            'value': value,\n            'timestamp': time.time(),\n        }))\n    \n    async def flush_buffer(self) -> None:\n        \"\"\"Batch process write buffer to database.\"\"\"\n        while True:\n            item = await self.cache.rpop('write_buffer')\n            if not item:\n                break\n            \n            data = json.loads(item)\n            await self.db.save(data['key'], data['value'])\n```\n\n## Rate Limiting\n```python\nfrom datetime import datetime, timedelta\nfrom collections import defaultdict\n\n\nclass RateLimiter:\n    \"\"\"Token bucket rate limiter with sliding window.\"\"\"\n    \n    def __init__(\n        self,\n        max_requests: int,\n        window_seconds: int\n    ) -> None:\n        self.max_requests = max_requests\n        self.window_seconds = window_seconds\n        self.requests: dict[str, list[datetime]] = defaultdict(list)\n    \n    def is_allowed(self, key: str) -> bool:\n        \"\"\"Check if request is allowed under rate limit.\"\"\"\n        now = datetime.utcnow()\n        window_start = now - timedelta(seconds=self.window_seconds)\n        \n        # Remove old requests outside window\n        self.requests[key] = [\n            t for t in self.requests[key]\n            if t > window_start\n        ]\n        \n        # Check limit\n        if len(self.requests[key]) >= self.max_requests:\n            return False\n        \n        # Add current request\n        self.requests[key].append(now)\n        return True\n    \n    def get_remaining(self, key: str) -> int:\n        \"\"\"Get remaining requests in window.\"\"\"\n        window_start = datetime.utcnow() - timedelta(seconds=self.window_seconds)\n        current = len([\n            t for t in self.requests[key]\n            if t > window_start\n        ])\n        return max(0, self.max_requests - current)\n    \n    def get_reset_time(self, key: str) -> datetime:\n        \"\"\"Get time when rate limit resets.\"\"\"\n        window_start = datetime.utcnow() - timedelta(seconds=self.window_seconds)\n        oldest = min(self.requests[key]) if self.requests[key] else datetime.utcnow()\n        return oldest + timedelta(seconds=self.window_seconds)\n```\n\n## Circuit Breaker\n```python\nimport asyncio\nfrom enum import Enum\n\n\nclass CircuitState(Enum):\n    CLOSED = 'closed'\n    OPEN = 'open'\n    HALF_OPEN = 'half_open'\n\n\nclass CircuitBreaker:\n    \"\"\"Circuit breaker pattern for external service calls.\"\"\"\n    \n    def __init__(\n        self,\n        name: str,\n        failure_threshold: int = 5,\n        success_threshold: int = 2,\n        timeout_seconds: int = 60\n    ) -> None:\n        self.name = name\n        self.failure_threshold = failure_threshold\n        self.success_threshold = success_threshold\n        self.timeout_seconds = timeout_seconds\n        \n        self.state = CircuitState.CLOSED\n        self.failure_count = 0\n        self.success_count = 0\n        self.last_failure_time = None\n    \n    async def call(self, coro):\n        \"\"\"Execute coroutine with circuit breaker protection.\"\"\"\n        if self.state == CircuitState.OPEN:\n            if self._should_attempt_reset():\n                self.state = CircuitState.HALF_OPEN\n            else:\n                raise CircuitOpenError(\n                    f\"Circuit {self.name} is open\"\n                )\n        \n        try:\n            result = await coro\n            self._on_success()\n            return result\n        except Exception as e:\n            self._on_failure()\n            raise\n    \n    def _should_attempt_reset(self) -> bool:\n        \"\"\"Check if enough time has passed to retry.\"\"\"\n        if self.last_failure_time is None:\n            return True\n        return (\n            datetime.utcnow() - self.last_failure_time\n        ).total_seconds() >= self.timeout_seconds\n    \n    def _on_success(self) -> None:\n        \"\"\"Handle successful call.\"\"\"\n        if self.state == CircuitState.HALF_OPEN:\n            self.success_count += 1\n            if self.success_count >= self.success_threshold:\n                self.state = CircuitState.CLOSED\n                self.failure_count = 0\n        else:\n            self.failure_count = 0\n    \n    def _on_failure(self) -> None:\n        \"\"\"Handle failed call.\"\"\"\n        self.failure_count += 1\n        self.last_failure_time = datetime.utcnow()\n        \n        if self.failure_count >= self.failure_threshold:\n            self.state = CircuitState.OPEN\n            self.success_count = 0\n```\n\n## Database Scaling Patterns\n\n### Read Replicas\n```\n                    ┌─────────────────┐\n                    │   Application    │\n                    └────────┬────────┘\n                             │\n         ┌────────────────────┼────────────────────┐\n         │                    │                    │\n         ▼                    ▼                    ▼\n    ┌─────────┐          ┌─────────┐          ┌─────────┐\n    │ Primary │──────────│ Replica │──────────│ Replica │\n    │   DB    │ sync     │   DB    │ async    │   DB    │\n    └─────────┘          └─────────┘          └─────────┘\n         │                    │                    │\n         └────────────────────┼────────────────────┘\n                              │\n                    Writes go to Primary\n                    Reads go to Replicas\n```\n\n### Sharding\n```python\ndef get_shard(user_id: str, num_shards: int) -> int:\n    \"\"\"Consistent hashing for sharding.\"\"\"\n    return hash(user_id) % num_shards\n\n\nclass ShardedDatabase:\n    def __init__(self, shards: int) -> None:\n        self.shards = shards\n        self.connections: list[DatabaseConnection] = []\n    \n    async def get_user(self, user_id: str) -> Optional[User]:\n        \"\"\"Route to correct shard.\"\"\"\n        shard_id = get_shard(user_id, self.shards)\n        connection = self.connections[shard_id]\n        return await connection.query(\n            \"SELECT * FROM users WHERE id = ?\",\n            (user_id,)\n        )\n    \n    async def save_user(self, user: User) -> None:\n        \"\"\"Save to appropriate shard.\"\"\"\n        shard_id = get_shard(user.id, self.shards)\n        connection = self.connections[shard_id]\n        await connection.execute(\n            \"INSERT INTO users ...\",\n            (user.id, user.name, ...)\n        )\n```\n","## What I do\n- Design scalable and reliable systems\n- Apply CAP theorem and trade-offs\n- Choose appropriate data storage solutions\n- Design for high availability and fault tolerance\n- Implement caching strategies\n- Handle rate limiting and throttling\n- Design APIs for scalability\n- Consider security from the start\n\n## When to use me\nWhen designing system architecture or reviewing high-level designs.\n\n## CAP Theorem\n```\n         Consistency + Partition Tolerance\n                     \u002F\\\n                    \u002F  \\\n                   \u002F    \\\n                  \u002F      \\\n                 \u002F   AP   \\\n                \u002F          \\\n               \u002F            \\\n              \u002F              \\\n             \u002F                \\\n            \u002F    Consistency   \\\n           \u002F      Availability \\\n          \u002F                    \\\n         \u002F----------------------\\\n        \u002F       CA              \\\n       \u002F                        \\\n      \u002F    Availability          \\\n     \u002F       Consistency         \\\n    \u002F______________________________\\\n\nChoose 2 of 3:\n- CP (Consistency + Partition Tolerance): Databases like MongoDB, Redis Cluster\n- AP (Availability + Partition Tolerance): DynamoDB, Cassandra, CouchDB\n- CA (Consistency + Availability): Not possible with network partitions\n```\n\n## High-Level Design Components\n\n### Load Balancer\n```\n                    ┌──────────────────────────────────────┐\n                    │         Load Balancer                 │\n                    │   (Nginx, AWS ALB, Cloudflare)        │\n                    └──────────────┬───────────────────────┘\n                                   │\n         ┌─────────────┬─────────────┼─────────────┬─────────────┐\n         ▼             ▼             ▼             ▼             ▼\n    ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐\n    │ App     │  │ App     │  │ App     │  │ App     │  │ App     │\n    │ Server  │  │ Server  │  │ Server  │  │ Server  │  │ Server  │\n    │ (x3)    │  │ (x3)    │  │ (x3)    │  │ (x3)    │  │ (x3)    │\n    └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘\n         │             │             │             │             │\n         └─────────────┴─────────────┼─────────────┴─────────────┘\n                                    │\n                    ┌───────────────┴───────────────┐\n                    │        Cache Layer             │\n                    │   (Redis Cluster, Memcached)   │\n                    └───────────────┬───────────────┘\n                                    │\n         ┌─────────────┬─────────────┼─────────────┬─────────────┐\n         ▼             ▼             ▼             ▼             ▼\n    ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐\n    │Primary  │  │Replica  │  │Replica  │  │Replica  │  │Replica  │\n    │DB       │  │DB       │  │DB       │  │DB       │  │DB       │\n    └─────────┘  └─────────┘  └─────────┘  └─────────┘  └─────────┘\n```\n\n## Caching Strategies\n\n### Cache-Aside Pattern\n```python\ndef get_user(user_id: str) -> Optional[User]:\n    \"\"\"Cache-aside: Check cache first, then database.\"\"\"\n    # 1. Check cache\n    cached = cache.get(f\"user:{user_id}\")\n    if cached:\n        return User.from_dict(cached)\n    \n    # 2. Fetch from database\n    user = database.get_user(user_id)\n    if user:\n        # 3. Store in cache with TTL\n        cache.set(f\"user:{user_id}\", user.to_dict(), ttl=3600)\n    \n    return user\n\n\ndef update_user(user_id: str, **kwargs) -> None:\n    \"\"\"On update: Invalidate cache, then update database.\"\"\"\n    # 1. Update database\n    database.update_user(user_id, **kwargs)\n    \n    # 2. Invalidate cache\n    cache.delete(f\"user:{user_id}\")\n```\n\n### Read-Through \u002F Write-Through\n```python\nclass CachedRepository:\n    def __init__(self, cache: Cache, db: Database) -> None:\n        self.cache = cache\n        self.db = db\n    \n    async def get(self, key: str) -> Optional[dict]:\n        \"\"\"Read-through cache.\"\"\"\n        # Check cache first\n        cached = await self.cache.get(key)\n        if cached:\n            return cached\n        \n        # Fetch from DB and cache\n        result = await self.db.query(key)\n        if result:\n            await self.cache.set(key, result, ttl=3600)\n        \n        return result\n    \n    async def set(self, key: str, value: dict) -> None:\n        \"\"\"Write-through: Write to cache and database.\"\"\"\n        await self.db.save(key, value)\n        await self.cache.set(key, value, ttl=3600)\n```\n\n### Write-Behind \u002F Write-Back\n```python\nclass WriteBehindCache:\n    \"\"\"Buffer writes and batch to database.\"\"\"\n    \n    def __init__(self, cache: Redis, db: Database) -> None:\n        self.cache = cache\n        self.db = db\n        self.write_buffer = []\n    \n    async def set(self, key: str, value: dict) -> None:\n        \"\"\"Write to cache immediately, queue for DB.\"\"\"\n        await self.cache.set(key, value)\n        await self.cache.lpush('write_buffer', json.dumps({\n            'key': key,\n            'value': value,\n            'timestamp': time.time(),\n        }))\n    \n    async def flush_buffer(self) -> None:\n        \"\"\"Batch process write buffer to database.\"\"\"\n        while True:\n            item = await self.cache.rpop('write_buffer')\n            if not item:\n                break\n            \n            data = json.loads(item)\n            await self.db.save(data['key'], data['value'])\n```\n\n## Rate Limiting\n```python\nfrom datetime import datetime, timedelta\nfrom collections import defaultdict\n\n\nclass RateLimiter:\n    \"\"\"Token bucket rate limiter with sliding window.\"\"\"\n    \n    def __init__(\n        self,\n        max_requests: int,\n        window_seconds: int\n    ) -> None:\n        self.max_requests = max_requests\n        self.window_seconds = window_seconds\n        self.requests: dict[str, list[datetime]] = defaultdict(list)\n    \n    def is_allowed(self, key: str) -> bool:\n        \"\"\"Check if request is allowed under rate limit.\"\"\"\n        now = datetime.utcnow()\n        window_start = now - timedelta(seconds=self.window_seconds)\n        \n        # Remove old requests outside window\n        self.requests[key] = [\n            t for t in self.requests[key]\n            if t > window_start\n        ]\n        \n        # Check limit\n        if len(self.requests[key]) >= self.max_requests:\n            return False\n        \n        # Add current request\n        self.requests[key].append(now)\n        return True\n    \n    def get_remaining(self, key: str) -> int:\n        \"\"\"Get remaining requests in window.\"\"\"\n        window_start = datetime.utcnow() - timedelta(seconds=self.window_seconds)\n        current = len([\n            t for t in self.requests[key]\n            if t > window_start\n        ])\n        return max(0, self.max_requests - current)\n    \n    def get_reset_time(self, key: str) -> datetime:\n        \"\"\"Get time when rate limit resets.\"\"\"\n        window_start = datetime.utcnow() - timedelta(seconds=self.window_seconds)\n        oldest = min(self.requests[key]) if self.requests[key] else datetime.utcnow()\n        return oldest + timedelta(seconds=self.window_seconds)\n```\n\n## Circuit Breaker\n```python\nimport asyncio\nfrom enum import Enum\n\n\nclass CircuitState(Enum):\n    CLOSED = 'closed'\n    OPEN = 'open'\n    HALF_OPEN = 'half_open'\n\n\nclass CircuitBreaker:\n    \"\"\"Circuit breaker pattern for external service calls.\"\"\"\n    \n    def __init__(\n        self,\n        name: str,\n        failure_threshold: int = 5,\n        success_threshold: int = 2,\n        timeout_seconds: int = 60\n    ) -> None:\n        self.name = name\n        self.failure_threshold = failure_threshold\n        self.success_threshold = success_threshold\n        self.timeout_seconds = timeout_seconds\n        \n        self.state = CircuitState.CLOSED\n        self.failure_count = 0\n        self.success_count = 0\n        self.last_failure_time = None\n    \n    async def call(self, coro):\n        \"\"\"Execute coroutine with circuit breaker protection.\"\"\"\n        if self.state == CircuitState.OPEN:\n            if self._should_attempt_reset():\n                self.state = CircuitState.HALF_OPEN\n            else:\n                raise CircuitOpenError(\n                    f\"Circuit {self.name} is open\"\n                )\n        \n        try:\n            result = await coro\n            self._on_success()\n            return result\n        except Exception as e:\n            self._on_failure()\n            raise\n    \n    def _should_attempt_reset(self) -> bool:\n        \"\"\"Check if enough time has passed to retry.\"\"\"\n        if self.last_failure_time is None:\n            return True\n        return (\n            datetime.utcnow() - self.last_failure_time\n        ).total_seconds() >= self.timeout_seconds\n    \n    def _on_success(self) -> None:\n        \"\"\"Handle successful call.\"\"\"\n        if self.state == CircuitState.HALF_OPEN:\n            self.success_count += 1\n            if self.success_count >= self.success_threshold:\n                self.state = CircuitState.CLOSED\n                self.failure_count = 0\n        else:\n            self.failure_count = 0\n    \n    def _on_failure(self) -> None:\n        \"\"\"Handle failed call.\"\"\"\n        self.failure_count += 1\n        self.last_failure_time = datetime.utcnow()\n        \n        if self.failure_count >= self.failure_threshold:\n            self.state = CircuitState.OPEN\n            self.success_count = 0\n```\n\n## Database Scaling Patterns\n\n### Read Replicas\n```\n                    ┌─────────────────┐\n                    │   Application    │\n                    └────────┬────────┘\n                             │\n         ┌────────────────────┼────────────────────┐\n         │                    │                    │\n         ▼                    ▼                    ▼\n    ┌─────────┐          ┌─────────┐          ┌─────────┐\n    │ Primary │──────────│ Replica │──────────│ Replica │\n    │   DB    │ sync     │   DB    │ async    │   DB    │\n    └─────────┘          └─────────┘          └─────────┘\n         │                    │                    │\n         └────────────────────┼────────────────────┘\n                              │\n                    Writes go to Primary\n                    Reads go to Replicas\n```\n\n### Sharding\n```python\ndef get_shard(user_id: str, num_shards: int) -> int:\n    \"\"\"Consistent hashing for sharding.\"\"\"\n    return hash(user_id) % num_shards\n\n\nclass ShardedDatabase:\n    def __init__(self, shards: int) -> None:\n        self.shards = shards\n        self.connections: list[DatabaseConnection] = []\n    \n    async def get_user(self, user_id: str) -> Optional[User]:\n        \"\"\"Route to correct shard.\"\"\"\n        shard_id = get_shard(user_id, self.shards)\n        connection = self.connections[shard_id]\n        return await connection.query(\n            \"SELECT * FROM users WHERE id = ?\",\n            (user_id,)\n        )\n    \n    async def save_user(self, user: User) -> None:\n        \"\"\"Save to appropriate shard.\"\"\"\n        shard_id = get_shard(user.id, self.shards)\n        connection = self.connections[shard_id]\n        await connection.execute(\n            \"INSERT INTO users ...\",\n            (user.id, user.name, ...)\n        )\n```\n",{"name":5,"license":14,"metadata":40,"description":7,"compatibility":32},{"audience":41,"category":31},"developers","main","5f7a3e453c98261f93d19a6a7de44ad8f7b72d41",2,"https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk","2026-03-01 06:55:40",{"source":8,"skillName":5,"commands":49,"prompt":59,"zipAvailable":60},[50,53,56],{"tool":51,"command":52},"npx","npx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill system-design",{"tool":54,"command":55},"bunx","bunx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill system-design",{"tool":57,"command":58},"pnpm","pnpm dlx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill system-design","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fsystem-design\u002FSKILL.md",true,[],[63,74,84,92,102,111],{"skillNo":64,"name":65,"nameZh":6,"description":66,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":67,"categories":68,"keywords":69,"publishedAt":35},"01M6CXT9TXDF79BWJTMQAPB49G","xamarin","Xamarin cross-platform development","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fxamarin\u002FSKILL.md",[],[65,70,71,72,32,73],"platform","cross-platform","mobile","development",{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":35},"01M6CXT8AD04MFYDA32VW3FKAG","wrangling","Data wrangling fundamentals","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwrangling\u002FSKILL.md",[],[76,81,32,82,83],"data wrangling","science","data",{"skillNo":85,"name":86,"nameZh":6,"description":87,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":90,"publishedAt":35},"01M6CXT717GCN7SRRNPBDP4508","windows","Windows operating system administration and scripting","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwindows\u002FSKILL.md",[],[86,29,32,91],"scripting",{"skillNo":93,"name":94,"nameZh":6,"description":95,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":96,"categories":97,"keywords":98,"publishedAt":35},"01M6CXT54K794NMEM3XAPZZDKT","wide-column","Wide-column data model","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwide-column\u002FSKILL.md",[],[99,100,32,101,83],"wide column","databases","model",{"skillNo":103,"name":104,"nameZh":6,"description":105,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":106,"categories":107,"keywords":108,"publishedAt":35},"01M6CXT28FMT2P4V9GZE67WA8E","wide-column-stores","Wide-column database stores","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwide-column-stores\u002FSKILL.md",[],[109,100,32,110],"wide column stores","database",{"skillNo":112,"name":113,"nameZh":6,"description":114,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":115,"categories":116,"keywords":117,"publishedAt":35},"01M6CXT0D0M0Q4T2N7C2RX7DSN","websockets","WebSocket implementation and best practices","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwebsockets\u002FSKILL.md",[],[113,118,119,120,32,121,122],"websocket","real-time","time","best practices","implementation"]