terraform-module-library
Build reusable Terraform modules for AWS, Azure, GCP, and OCI infrastructure following infrastructure-as-code best practices. Use when creating infrastructure modules, standardizing cloud provisioning, or implementing reusable IaC components.
59
67%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/cloud-infrastructure/skills/terraform-module-library/SKILL.mdQuality
Discovery
82%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is a solid description that clearly identifies its domain (Terraform modules across major cloud providers) and includes an explicit 'Use when' clause with relevant trigger scenarios. Its main weaknesses are that the specific actions could be more granular (e.g., listing concrete module operations) and the trigger terms, while good for Terraform, include some broader IaC terms that could cause overlap with other infrastructure skills.
Suggestions
Add more specific concrete actions like 'define input variables, create output blocks, structure module hierarchies, configure provider blocks, and write module documentation'
Narrow the 'Use when' clause to reduce overlap with non-Terraform IaC tools, e.g., explicitly mention '.tf files' or 'HCL' to strengthen distinctiveness
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Terraform modules) and lists cloud providers (AWS, Azure, GCP, OCI), but the actions are somewhat general — 'build reusable Terraform modules' and 'following best practices' rather than listing specific concrete actions like 'define variable inputs, create output blocks, write provider configurations, structure module hierarchies'. | 2 / 3 |
Completeness | Clearly answers both 'what' (build reusable Terraform modules for multiple cloud providers following IaC best practices) and 'when' (explicit 'Use when' clause covering creating infrastructure modules, standardizing cloud provisioning, or implementing reusable IaC components). | 3 / 3 |
Trigger Term Quality | Includes strong natural keywords users would say: 'Terraform', 'modules', 'AWS', 'Azure', 'GCP', 'OCI', 'infrastructure-as-code', 'IaC', 'cloud provisioning', 'infrastructure modules'. Good coverage of terms and abbreviations a user would naturally use. | 3 / 3 |
Distinctiveness Conflict Risk | While Terraform modules is a fairly specific niche, the description could overlap with general cloud infrastructure skills, CloudFormation skills, or Pulumi skills. The mention of 'cloud provisioning' and 'infrastructure-as-code' is broad enough to potentially conflict with non-Terraform IaC tools. | 2 / 3 |
Total | 10 / 12 Passed |
Implementation
52%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
The skill excels at providing concrete, executable Terraform code examples with proper HCL patterns including validation blocks and module composition. However, it lacks a clear sequential workflow with validation checkpoints (no `terraform validate`, `terraform plan`, or `terraform fmt` steps), which is critical for infrastructure operations. The content is somewhat verbose with sections that explain things Claude already knows, and references non-existent bundle files.
Suggestions
Add an explicit step-by-step workflow for module creation that includes validation checkpoints: `terraform fmt`, `terraform validate`, `terraform plan` review before apply, and error recovery guidance.
Remove the 'Purpose' and 'When to Use' sections (or reduce to one line) since this context is already in the skill description/frontmatter and Claude understands when to use Terraform modules.
Move the full VPC module example (main.tf, variables.tf, outputs.tf) and the Terratest example into bundle reference files, keeping only a concise snippet inline with links to the full examples.
Either provide the referenced `references/aws-modules.md` and `references/oci-modules.md` bundle files or remove the dangling references.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary content like the 'Purpose' and 'When to Use' sections that explain obvious context Claude already knows. The code examples are well-structured but the overall document is quite long (~200 lines) with content that could be trimmed or split into reference files. The 'Best Practices' list is somewhat generic knowledge. | 2 / 3 |
Actionability | The skill provides fully executable, copy-paste ready HCL code for a complete VPC module (main.tf, variables.tf, outputs.tf), a concrete module composition example, and a working Go test file. Variable validation blocks and real CIDR values make this immediately usable. | 3 / 3 |
Workflow Clarity | There is no clear sequential workflow for creating a module. The content presents patterns and examples but lacks a step-by-step process with validation checkpoints. For infrastructure operations (which are destructive), there's no mention of `terraform plan` before `apply`, no validation steps like `terraform validate` or `terraform fmt`, and no feedback loops for error recovery. | 1 / 3 |
Progressive Disclosure | The skill references `references/aws-modules.md` and `references/oci-modules.md` but no bundle files exist to support these references. The main file contains a large amount of inline code that could be split into separate reference files (e.g., the full VPC module example, the test example). The directory structure diagrams are helpful but the overall organization puts too much detail inline. | 2 / 3 |
Total | 8 / 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
- wshobson/agents
- Commit
112197c
- 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.