implement-claude-extensions
npx machina-cli add skill yu-iskw/google-cloud-observability-plugin/implement-claude-extensions --openclawImplement Claude Extensions
Use this umbrella skill to choose the correct extension type and route implementation to the appropriate component skill.
Core Principle: Start simple. Use the decision framework to score task complexity (0-10) and match to the simplest component type that meets requirements.
Complexity-Based Selection
| Score | Component Type | When to Use |
|---|---|---|
| 1-3 | Simple Skill | Single deterministic task, no branching logic |
| 4-6 | Workflow Skill | Multi-step with some conditional logic |
| 7-8 | Sub-Agent | Model-driven decisions, flexible approach needed |
| 9-10 | Agent Team | Multiple specialized domains, complex coordination |
See references/decision-framework.md for detailed scoring guide.
Comparison
| Extension Type | Best For | Primary Artifacts | Component Skill |
|---|---|---|---|
| Hooks | Event-driven automation/guardrails | hooks/hooks.json, hook scripts | ../implement-hooks/SKILL.md |
| Agent Skills | Reusable task playbooks | skills/<name>/SKILL.md | ../implement-agent-skills/SKILL.md |
| Sub-Agents | Specialized delegated roles | agents/*.md | ../implement-sub-agents/SKILL.md |
| Agent Teams | Coordinated multi-agent execution | team config + coordination docs | ../implement-agent-teams/SKILL.md |
| Plugins | Packaging/distribution + wiring | .claude-plugin/plugin.json | ../implement-plugin/SKILL.md |
Workflow
- Assess complexity: Score task complexity using decision framework (0-10)
- Start simple: Choose simplest component type that meets requirements
- Validate choice: Ask "Can this be done more simply?"
- Identify constraints: Determine specific requirements and boundaries
- Plan evaluations: Define 20-50 test cases for validation
- Route implementation: Hand off to appropriate component skill
- Apply lifecycle checks: Follow design → implement → evaluate → verify
Progressive Disclosure
Best Practices (Anthropic Guidelines)
- START HERE - Complexity scoring & decision framework:
references/decision-framework.md - Context management patterns:
references/context-management.md - Evaluation strategy:
references/evaluation-strategy.md
Component Selection
- Extension comparison details:
references/extension-types.md - Decision guide:
references/when-to-use.md - Cross-component patterns:
references/cross-component-patterns.md - Lifecycle from design to verification:
references/extension-lifecycle.md
Component Skills
../implement-hooks/SKILL.md../implement-agent-skills/SKILL.md../implement-sub-agents/SKILL.md../implement-agent-teams/SKILL.md../implement-plugin/SKILL.md
Sources
Source
git clone https://github.com/yu-iskw/google-cloud-observability-plugin/blob/main/.claude/skills/implement-claude-extensions/SKILL.mdView on GitHub Overview
Use this umbrella skill to determine the correct Claude extension type (hooks, agent skills, sub-agents, agent teams, or plugins) and route implementation to the appropriate component skill. It scores task complexity (0-10) and selects the simplest type that meets requirements, keeping workflows maintainable and scalable.
How This Skill Works
Score the task using the decision framework (0-10), then select the smallest extension type that satisfies constraints. Route the implementation to the matching component skill (hooks, agent-skills, sub-agents, agent-teams, or plugin) and apply lifecycle checks (design → implement → evaluate → verify) before delivery.
When to Use It
- You need event-driven automation or guardrails and want to implement with Hooks.
- The task is a multi-step process with conditional logic requiring a Workflow Skill.
- Model-driven decisions require flexible, delegated roles handled by Sub-Agents.
- Coordinated work across multiple domains requires an Agent Team.
- Packaging, distribution, or wiring is needed via Claude plugins.
Quick Start
- Step 1: Assess complexity with the decision framework (0-10).
- Step 2: Choose the simplest extension type that satisfies requirements (Hooks, Agent Skills, Sub-Agents, Agent Teams, or Plugin).
- Step 3: Route implementation to the appropriate component skill and apply lifecycle checks.
Best Practices
- Score complexity from 0 to 10 before selecting an extension type.
- Start with the simplest viable type (Hooks or Simple Skill) when possible.
- Always ask: can this be done more simply? if yes, downgrade the extension type.
- Document constraints, boundaries, and expected lifecycle stages up front.
- Refer to references/decision-framework.md and references/extension-types.md during design.
Example Use Cases
- Implementing an event-driven alerting workflow using a Hooks extension.
- A multi-step user onboarding process implemented as a Workflow Skill with conditional branches.
- A task requiring model-driven decisions routed to a Sub-Agent for specialized handling.
- Coordinated reporting across teams implemented as an Agent Team.
- Packaging a feature as a Claude plugin for distribution.
