devskill 2.0.7 → 2.0.8

package/skills/cli-mastery/references/module-1-slash-commands.md

@@ -0,0 +1,88 @@
+# Module 1: Slash Commands
+
+Teach these categories one at a time, with examples and "when to use" guidance.
+
+## Getting Started
+
+| Command | What it does | When to use |
+|---------|-------------|-------------|
+| `/login` | Authenticate with GitHub | First launch or expired session |
+| `/logout` | Sign out | Switching accounts |
+| `/help` | Show all commands | When lost |
+| `/exit` `/quit` | Exit CLI | Done working |
+| `/init` | Bootstrap copilot-instructions.md | New repo setup |
+| `/terminal-setup` | Configure multiline input | First-time setup |
+
+## Models & Agents
+
+| Command | What it does | When to use |
+|---------|-------------|-------------|
+| `/model` | Switch AI model | Need different capability/speed |
+| `/agent` | Browse/select agents | Delegate to specialist |
+| `/fleet` | Enable parallel subagents | Complex multi-part tasks |
+| `/tasks` | View background tasks | Check on running subagents |
+
+## Code & Review
+
+| Command | What it does | When to use |
+|---------|-------------|-------------|
+| `/diff` | Review changes in current dir | Before committing |
+| `/review` | Run code review agent | Get feedback on changes |
+| `/lsp` | Manage language servers | Need go-to-def, diagnostics |
+| `/ide` | Connect to IDE workspace | Want IDE integration |
+
+## Session & Context
+
+| Command | What it does | When to use |
+|---------|-------------|-------------|
+| `/context` | Show token usage visualization | Context getting large |
+| `/usage` | Display session metrics | Check premium request count |
+| `/compact` | Compress conversation history | Near context limit |
+| `/session` | Show session info | Need session details |
+| `/resume` | Switch to different session | Continue previous work |
+| `/rename` | Rename current session | Better organization |
+| `/share` | Export session to markdown/gist | Share with team |
+| `/copy` | Copy last response to clipboard | Grab AI output quickly |
+| `/clear` | Clear conversation history | Fresh start |
+
+## Permissions & Directories
+
+| Command | What it does | When to use |
+|---------|-------------|-------------|
+| `/allow-all` | Enable all permissions | Trusted environment, move fast |
+| `/add-dir` | Add trusted directory | Working across projects |
+| `/list-dirs` | Show allowed directories | Check access scope |
+| `/cwd` | Change working directory | Switch project context |
+| `/reset-allowed-tools` | Revoke tool approvals | Tighten security |
+
+## Configuration & Customization
+
+| Command | What it does | When to use |
+|---------|-------------|-------------|
+| `/instructions` | View active instruction files | Debug custom behavior |
+| `/experimental` | Toggle experimental features | Try autopilot mode |
+| `/theme` | Change terminal theme | Personalize |
+| `/streamer-mode` | Hide sensitive info | Livestreaming/demos |
+| `/changelog` | Show release notes | After update |
+| `/update` | Update CLI | New version available |
+| `/feedback` | Submit feedback | Report bug or request |
+
+## Extensibility
+
+| Command | What it does | When to use |
+|---------|-------------|-------------|
+| `/skills` | Manage skills | Browse/enable capabilities |
+| `/mcp` | Manage MCP servers | Add external tools |
+| `/plugin` | Manage plugins | Extend functionality |
+
+## Workflows & Research
+
+| Command | What it does | When to use |
+|---------|-------------|-------------|
+| `/plan` | Create implementation plan | Before complex changes |
+| `/research` | Run deep research investigation | Need thorough analysis with sources |
+| `/user` | Manage GitHub user list | Team context |
+
+## Quiz (5+ questions, use ask_user with 4 choices each)
+
+Ask "Which command would you use to [scenario]?" style questions.

package/skills/cli-mastery/references/module-2-keyboard-shortcuts.md

