provider-actions
Implement Terraform Provider actions using the Plugin Framework. Use when developing imperative operations that execute at lifecycle events (before/after create, update, destroy).
95
55%
Does it follow best practices?
Impact
99%
6.18xAverage score across 15 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./terraform/provider-development/skills/provider-actions/SKILL.mdQuality
Discovery
75%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
The description is well-structured with a clear 'what' and 'when' clause, targeting a very specific niche in Terraform provider development. Its main weakness is that it could be more specific about the concrete actions it enables and could include more natural trigger term variations that developers might use when seeking this skill.
Suggestions
Add more specific concrete actions, e.g., 'Define pre/post-create hooks, implement destroy cleanup logic, configure update side effects'.
Include additional trigger term variations users might naturally say, such as 'terraform plugin', 'provider development', 'resource hooks', 'side effects', or 'imperative logic'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Terraform Provider Plugin Framework) and a general action (implement actions/imperative operations at lifecycle events), but doesn't list multiple specific concrete actions like 'define action functions, register lifecycle hooks, handle error responses'. | 2 / 3 |
Completeness | Clearly answers both 'what' (implement Terraform Provider actions using the Plugin Framework) and 'when' (Use when developing imperative operations that execute at lifecycle events before/after create, update, destroy) with explicit trigger guidance. | 3 / 3 |
Trigger Term Quality | Includes relevant terms like 'Terraform Provider', 'Plugin Framework', 'lifecycle events', 'create, update, destroy', but misses common variations users might say such as 'terraform plugin', 'provider development', 'resource actions', 'hooks', or 'side effects'. | 2 / 3 |
Distinctiveness Conflict Risk | Very specific niche targeting Terraform Provider Plugin Framework actions at lifecycle events — this is unlikely to conflict with general Terraform skills, IaC skills, or other provider development skills due to the precise scoping around 'actions' and 'lifecycle events'. | 3 / 3 |
Total | 10 / 12 Passed |
Implementation
35%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is comprehensive in coverage but suffers from excessive verbosity and a reference-manual style that doesn't respect token efficiency. Many sections describe patterns abstractly rather than providing executable, copy-paste-ready code. The content would benefit significantly from being restructured as a concise overview with detailed sub-topics split into separate referenced files.
Suggestions
Reduce the SKILL.md to a concise overview (~100 lines) covering the core workflow steps, and move detailed sections (Common Action Patterns, Testing, Documentation Standards) into separate referenced files.
Remove abstract bullet-point sections like 'Common Action Patterns' that describe patterns without executable code—either provide complete code examples or omit them.
Add an explicit numbered workflow sequence at the top (1. Define schema → 2. Implement Invoke → 3. Compile check → 4. Write tests → 5. Documentation → 6. Changelog) with validation gates between steps.
Replace pseudocode placeholders (e.g., `/* get client for region */`, hypothetical `wait.WaitForStatus`) with either real executable code or clearly mark them as templates requiring customization.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is extremely verbose at ~400+ lines, with significant redundancy (e.g., schema validation checklist repeats schema issues section, pre-submission checklist repeats earlier points). It explains many concepts Claude already knows (error handling patterns, pagination, basic Go testing) and includes generic patterns like 'Handle partial failures gracefully' that add no actionable value. | 1 / 3 |
Actionability | Code examples are provided for schema definition, invoke method, error handling, polling, and testing, which is good. However, many examples are semi-pseudocode (e.g., the polling example uses hypothetical `wait.WaitForStatus` API, sweep functions use placeholder comments like `/* get client for region */`), and several sections give vague bullet-point guidance rather than executable code (e.g., 'Common Action Patterns' section is entirely abstract). | 2 / 3 |
Workflow Clarity | The document covers the full lifecycle from schema to testing to documentation, and includes checklists. However, the workflow is not clearly sequenced as a step-by-step process—it reads more like a reference document with scattered sections. The pre-submission checklist provides some validation, but there are no explicit feedback loops for catching errors during development (e.g., 'compile after schema changes, fix, then proceed'). | 2 / 3 |
Progressive Disclosure | The document has clear section headers and some external references at the top and bottom, but it's a monolithic wall of content that should be split into separate files (e.g., testing patterns, documentation standards, common patterns could each be their own reference). The inline content is far too long for a SKILL.md overview. | 2 / 3 |
Total | 7 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- hashicorp/agent-skills
- Commit
de4323a
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.