Skip to content
Back to search

terrashark

MarketplaceWorks with Claude CodeGitHub

Practical Terraform and OpenTofu skill focused on structure, security, testing, and low-hallucination IaC generation.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/lukasniessen--terrashark/badge.svg)](/listings/lukasniessen--terrashark)

HTML

<a href="/listings/lukasniessen--terrashark"><img src="/api/listings/lukasniessen--terrashark/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option 1: Clone

**macOS / Linux:**

git clone https://github.com/LukasNiessen/terrashark.git ~/.claude/skills/terrashark

**Windows (Powershell):**

git clone https://github.com/LukasNiessen/terrashark.git "$env:USERPROFILE\.claude\skills\terrashark"

**Windows (Command Prompt):**

git clone https://github.com/LukasNiessen/terrashark.git "%USERPROFILE%\.claude\skills\terrashark"

That's it. Claude Code auto-discovers skills in `~/.claude/skills/` - no restart needed.

Option 2: Marketplace

Claude Code has a built-in plugin system with marketplace support. Instead of cloning manually, you can add TerraShark's marketplace and install directly from the CLI:

/plugin marketplace add LukasNiessen/terrashark
/plugin install terrashark

Or use the interactive plugin manager - run `/plugin`, switch to the **Discover** tab, and install from there. The marketplace reads the `.claude-plugin/marketplace.json` in this repo to register TerraShark as an installable plugin.

Option 3: Codex

Codex has no global skill system - setup is per-project. Clone TerraShark into your repo and reference it from your `AGENTS.md`:

# Clone into your project root
git clone https://github.com/LukasNiessen/terrashark.git .terrashark

Then add to your `AGENTS.md` (or create one in the repo root):

## Terraform

When working with Terraform or OpenTofu, follow the workflow in `.terrashark/SKILL.md`.
Load references from `.terrashark/references/` as needed.

Option 4: Antigravity

**macOS / Linux:**

git clone https://github.com/LukasNiessen/terrashark.git ~/.gemini/antigravity/skills/terrashark

**Windows (PowerShell):**

git clone https://github.com/LukasNiessen/terrashark.git "$env:USERPROFILE\.gemini\antigravity\skills\terrashark"

Antigravity auto-discovers skills in the skills directory — no restart needed.

Option 5: Gemini CLI

Gemini CLI discovers skills in several standard locations.

**Global Installation (All Workspaces):**

git clone https://github.com/LukasNiessen/terrashark.git ~/.gemini/skills/terrashark

**Local Installation (Current Workspace):**

git clone https://github.com/LukasNiessen/terrashark.git .gemini/skills/terrashark

Gemini CLI auto-discovers skills in these directories. Run `/skills list` in the CLI to verify.

That's it!

Done. Now ask Claude Code / Codex / Antigravity / Gemini CLI any Terraform question. TerraShark responses follow the 7-step failure-mode workflow and include an output contract with assumptions, tradeoffs, and rollback notes.

**Invoke explicitly:**

/terrashark Create a multi-region S3 module with replication
/terrashark Refactor our EKS stack into separate state files per environment, add moved blocks to avoid recreation, set up a GitHub Actions pipeline with plan on PR and gated apply on merge, and wire in Checkov for compliance scanning

**Or just ask naturally** - TerraShark activates automatically for any Terraform/OpenTofu task:

Review my main.tf for security issues
Migrate this module from count to for_each

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "terrashark",
  3. "description": "Practical Terraform and OpenTofu skill focused on structure, security, testing, and low-hallucination IaC generation.",
  4. "owner": {
  5. "name": "LukasNiessen"
  6. },
  7. "plugins": [
  8. {
  9. "name": "terrashark",
  10. "source": "./",
  11. "description": "Terraform/OpenTofu Guardrails",
  12. "version": "2.3.0"
  13. }
  14. ]
  15. }