@@ -0,0 +1,38 @@
+# Module 2: Keyboard Shortcuts
+
+## Navigation & Editing
+
+| Shortcut | Action |
+|----------|--------|
+| `@` | Mention files — include their contents as context |
+| `Ctrl+S` | Submit prompt while preserving input text |
+| `Shift+Tab` | Cycle modes: Interactive → Plan |
+| `Ctrl+T` | Toggle model reasoning display |
+| `Ctrl+O` | Expand recent timeline (when no input) |
+| `Ctrl+E` | Expand all timeline (when no input) / move to end of line (when typing) |
+| `↑` `↓` | Navigate command history |
+| `!` | Execute shell command directly (bypass AI) |
+| `Esc` | Cancel current operation |
+| `Ctrl+C` | Cancel operation / clear input / exit |
+| `Ctrl+D` | Shutdown session |
+| `Ctrl+L` | Clear the screen |
+| `Ctrl+G` | Edit prompt in external editor ($EDITOR) |
+
+## Line Editing
+
+| Shortcut | Action |
+|----------|--------|
+| `Ctrl+A` | Move to beginning of line |
+| `Ctrl+H` | Delete previous character |
+| `Ctrl+W` | Delete previous word |
+| `Ctrl+U` | Delete from cursor to beginning of line |
+| `Ctrl+K` | Delete from cursor to end of line |
+| `Meta+←` `Meta+→` | Move cursor by word |
+
+## Pro tips to teach
+
+- `@` is THE most important shortcut — it's how you give precise context
+- `!git status` runs git directly without AI processing
+- `Shift+Tab` into Plan mode BEFORE complex tasks
+- `Ctrl+G` opens your $EDITOR for long prompts — game changer
+- `Ctrl+S` lets you iterate on a prompt without retyping

package/skills/cli-mastery/references/module-3-modes.md

@@ -0,0 +1,33 @@
+# Module 3: Interaction Modes
+
+## Interactive Mode (default)
+
+- AI acts immediately on your prompts
+- Asks permission for risky operations
+- Best for: quick tasks, debugging, exploring code
+- 80% of your time will be here
+
+## Plan Mode (`Shift+Tab` or `/plan`)
+
+- AI creates a step-by-step plan FIRST
+- You review and approve before execution
+- Best for: complex refactoring, architecture changes, risky operations
+- Key insight: Use this when mistakes are expensive
+
+## Autopilot Mode (experimental, `/experimental`)
+
+- AI acts without asking for confirmation
+- Best for: trusted environments, long-running tasks
+- Use with caution — pair with `/allow-all` or `--yolo`
+
+## Mode Comparison
+
+| Feature | Interactive | Plan | Autopilot |
+|---------|------------|------|-----------|
+| Speed | Fast | Slower | Fastest |
+| Safety | Medium | Highest | Lowest |
+| Control | You approve each action | You approve the plan | Full AI autonomy |
+| Best for | Daily tasks | Complex changes | Repetitive/trusted work |
+| Switch | Default | Shift+Tab or /plan | /experimental (enables), then Shift+Tab |
+
+Teaching point: The right mode at the right time = 10x productivity.

package/skills/cli-mastery/references/module-4-agents.md

@@ -0,0 +1,42 @@
+# Module 4: Agent System
+
+## Built-in Agents
+
+| Agent | Model | Best For | Key Trait |
+|-------|-------|----------|-----------|
+| `explore` | Haiku | Fast codebase Q&A | Read-only, <300 words, safe to parallelize |
+| `task` | Haiku | Running commands (tests, builds, lints) | Brief on success, verbose on failure |
+| `general-purpose` | Sonnet | Complex multi-step tasks | Full toolset, separate context window |
+| `code-review` | Sonnet | Analyzing code changes | Never modifies code, high signal-to-noise |
+
+## Custom Agents — define your own in Markdown
+
+| Level | Location | Scope |
+|-------|----------|-------|
+| Personal | `~/.copilot/agents/*.md` | All your projects |
+| Project | `.github/agents/*.md` | Everyone on this repo |
+| Organization | `.github-private/agents/` in org repo | Entire org |
+
+## Agent file anatomy
+
+```markdown
+---
+name: my-agent
+description: What this agent does
+tools:
+  - bash
+  - edit
+  - view
+---
+
+# Agent Instructions
+Your detailed behavior instructions here.
+```
+
+## Agent orchestration patterns
+
+1. **Fan-out exploration** — Launch multiple `explore` agents in parallel to answer different questions simultaneously
+2. **Pipeline** — `explore` → understand → `general-purpose` → implement → `code-review` → verify
+3. **Specialist handoff** — Identify task → `/agent` to pick specialist → review with `/fleet` or `/tasks`
+
+Key insight: The AI automatically delegates to subagents when appropriate.

package/skills/cli-mastery/references/module-5-skills.md

