port-hadolint-rule

Port Hadolint linter rules from Haskell to Go for the tally project.

8|3|Updated Jan 25, 2026
One-click install
npx skills add https://github.com/wharflab/tally --skill port-hadolint-rule
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: port-hadolint-rule
Source: https://github.com/wharflab/tally/tree/main/.claude/skills/port-hadolint-rule
Command: npx skills add https://github.com/wharflab/tally --skill port-hadolint-rule

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill automates the complex and time-consuming process of porting linter rules from one language (Haskell) to another (Go), ensuring consistency and expanding the capabilities of the tally project.

Core Features & Use Cases

  • Rule Porting Automation: Guides the user through fetching, analyzing, and implementing Hadolint rules in Go.
  • Codebase Integration: Provides patterns and requirements for integrating new rules into the tally project's structure.
  • Test Case Management: Ensures comprehensive testing by extracting and implementing all original test cases.
  • Use Case: A developer needs to add a new linter rule for Dockerfiles to the tally project. This Skill provides a structured workflow to port an existing Hadolint rule, including fetching the original code, writing Go implementations, and adding tests.

Quick Start

Use the port-hadolint-rule skill to port the DL3001 Hadolint rule.

Frequently Asked Questions about port-hadolint-rule

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I port Hadolint rules from Haskell to Go?

Porting Hadolint rules from Haskell to Go is automated by fetching original Haskell implementations and test cases, analyzing existing Go patterns, and implementing new rules using shell command parsing and semantic models.

What is the best way to add a new Dockerfile linter rule to the tally project?

Adding a Dockerfile linter rule to the tally project requires a structured workflow of fetching original Hadolint code, writing Go implementations using shell command parsing, and adding comprehensive unit and integration tests.

Can I automate extracting Hadolint test cases when porting linter rules to Go?

Yes, automating the extraction and implementation of all original Hadolint test cases in Go is supported to ensure comprehensive testing and validate the ported linter rules against expected outcomes.

Does porting Hadolint rules to Go require integrating with existing codebase patterns?

Porting Hadolint rules to Go requires integrating with existing codebase patterns by analyzing the tally project's current structure and applying its specific requirements for new rule integration.

Why do I need to use semantic models when implementing Dockerfile linter rules in Go?

Semantic models are needed when implementing Dockerfile linter rules in Go to accurately parse and evaluate shell commands, ensuring the ported rules correctly analyze Dockerfile instructions and maintain parity with the original Haskell logic.

What are the limitations of using automated tools to port linter rules from Haskell to Go?

Automated porting of linter rules from Haskell to Go still requires manual guidance through the workflow to fetch, analyze, and implement rules, meaning it provides structured assistance rather than fully autonomous code translation.