mcpbeat Sign in

Go Local Health Skill for Codex

Run local Go health checks (tests, coverage, lint) in Go repositories that contain go.mod/go.sum. Use when the user asks to run or interpret local Go test/coverage/lint workflows using tools like lazygotest, gocovsh, tparse, and golangci-lint. Do not use for Rust or non-Go projects.

2k tokens
context cost
the whole folder, loaded on every use
3
files
ships runnable scripts
0
copies elsewhere
how many repositories repackaged it
131
stars on the repo
on the repository, not the skill itself

Install

one command, takes just this skill from the repository
npx skills add https://github.com/instructa/agent-skills --skill go-local-health

What comes with it

3 622 bytes besides the instruction
README.md
scripts/go-local-health

The instruction itself

9 sections, as written by the author

Go Local Health

Overview

Provide a consistent, repeatable local workflow for Go test, coverage, and lint checks.

Use this to run fast snapshots, interactive test loops, and coverage inspection without re-deriving commands.

Guardrails (language + tooling)

  • Confirm go.mod exists in the repo root before running anything. If missing, stop and ask.
  • Run commands from the repo root so module settings and tooling config are discovered.
  • Respect the repo’s Go toolchain configuration (go.mod + toolchain).
  • Prefer repo-pinned tool versions (e.g., tools.go or go.mod tool directives). If tools are missing and no pins exist, ask before installing or adding pins.
  • Required tools vary by mode:
  • Quick Snapshot: go, tparse, golangci-lint
  • Interactive Test Loop: lazygotest
  • Coverage Explorer: gocovsh

If any required tool is missing, ask to install rather than using substitutes.

  • All automated runs must be non-interactive. Only launch TUIs when the user explicitly requests them.

Workflow Decision Tree

  • Use Quick Snapshot when you want a fast read on tests + coverage + lint.
  • Use Interactive Test Loop when you are actively iterating on tests.
  • Use Coverage Explorer when you need to inspect coverage hotspots in detail.
  • If the repo is large, ask whether to scope to a package path before running full ./....

Quick Snapshot (tests + coverage + lint)

Preferred (scripted, deterministic):

~/.codex/skills/go-local-health/scripts/go-local-health --scope ./...

Manual fallback:

  • Run tests with coverage and a one-screen summary:
go test -cover -json ./... | tparse
  • Run lint with the repo’s configuration:
golangci-lint run ./...

If a narrower scope is requested, replace ./... with the specific package path.

Interactive Test Loop (lazygotest)

  • Launch from the repo root:
lazygotest
  • Use the UI to filter packages and re-run tests while editing code.

Coverage Explorer (gocovsh)

  • Launch from the repo root:
gocovsh
  • If a cover.out is required or preferred, generate it first:
go test -coverprofile=cover.out ./...

Reporting Back to the User

  • Summarize failing packages, error types, and coverage gaps.
  • If lint fails, report the top categories (not every line) and ask whether to fix now.
  • If coverage is low, identify the worst packages and suggest next steps only if asked.

Non-Goals

  • Do not run in non-Go repos.
  • Do not swap in other tools or skip required checks.
  • Do not change CI configuration or code unless the user asks.

Other skills for the same job

different authors, same section of the catalogue
Performance Testing Review AI Review
by ComeOnOliver
×2

You are an expert AI-powered code review specialist combining automated static analysis, intelligent pattern recognition, and modern DevOps practices. Leverage AI tools (GitHub Copilot, Qodo, GPT-5, C

6k tokens
Ruby Pro
by ComeOnOliver
×2

Write idiomatic Ruby code with metaprogramming, Rails patterns, and performance optimization. Specializes in Ruby on Rails, gem development, and testing frameworks. Use PROACTIVELY for Ruby refactoring, optimization, or complex Ruby features.

3k tokens
Tdd Workflows Tdd Refactor
by ComeOnOliver
×2

Use when working with tdd workflows tdd refactor

4k tokens
Setup Pre Commit
by aiskillstore
×1

Set up Husky pre-commit hooks with lint-staged (Prettier), type checking, and tests in the current repo. Use when user wants to add pre-commit hooks, set up Husky, configure lint-staged, or add commit-time formatting/typechecking/testing.

7k tokens
Pair Programming
by Microck
×1

AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, quality monitoring, and comprehensive testing. Supports TDD, debugging, refactoring, and learning sessions. Features automatic role switching, continuous code review, security scanning, and performance optimization with truth-score verification.

6k tokens
Audit Prep Assistant
by christophacham
×1

Prepares codebases for security review using Trail of Bits' checklist. Helps set review goals, runs static analysis tools, increases test coverage, removes dead code, ensures accessibility, and generates documentation (flowcharts, user stories, inline comments).

2k tokens
Component Refactoring
by ComeOnOliver
×1

Refactor high-complexity React components in Dify frontend. Use when `pnpm analyze-component --json` shows complexity > 50 or lineCount > 300, when the user asks for code splitting, hook extraction, or complexity reduction, or when `pnpm analyze-component` warns to refactor before testing; avoid for simple/well-structured components, third-party wrappers, or when the user explicitly wants testing without refactoring.

20k tokens
Csharp Pro
by ComeOnOliver
×1

Write modern C# code with advanced features like records, pattern matching, and async/await. Optimizes .NET applications, implements enterprise patterns, and ensures comprehensive testing. Use PROACTIVELY for C# refactoring, performance optimization, or complex .NET solutions.

3k tokens

How to use it

Copy the folder

Take instructa/go-local-health from the repository into ~/.claude/skills for personal use, or into .claude/skills inside a project.

Check the name does not clash

The agent identifies a skill by the name field in its header. Two skills with the same name cannot sit side by side — one of them will be ignored.