@@ -0,0 +1,33 @@
+# Module 5: Skills System
+
+## What are skills?
+
+- Specialized capability packages the AI can invoke
+- Think of them as "expert modes" with domain-specific knowledge
+- Managed via `/skills` command
+
+## Skill locations
+
+| Level | Location |
+|-------|----------|
+| User | `~/.copilot/skills/<name>/SKILL.md` |
+| Repo | `.github/skills/<name>/SKILL.md` |
+| Org | Shared via org-level config |
+
+## Creating a custom skill
+
+1. Create the directory: `mkdir -p ~/.copilot/skills/my-skill/`
+2. Create `SKILL.md` with YAML frontmatter (`name`, `description`, optional `tools`)
+3. Write detailed instructions for the AI's behavior
+4. Verify with `/skills`
+
+## Skill design best practices
+
+- **Clear description** — helps the AI match tasks to your skill automatically
+- **Focused scope** — each skill should do ONE thing well
+- **Include instructions** — specify exactly how the skill should operate
+- **Test thoroughly** — use `/skills` to verify, then invoke and check results
+
+## Auto-matching
+
+When you describe a task, the AI checks if any skill matches and suggests using it.

package/skills/cli-mastery/references/module-6-mcp.md

@@ -0,0 +1,50 @@
+# Module 6: MCP Integration
+
+## What is MCP?
+
+- Model Context Protocol — a standard for connecting AI to external tools
+- Think of it as "USB ports for AI" — plug in any compatible tool
+- The GitHub MCP server is **built-in** (search repos, issues, PRs, actions)
+
+## Key commands
+
+| Command | What it does |
+|---------|-------------|
+| `/mcp` | List connected MCP servers |
+| `/mcp add <name> <command>` | Add a new MCP server |
+
+## Popular MCP servers
+
+- `@modelcontextprotocol/server-postgres` — Query PostgreSQL databases
+- `@modelcontextprotocol/server-sqlite` — Query SQLite databases
+- `@modelcontextprotocol/server-filesystem` — Access local files with permissions
+- `@modelcontextprotocol/server-memory` — Persistent knowledge graph
+- `@modelcontextprotocol/server-puppeteer` — Browser automation
+
+## Configuration
+
+| Level | File |
+|-------|------|
+| User | `~/.copilot/mcp-config.json` |
+| Project | `.github/mcp-config.json` |
+
+## Config file format
+
+```json
+{
+  "mcpServers": {
+    "my-server": {
+      "command": "npx",
+      "args": ["@modelcontextprotocol/server-postgres", "{{env.DATABASE_URL}}"],
+      "env": { "NODE_ENV": "development" }
+    }
+  }
+}
+```
+
+## Security best practices
+
+- Never put credentials directly in config files
+- Use environment variable references: `{{env.SECRET}}`
+- Review MCP server source before using
+- Only connect servers you actually need

package/skills/cli-mastery/references/module-7-advanced.md

@@ -0,0 +1,38 @@
+# Module 7: Advanced Techniques
+
+1. **`@` file mentions** — Always give precise context, don't rely on the AI finding files
+   - `@src/auth.ts` — single file
+   - `@src/components/` — directory listing
+   - "Fix @src/auth.ts to match @tests/auth.test.ts" — multi-file context
+
+2. **`! shell bypass`** — `!git log --oneline -5` runs instantly, no AI overhead
+
+3. **`/research`** — Run a deep research investigation using GitHub search and web sources
+
+4. **`/resume` + `--continue`** — Session continuity across CLI launches
+
+5. **`/compact`** — Compress history when context gets large (auto at 95%)
+   - Check with `/context` first
+   - Best used at natural task boundaries
+   - Warning signs: AI contradicting earlier statements, token usage >80%
+
+6. **`/context`** — Visualize what's eating your token budget
+
+7. **Custom instructions precedence** (highest to lowest):
+   - `CLAUDE.md` / `GEMINI.md` / `AGENTS.md` (git root + cwd)
+   - `.github/instructions/**/*.instructions.md` (path-specific!)
+   - `.github/copilot-instructions.md`
+   - `~/.copilot/copilot-instructions.md`
+   - `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` (additional directories via env var)
+
+8. **Path-specific instructions:**
+   - `.github/instructions/backend.instructions.md` with `applyTo: "src/api/**"`
+   - Different coding standards for different parts of the codebase
+
+9. **LSP config** — `~/.copilot/lsp-config.json` or `.github/lsp.json`
+
+10. **`/review`** — Get code review without leaving terminal
+
+11. **`--allow-all` / `--yolo`** — Full trust mode (use responsibly!)
+
+12. **`Ctrl+T`** — Watch the AI think (learn its reasoning patterns)