README.md · README · 388 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Terraform Skill for Claude Code, Codex, Antigravity, and Gemini CLI: TerraShark
  2. <div align="center" name="top">
  3. <img align="center" src="assets/logo.png" width="180" height="180" alt="TerraShark Logo">
  4. <!-- spacer -->
  5. <p></p>
  6. [![Claude Skill](https://img.shields.io/badge/Claude-Skill-6272F5)](https://docs.claude.ai/docs/agent-skills)
  7. [![Codex Skill](https://img.shields.io/badge/Codex-Skill-10A37F)](https://developers.openai.com/codex/skills/)
  8. [![Gemini Skill](https://img.shields.io/badge/Gemini-Skill-8E75C2)](https://geminicli.com/docs/cli/skills)
  9. [![Antigravity Skill](https://img.shields.io/badge/Antigravity-Skill-blue)](https://antigravity.google/docs/skills)
  10. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  11. [![GitHub stars](https://img.shields.io/github/stars/LukasNiessen/terrashark.svg)](https://github.com/LukasNiessen/terrashark)
  12. </div>
  13. The #1 Terraform skill for Claude Code and Codex, measured by GitHub stars.
  14. ### Fixes Hallucinations.
  15. LLMs hallucinate a lot when it comes to Terraform. This skill fixes it. It includes best practices for Terraform and OpenTofu - good, bad, and neutral examples so the AI avoids common mistakes. Using TerraShark, the AI keeps proven practices in mind, eliminates hallucinations, and defaults to modular, reusable, security-first design.
  16. ### Very Token-Efficient.
  17. Most Terraform skills dump huge text-of-walls onto the agent and burn expensive tokens - with no upside. LLMs don't need the entire Terraform docs again. TerraShark was aggressively de-duplicated and optimized for maximum quality per token.
  18. ### Based on HashiCorp's Official Best Practices.
  19. TerraShark is primarily based on [HashiCorp official recommended practices](https://developer.hashicorp.com/terraform/cloud-docs/recommended-practices). When guidance conflicts, it prioritizes HashiCorp's recommendations.
  20. ---
  21. [Quick Start](#-quick-start) • [Why TerraShark?](#-library-comparison) • [Token Strategy](#-token-strategy) • [What's Included](#-whats-included) • [How It Works](#-how-it-works) • [Sponsor](https://github.com/sponsors/LukasNiessen) • [Philosophy](PHILOSOPHY.md)
  22. ---
  23. ## ⚡ 2 min Quickstart
  24. ### Option 1: Clone
  25. **macOS / Linux:**
  26. ```bash
  27. git clone https://github.com/LukasNiessen/terrashark.git ~/.claude/skills/terrashark
  28. ```
  29. **Windows (Powershell):**
  30. ```powershell
  31. git clone https://github.com/LukasNiessen/terrashark.git "$env:USERPROFILE\.claude\skills\terrashark"
  32. ```
  33. **Windows (Command Prompt):**
  34. ```powershell
  35. git clone https://github.com/LukasNiessen/terrashark.git "%USERPROFILE%\.claude\skills\terrashark"
  36. ```
  37. That's it. Claude Code auto-discovers skills in `~/.claude/skills/` - no restart needed.
  38. ### Option 2: Marketplace
  39. Claude Code has a built-in plugin system with marketplace support. Instead of cloning manually, you can add TerraShark's marketplace and install directly from the CLI:
  40. ```
  41. /plugin marketplace add LukasNiessen/terrashark
  42. /plugin install terrashark
  43. ```
  44. Or use the interactive plugin manager - run `/plugin`, switch to the **Discover** tab, and install from there. The marketplace reads the `.claude-plugin/marketplace.json` in this repo to register TerraShark as an installable plugin.
  45. ### Option 3: Codex
  46. Codex has no global skill system - setup is per-project. Clone TerraShark into your repo and reference it from your `AGENTS.md`:
  47. ```bash
  48. # Clone into your project root
  49. git clone https://github.com/LukasNiessen/terrashark.git .terrashark
  50. ```
  51. Then add to your `AGENTS.md` (or create one in the repo root):
  52. ```markdown
  53. ## Terraform
  54. When working with Terraform or OpenTofu, follow the workflow in `.terrashark/SKILL.md`.
  55. Load references from `.terrashark/references/` as needed.
  56. ```
  57. ### Option 4: Antigravity
  58. **macOS / Linux:**
  59. ```bash
  60. git clone https://github.com/LukasNiessen/terrashark.git ~/.gemini/antigravity/skills/terrashark
  61. ```
  62. **Windows (PowerShell):**
  63. ```powershell
  64. git clone https://github.com/LukasNiessen/terrashark.git "$env:USERPROFILE\.gemini\antigravity\skills\terrashark"
  65. ```
  66. Antigravity auto-discovers skills in the skills directory — no restart needed.
  67. ### Option 5: Gemini CLI
  68. Gemini CLI discovers skills in several standard locations.
  69. **Global Installation (All Workspaces):**
  70. ```bash
  71. git clone https://github.com/LukasNiessen/terrashark.git ~/.gemini/skills/terrashark
  72. ```
  73. **Local Installation (Current Workspace):**
  74. ```bash
  75. git clone https://github.com/LukasNiessen/terrashark.git .gemini/skills/terrashark
  76. ```
  77. Gemini CLI auto-discovers skills in these directories. Run `/skills list` in the CLI to verify.
  78. ### That's it!
  79. Done. Now ask Claude Code / Codex / Antigravity / Gemini CLI any Terraform question. TerraShark responses follow the 7-step failure-mode workflow and include an output contract with assumptions, tradeoffs, and rollback notes.
  80. **Invoke explicitly:**
  81. ```bash
  82. /terrashark Create a multi-region S3 module with replication
  83. ```
  84. ```bash
  85. /terrashark Refactor our EKS stack into separate state files per environment, add moved blocks to avoid recreation, set up a GitHub Actions pipeline with plan on PR and gated apply on merge, and wire in Checkov for compliance scanning
  86. ```
  87. **Or just ask naturally** - TerraShark activates automatically for any Terraform/OpenTofu task:
  88. ```
  89. Review my main.tf for security issues
  90. ```
  91. ```
  92. Migrate this module from count to for_each
  93. ```
  94. ## 🎬 Demo
  95. https://github.com/user-attachments/assets/2bc4c9ff-9f54-4a49-8bf0-5cfc0f26dec6
  96. ## 📊 Library Comparison
  97. Here's how TerraShark compares to other Terraform and OpenTofu agent skills:
  98. | Feature | **TerraShark** | **Anton Babenko terraform-skill** | **terraform-patterns** |
  99. | -------------------------------- | ----------------------------------------------------- | --------------------------------- | ------------------------------------ |
  100. | **Core Architecture** | ✅ Failure-mode workflow | ⚠️ Static reference manual | ⚠️ Pattern checklist |
  101. | **SKILL.md Activation Cost** | ✅ ~600 tokens | ⚠️ ~4,400 tokens | ⚠️ Single broad reference |
  102. | **Reference Granularity** | ✅ 19 focused files | ⚠️ 6 large files | ❌ No focused reference library |
  103. | **Token Burn Per Query** | ✅ Low (load 1-2 small refs) | ⚠️ High for deep references | ⚠️ Loads broad guidance |
  104. | **Diagnoses Before Generating** | ✅ Step 2 requires diagnosis | ❌ No | ❌ No |
  105. | **Hallucination Prevention** | ✅ Core design goal | ⚠️ Indirect via best practices | ⚠️ Indirect via patterns |
  106. | **Output Contract** | ✅ Assumptions, tradeoffs, rollback | ❌ No | ❌ No |
  107. | **Failure-Mode Coverage** | ✅ Identity, secrets, blast radius, CI, compliance | ⚠️ General state/security advice | ⚠️ General anti-pattern summary |
  108. | **Migration Playbooks** | ✅ 5 dedicated playbooks | ⚠️ Partial inline snippets | ⚠️ Import and moved-block notes |
  109. | **Good/Bad/Neutral Examples** | ✅ 3 dedicated files | ⚠️ Inline DO/DON'T examples | ⚠️ Inline BAD/GOOD snippets |
  110. | **Do/Don't Checklist** | ✅ Dedicated file | ⚠️ Inline only | ⚠️ Inline only |
  111. | **Compliance Framework Mapping** | ✅ ISO 27001, SOC 2, FedRAMP, GDPR, PCI DSS, HIPAA | ⚠️ Scanner-oriented guidance | ❌ No |
  112. | **Trusted Module Awareness** | ✅ AWS, Azure, GCP, OCI, IBM loaded conditionally | ⚠️ AWS module context | ❌ No |
  113. | **MCP Integration Guidance** | ✅ Dedicated reference | ⚠️ Optional Terraform MCP mention | ❌ No |
  114. | **Claude + Codex Support** | ✅ First-class Claude Code and Codex setup | ⚠️ Broad multi-agent setup | ⚠️ Claude plugin oriented |
  115. | **Security-First Defaults** | ✅ Built into the workflow | ⚠️ Checklist-style | ⚠️ Style-guide based |
  116. | **CI/CD Templates** | ✅ GitHub Actions, GitLab CI, Atlantis, Infracost | ✅ GitHub Actions, GitLab CI | ⚠️ Pipeline rules only |
  117. | **License** | ✅ MIT | ⚠️ Apache 2.0 | ❌ Not highlighted in skill listing |
  118. As you see in the table, there are some features that are only supported by us. Here is a brief highlight of those that we believe are the most critical of them:
  119. - **Failure-mode workflow**: TerraShark does not just give the agent Terraform facts. It forces the agent to identify the likely failure mode first, then load the exact reference material needed for that risk.
  120. - **Output contract**: TerraShark responses include assumptions, remediation choices, tradeoffs, validation steps, and rollback notes. Other skills leave that structure to the model.
  121. - **Token efficiency**: TerraShark keeps the activation path tiny and moves depth into focused references. This gives the agent the right Terraform context without turning every request into a large reference dump.
  122. - **Compliance mapping**: TerraShark includes explicit mappings for ISO 27001, SOC 2, FedRAMP, GDPR, PCI DSS, and HIPAA. Other skills focus more on scanners than audit-ready control mapping.
  123. - **Trusted module awareness**: TerraShark knows when to prefer mature vendor and community modules for AWS, Azure, GCP, Oracle Cloud, and IBM Cloud, reducing the surface area for hallucinated raw resources.
  124. - **LLM-specific hallucination prevention**: TerraShark is designed around the ways AI agents fail at infrastructure code: unstable identity, leaked secrets, wide blast radius, CI drift, and weak compliance gates.
  125. ### TerraShark vs terraform-skill
  126. The key difference is architectural. **terraform-skill** is a static reference manual: it dumps ~4,400 tokens into context on every activation, then loads additional reference files that can be over 1,000 lines each. It gives Claude information but never tells it _how to think_ about a problem. There's no diagnosis step, no risk assessment, and no structured output - Claude reads the reference and generates whatever it thinks fits.
  127. **TerraShark** takes the opposite approach. The core SKILL.md is an 86-line operational workflow that costs ~600 tokens on activation - **over 7x leaner**. Instead of front-loading a wall of text, it forces Claude through a diagnostic sequence: capture context → identify failure modes → load _only_ the relevant references → propose fixes with explicit risk controls → validate → deliver a structured output contract.
  128. This matters for three reasons:
  129. 1. **Token efficiency.** terraform-skill burns ~4,400 tokens just to activate, before any reference files. A single reference file like `module-patterns.md` (1,126 lines, ~7,000 tokens) can double the cost again. TerraShark's activation is ~600 tokens, and its 19 granular reference files mean Claude loads only what's needed - typically one or two small, focused docs instead of one massive dump.
  130. 2. **Hallucination prevention.** terraform-skill provides good patterns but never asks Claude to _diagnose what could go wrong_. TerraShark's Step 2 forces failure-mode identification before any code is generated. Step 4 requires explicit risk controls for every fix. Step 7 enforces an output contract with assumptions, tradeoffs, and rollback notes. This is the difference between giving someone a cookbook and giving them a diagnostic checklist.
  131. 3. **Reference coverage.** TerraShark ships 19 focused reference files covering failure modes, backend-specific state safety, migration playbooks, good/bad/neutral examples, do/don't checklists, compliance framework mappings, and MCP integration. terraform-skill has 6 larger files that go deep on testing and module patterns but lack migration playbooks, explicit anti-pattern banks, compliance mappings beyond a few frameworks, and MCP guidance.
  132. **In short:** TerraShark is the better skill due to 7x leaner activation, failure-mode-first diagnostic workflow, output contracts, granular references, and LLM-specific hallucination prevention. terraform-skill wins on HCL example depth and testing docs, but TerraShark's architecture is fundamentally better designed for the core use case of LLM-assisted IaC generation.
  133. ---
  134. ## 🕵️ Token Strategy
  135. - Keep `SKILL.md` procedural and compact
  136. - Keep references focused on failure-prone decisions
  137. - Exclude broad tutorial material with low safety impact
  138. - Add depth only when measured quality would otherwise drop
  139. See `references/token-balance-rationale.md` for the full decision and tradeoffs.
  140. ## 🧱 Trusted Module Awareness
  141. Hand-rolled `resource` blocks are one of the largest hallucination surfaces for LLMs; attribute names, defaults, and iteration shapes are where models drift. TerraShark recognizes the major vendor-maintained and community module registries and defaults to using them instead of generating raw resources, whenever a mature module covers the requested service.
  142. ### How it helps
  143. - A pinned registry module replaces hundreds of lines of hand-rolled HCL with a version-locked interface already tested across many production stacks
  144. - Removes attribute-name, default-value, and `for_each` drift; the exact spots where LLMs slip
  145. - Enforces **exact** version pinning for production, so module upgrades don't silently change generated resource addresses
  146. ### When it loads (lean-token approach)
  147. `references/conditional/trusted-modules.md` is pulled into context **only when the detected provider is one of the supported clouds**. AWS-only projects never pay the token cost for Azure or GCP guidance, and vice versa, matching TerraShark's core token-efficiency design.
  148. ### Supported providers
  149. | Cloud | Registry namespace | Program |
  150. | ------------ | -------------------------- | ---------------------------------- |
  151. | AWS | `terraform-aws-modules` | Community standard |
  152. | Azure | `Azure` | Azure Verified Modules (AVM) |
  153. | GCP | `terraform-google-modules` | Cloud Foundation Toolkit |
  154. | Oracle Cloud | `oracle-terraform-modules` | Vendor-maintained |
  155. | IBM Cloud | `terraform-ibm-modules` | IBM Deployable Architectures |
  156. Other ecosystems (Alibaba Cloud, DigitalOcean, Hetzner, etc.) are intentionally not included yet, their module programs are still small or early-stage, so recommending them as defaults would trade one failure mode (hallucinated attributes) for another (unmaintained wrappers). If a provider's ecosystem matures, it can be added later.
  157. ## 🐣 What's Included
  158. - A focused `SKILL.md` execution flow
  159. - Failure-mode-first guidance to prevent common IaC hallucinations
  160. - Core failure-mode references: identity churn, secret exposure, blast radius, CI drift, compliance gates
  161. - Backend-specific state safety loaded conditionally for state storage, locking, migration, and restore work
  162. - Expanded architecture guidance (state, boundaries, module roles)
  163. - Refactor/migration playbooks for safe evolution
  164. - Stronger CI/CD and governance patterns (including Atlantis + Infracost)
  165. - Risk-based test depth guidance with native test caveats and Terratest coverage
  166. - Rewritten good/bad/neutral example bank
  167. - Do/Don't pattern bank and MCP integration guidance
  168. - Trusted community/vendor module awareness (AWS, Azure, GCP, OCI, IBM) loaded conditionally
  169. ## 🔲 Repository Layout
  170. Here an overview of the repository layout.
  171. | File | Description |
  172. | --------------------------------------- | ------------------------------------------------------------- |
  173. | `SKILL.md` | Operational workflow for TerraShark |
  174. | `PHILOSOPHY.md` | Design strategy, architecture decisions, token experiment |
  175. | `references/identity-churn.md` | Address stability, `count`/`for_each`, `moved` safety |
  176. | `references/secret-exposure.md` | Preventing secret leakage through state/logs/artifacts |
  177. | `references/blast-radius.md` | State boundaries, environment isolation, apply impact control |
  178. | `references/ci-drift.md` | Production CI drift prevention and plan/apply integrity |
  179. | `references/compliance-gates.md` | Policy gates, approvals, evidence, framework mappings |
  180. | `references/structure-and-state.md` | State, boundaries, and apply safety |
  181. | `references/conditional/backend-state-safety.md` | Backend-specific state safety and migration guardrails |
  182. | `references/module-architecture.md` | Module role model and composition rules |
  183. | `references/coding-standards.md` | Naming, typing, iteration, versioning |
  184. | `references/migration-playbooks.md` | moved/import/refactor/upgrade playbooks |
  185. | `references/testing-matrix.md` | Test tiering, native test caveats, Terratest guidance |
  186. | `references/ci-delivery-patterns.md` | CI stages and production-oriented pipeline templates |
  187. | `references/security-and-governance.md` | Security controls and operational governance |
  188. | `references/quick-ops.md` | Command sequence and troubleshooting shortcuts |
  189. | `references/examples-good.md` | Strong implementation examples |
  190. | `references/examples-bad.md` | Anti-pattern examples |
  191. | `references/examples-neutral.md` | Context-based tradeoff examples |
  192. | `references/do-dont-patterns.md` | Do/Don't pattern checklist |
  193. | `references/mcp-integration.md` | MCP integration guidance |
  194. | `references/conditional/trusted-modules.md` | Canonical community/vendor modules per cloud (conditional) |
  195. | `references/token-balance-rationale.md` | Why the skill stays lean and where depth is kept |
  196. | `.github/workflows/validate.yml` | CI validation for skill structure and links |
  197. | `.github/PULL_REQUEST_TEMPLATE.md` | PR quality and failure-mode checklist |
  198. | `.claude-plugin/marketplace.json` | Plugin metadata |
  199. ## 🔎 How It Works
  200. The skill runs as a failure-mode workflow whenever Claude Code, Codex, Antigravity, or Gemini CLI handles Terraform or OpenTofu tasks:
  201. 1. **Capture execution context** - Runtime/version, providers, backend, execution path, risk level
  202. 2. **Diagnose likely failure mode(s)** - Identity churn, secret exposure, blast radius, CI drift, compliance gate gaps
  203. 3. **Load only relevant references** - Pull targeted guidance for the failure mode(s) in scope
  204. 4. **Propose fix path with controls** - Include risk notes, approvals, tests, and rollback expectations
  205. 5. **Generate implementation artifacts** - HCL changes, migration blocks, CI/policy updates
  206. 6. **Validate before finalize** - Runtime-appropriate command sequence and risk-tier checks
  207. 7. **Deliver complete output** - Assumptions, remediation choices, tradeoffs, validation plan, recovery notes
  208. ## 🐲 Scope
  209. - Terraform and OpenTofu module design/review/refactoring
  210. - Safe migration workflows for existing stacks
  211. - CI/CD and policy integration for infrastructure delivery
  212. - Blast-radius reduction and operational safety
  213. ## ℹ️ FAQ
  214. **Q: Does this work with OpenTofu?**
  215. Yes. TerraShark supports both Terraform and OpenTofu. The workflow captures runtime/version first and adapts guidance accordingly.
  216. **Q: Will this slow down my AI interactions?**
  217. No. The skill is designed for low token overhead. Only relevant references should be loaded for a given failure mode.
  218. **Q: Can I use this outside Claude Code?**
  219. Yes. The references are plain Markdown and can be used from any workflow or AI assistant, **including Codex, Antigravity, and Gemini CLI**. The trigger behavior in `SKILL.md` is optimized for skill-enabled environments.
  220. **Q: How was the content validated?**
  221. We started with much larger references and a large automated test suite, then repeatedly removed sections and re-tested. If quality dropped, content was restored. If quality stayed stable, content remained out.
  222. ## 🦊 Contributing
  223. We highly appreciate contributions. See [CONTRIBUTING.md](CONTRIBUTING.md) and use the PR template for failure-mode and validation details.
  224. ## 💟 Community
  225. ### Maintainers
  226. • **[LukasNiessen](https://github.com/LukasNiessen)** - Creator and main maintainer
  227. • **[janMagnusHeimann](https://github.com/janMagnusHeimann)** - Main maintainer
  228. • **[TristanKruse](https://github.com/TristanKruse)** - Main maintainer
  229. ### Contributors
  230. <a href="https://github.com/LukasNiessen/terrashark/graphs/contributors">
  231. <img src="https://contrib.rocks/image?repo=LukasNiessen/terrashark&max=1000&contributors=10" />
  232. </a>
  233. ### Questions
  234. Found a bug? Want to discuss features?
  235. - Submit an [issue on GitHub](https://github.com/LukasNiessen/terrashark/issues/new/choose)
  236. - Join [GitHub Discussions](https://github.com/LukasNiessen/terrashark/discussions)
  237. If TerraShark helps your project, please consider:
  238. - Starring the repository
  239. - Suggesting new features
  240. - Contributing code or documentation
  241. ### Star History
  242. [![Star History Chart](https://star-history.dera.page/svg?repos=LukasNiessen/terrashark&type=Date)](https://star-history.dera.page/#LukasNiessen/terrashark&Date)
  243. ## 📄 License
  244. This project is under the **MIT** license.
  245. ---
  246. <p align="center">
  247. <a href="#top"><strong>Go Back to Top</strong></a>
  248. </p>
  249. ---
  250. ## Other
  251. **Version:** v2.3.0
  252. **Website:** https://terraformskill.com/
  253. **GitHub Pages:** [https://lukasniessen.github.io/terrashark/](https://lukasniessen.github.io/terrashark/)
  254. ## Conditional Reference Retrieval (CRR)
  255. TerraShark adheres to Conditional Reference Retrieval (CRR): conditional references live under `references/conditional/`, are loaded only when concrete signals are detected, and neighboring conditional references are not loaded unless the task spans multiple detected routes.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.