package/skills/cli-mastery/references/module-8-configuration.md

@@ -0,0 +1,34 @@
+# Module 8: Configuration
+
+## Key files
+
+| File | Purpose |
+|------|---------|
+| `~/.copilot/config.json` | Main settings (model, theme, logging, experimental flags) |
+| `~/.copilot/mcp-config.json` | MCP servers |
+| `~/.copilot/lsp-config.json` | Language servers (user-level) |
+| `.github/lsp.json` | Language servers (repo-level) |
+| `~/.copilot/copilot-instructions.md` | Global custom instructions |
+| `.github/copilot-instructions.md` | Repo-level custom instructions |
+
+## Environment variables
+
+| Variable | Purpose |
+|----------|---------|
+| `EDITOR` | Text editor for `Ctrl+G` (edit prompt in external editor) |
+| `COPILOT_LOG_LEVEL` | Logging verbosity (error/warn/info/debug/trace) |
+| `GH_TOKEN` / `GITHUB_TOKEN` | GitHub authentication token (checked in order) |
+| `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` | Additional directories for custom instructions |
+
+## Permissions model
+
+- Default: confirmation required for edits, creates, shell commands
+- `/allow-all` or `--yolo`: skip all confirmations for the session
+- `/reset-allowed-tools`: re-enable confirmations
+- Directory allowlists, tool approval gates, MCP server trust
+
+## Logging levels
+
+error, warn, info, debug, trace (`COPILOT_LOG_LEVEL=debug copilot`)
+
+Use debug/trace for: MCP connection issues, tool failures, unexpected behavior, bug reports

package/skills/cli-mastery/references/scenarios.md

@@ -0,0 +1,44 @@
+# Scenario Challenges
+
+Present these as real-world situations. Ask the user what commands/shortcuts they'd use.
+Use `ask_user` with choices for each step.
+
+## Scenario 1: Hotfix Review Under Pressure
+> A production bug fix is ready. You need to inspect the diff, run code review, and keep sensitive data hidden because you're on a livestream.
+
+**Answer:** `/streamer-mode` → `/diff` → `/review @src/payment.ts`
+
+## Scenario 2: Context Window Rescue
+> Your session is huge and model quality is dropping. Keep continuity while shrinking noise.
+
+**Answer:** `/context` → `/compact` → `/resume` (or restart with `--continue`)
+
+## Scenario 3: Autonomous Refactor Sprint
+> You want an agent to execute a refactor with minimal prompts, but only after reviewing a plan and setting permissions.
+
+**Answer:** `Shift+Tab` (Plan mode) → validate plan → `/allow-all` → execute in Autopilot mode
+
+## Scenario 4: Enterprise Onboarding
+> Set up custom agents, repo instructions, and MCP integration for a new team repository.
+
+**Answer:** Add agent profiles to `.github/agents/`, verify `/instructions`, then `/mcp add`
+
+## Scenario 5: Power Editing Session
+> You're crafting a long prompt and need to edit quickly without losing context.
+
+**Answer:** `Ctrl+G` (open in editor), `Ctrl+A` (jump to start), `Ctrl+K` (trim)
+
+## Scenario 6: Agent Orchestration
+> You're leading a complex project: understand code, run tests, refactor, then review.
+
+**Answer:** `explore` agent (understand) → `task` agent (tests) → `general-purpose` (refactor) → `code-review` (verify)
+
+## Scenario 7: New Project Setup
+> You cloned a new repo and need to set up Copilot CLI for max productivity.
+
+**Answer:** `/init` → `/model` → `/mcp add` (if needed) → `Shift+Tab` to Plan mode for first task
+
+## Scenario 8: Production Safety
+> Switching from boilerplate work to production deployment scripts.
+
+**Answer:** `/reset-allowed-tools` → Plan mode → `/review` before every commit

package/skills/cloud-design-patterns/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/cloud-design-patterns/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: cloud-design-patterns
+description: 'Cloud design patterns for distributed systems architecture covering 42 industry-standard patterns across reliability, performance, messaging, security, and deployment categories. Use when designing, reviewing, or implementing distributed system architectures.'
+---
+
+# Cloud Design Patterns
+
+Architects design workloads by integrating platform services, functionality, and code to meet both functional and nonfunctional requirements. To design effective workloads, you must understand these requirements and select topologies and methodologies that address the challenges of your workload's constraints. Cloud design patterns provide solutions to many common challenges.
+
+System design heavily relies on established design patterns. You can design infrastructure, code, and distributed systems by using a combination of these patterns. These patterns are crucial for building reliable, highly secure, cost-optimized, operationally efficient, and high-performing applications in the cloud.
+
+The following cloud design patterns are technology-agnostic, which makes them suitable for any distributed system. You can apply these patterns across Azure, other cloud platforms, on-premises setups, and hybrid environments.
+
+## How Cloud Design Patterns Enhance the Design Process
+
+Cloud workloads are vulnerable to the fallacies of distributed computing, which are common but incorrect assumptions about how distributed systems operate. Examples of these fallacies include:
+
+- The network is reliable.
+- Latency is zero.
+- Bandwidth is infinite.
+- The network is secure.
+- Topology doesn't change.
+- There's one administrator.
+- Component versioning is simple.
+- Observability implementation can be delayed.
+
+These misconceptions can result in flawed workload designs. Design patterns don't eliminate these misconceptions but help raise awareness, provide compensation strategies, and provide mitigations. Each cloud design pattern has trade-offs. Focus on why you should choose a specific pattern instead of how to implement it.
+
+---
+
+## References
+
+| Reference | When to load |
+|---|---|
+| [Reliability & Resilience Patterns](references/reliability-resilience.md) | Ambassador, Bulkhead, Circuit Breaker, Compensating Transaction, Retry, Health Endpoint Monitoring, Leader Election, Saga, Sequential Convoy |
+| [Performance Patterns](references/performance.md) | Async Request-Reply, Cache-Aside, CQRS, Index Table, Materialized View, Priority Queue, Queue-Based Load Leveling, Rate Limiting, Sharding, Throttling |
+| [Messaging & Integration Patterns](references/messaging-integration.md) | Choreography, Claim Check, Competing Consumers, Messaging Bridge, Pipes and Filters, Publisher-Subscriber, Scheduler Agent Supervisor |
+| [Architecture & Design Patterns](references/architecture-design.md) | Anti-Corruption Layer, Backends for Frontends, Gateway Aggregation/Offloading/Routing, Sidecar, Strangler Fig |
+| [Deployment & Operational Patterns](references/deployment-operational.md) | Compute Resource Consolidation, Deployment Stamps, External Configuration Store, Geode, Static Content Hosting |
+| [Security Patterns](references/security.md) | Federated Identity, Quarantine, Valet Key |
+| [Event-Driven Architecture Patterns](references/event-driven.md) | Event Sourcing |
+| [Best Practices & Pattern Selection](references/best-practices.md) | Selecting appropriate patterns, Well-Architected Framework alignment, documentation, monitoring |
+| [Azure Service Mappings](references/azure-service-mappings.md) | Common Azure services for each pattern category |
+
+---
+
+## Pattern Categories at a Glance
+
+| Category | Patterns | Focus |
+|---|---|---|
+| Reliability & Resilience | 9 patterns | Fault tolerance, self-healing, graceful degradation |
+| Performance | 10 patterns | Caching, scaling, load management, data optimization |
+| Messaging & Integration | 7 patterns | Decoupling, event-driven communication, workflow coordination |
+| Architecture & Design | 7 patterns | System boundaries, API gateways, migration strategies |
+| Deployment & Operational | 5 patterns | Infrastructure management, geo-distribution, configuration |
+| Security | 3 patterns | Identity, access control, content validation |
+| Event-Driven Architecture | 1 pattern | Event sourcing and audit trails |
+
+## External Links
+
+- [Cloud Design Patterns - Azure Architecture Center](https://learn.microsoft.com/azure/architecture/patterns/)
+- [Azure Well-Architected Framework](https://learn.microsoft.com/azure/architecture/framework/)

package/skills/cloud-design-patterns/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/cloud-design-patterns`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/cloud-design-patterns/references/architecture-design.md

@@ -0,0 +1,127 @@
+# Architecture & Design Patterns
+
+## Anti-Corruption Layer Pattern
+
+**Problem**: New systems must integrate with legacy systems that use outdated models or technologies.
+
+**Solution**: Implement a façade or adapter layer between a modern application and a legacy system to prevent legacy constraints from affecting new design.
+
+**When to Use**:
+- Migrating from legacy systems incrementally
+- Integrating with third-party systems with different domain models
+- Protecting modern architectures from legacy constraints
+
+**Implementation Considerations**:
+- Create translation layer between domain models
+- Map between legacy and modern data structures
+- Isolate legacy system interfaces behind abstractions
+- Consider performance impact of translation
+- Plan for eventual removal if migration is complete
+
+## Backends for Frontends (BFF) Pattern
+
+**Problem**: A single backend may not optimally serve different client types.
+
+**Solution**: Create separate backend services to serve specific frontend applications or interfaces.
+
+**When to Use**:
+- Different client types (web, mobile, IoT) have different needs
+- Optimizing payload size and shape per client
+- Reducing coupling between frontend and shared backend
+
+**Implementation Considerations**:
+- Create one BFF per user experience or client type
+- Tailor API contracts to frontend needs
+- Avoid duplicating business logic across BFFs
+- Share common services between BFFs
+- Manage increased number of services
+
+## Gateway Aggregation Pattern
+
+**Problem**: Clients need data from multiple backend services.
+
+**Solution**: Use a gateway to aggregate multiple individual requests into a single request.
+
+**When to Use**:
+- Reducing chattiness between clients and backends
+- Combining data from multiple sources for a single view
+- Reducing latency by parallelizing backend calls
+
+**Implementation Considerations**:
+- API gateway aggregates responses from multiple services
+- Execute backend calls in parallel where possible
+- Handle partial failures appropriately
+- Consider caching of aggregated responses
+- Avoid creating a monolithic gateway
+
+## Gateway Offloading Pattern
+
+**Problem**: Shared functionality is duplicated across multiple services.
+
+**Solution**: Offload shared or specialized service functionality to a gateway proxy.
+
+**When to Use**:
+- Centralizing cross-cutting concerns (SSL, authentication, logging)
+- Simplifying service implementation
+- Standardizing shared functionality
+
+**Implementation Considerations**:
+- Offload SSL termination to gateway
+- Implement authentication and authorization at gateway
+- Handle rate limiting and throttling
+- Provide request/response logging
+- Avoid making gateway a bottleneck
+
+## Gateway Routing Pattern
+
+**Problem**: Clients need to access multiple services through a single endpoint.
+
+**Solution**: Route requests to multiple services using a single endpoint.
+
+**When to Use**:
+- Providing a single entry point for multiple services
+- Abstracting backend service topology from clients
+- Enabling service versioning and migration strategies
+
+**Implementation Considerations**:
+- Route based on URL path, headers, or query parameters
+- Support URL rewriting and transformation
+- Enable A/B testing and canary deployments
+- Implement health checks for backend services
+- Monitor routing performance
+
+## Sidecar Pattern
+
+**Problem**: Applications need auxiliary functionality without coupling.
+
+**Solution**: Deploy components of an application into a separate process or container to provide isolation and encapsulation.
+
+**When to Use**:
+- Adding functionality to applications without modifying them
+- Implementing cross-cutting concerns (logging, monitoring, security)
+- Supporting heterogeneous environments
+
+**Implementation Considerations**:
+- Deploy sidecar alongside main application
+- Share lifecycle, resources, and network with main application
+- Use for proxying, logging, configuration, or monitoring
+- Consider resource overhead of additional containers
+- Standardize sidecar implementations across services
+
+## Strangler Fig Pattern
+
+**Problem**: Legacy systems are risky to replace all at once.
+
+**Solution**: Incrementally migrate a legacy system by gradually replacing specific pieces of functionality with new applications and services.
+
+**When to Use**:
+- Modernizing legacy applications
+- Reducing risk of big-bang migrations
+- Enabling incremental business value delivery
+
+**Implementation Considerations**:
+- Identify functionality to migrate incrementally
+- Use facade or proxy to route between old and new
+- Migrate less risky components first
+- Run old and new systems in parallel initially
+- Plan for eventual decommissioning of legacy system

package/skills/cloud-design-patterns/references/azure-service-mappings.md

@@ -0,0 +1,13 @@
+# Azure Service Mappings
+
+## Common Azure Services per Pattern
+
+- **Message Queue**: Azure Service Bus, Azure Storage Queue, Event Hubs
+- **Cache**: Azure Cache for Redis, Azure Front Door cache
+- **API Gateway**: Azure API Management, Azure Application Gateway
+- **Identity**: Azure AD, Azure AD B2C
+- **Configuration**: Azure App Configuration, Azure Key Vault
+- **Storage**: Azure Storage (Blob, Table, Queue), Azure Cosmos DB
+- **Compute**: Azure Functions, Azure Container Apps, Azure Kubernetes Service
+- **Event Streaming**: Azure Event Hubs, Azure Event Grid
+- **CDN**: Azure CDN, Azure Front Door