Comprehensive guide for Go database access. Covers parameterized queries, struct scanning, NULLable column handling, error patterns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context propagation, and migration tooling. Use this skill whenever writing, reviewing, or debugging Golang code that interacts with PostgreSQL, MariaDB, MySQL, or SQLite. Also triggers for database testing or any question about database/sql, sqlx, pgx, or SQL queries in Golang. This skill explicitly does NOT generate database schemas or migration SQL.
87
86%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
100%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 an excellent skill description that thoroughly covers specific capabilities, includes abundant natural trigger terms across multiple database engines and Go libraries, explicitly states both when to use and when not to use the skill, and carves out a clear niche. The description is comprehensive without being padded, uses third-person voice throughout, and would allow Claude to confidently select or reject this skill from a large pool.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and topics: parameterized queries, struct scanning, NULLable column handling, error patterns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context propagation, and migration tooling. Also explicitly states what it does NOT do. | 3 / 3 |
Completeness | Clearly answers both 'what' (comprehensive list of database access topics) and 'when' ('Use this skill whenever writing, reviewing, or debugging Golang code that interacts with PostgreSQL, MariaDB, MySQL, or SQLite. Also triggers for database testing or any question about database/sql, sqlx, pgx, or SQL queries in Golang'). Includes explicit exclusion boundary as well. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms users would say: 'Go', 'Golang', 'PostgreSQL', 'MariaDB', 'MySQL', 'SQLite', 'database/sql', 'sqlx', 'pgx', 'SQL queries', 'database testing'. These are terms developers would naturally use when seeking help with Go database code. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive: scoped specifically to Go/Golang database access with named libraries (database/sql, sqlx, pgx) and named databases. The explicit exclusion of schema generation and migration SQL further reduces conflict risk with schema-design or migration-focused skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
72%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a strong, well-structured skill that provides actionable Go database patterns with good progressive disclosure to reference files. Its main weaknesses are moderate verbosity (the ORM rationale and some explanatory text could be trimmed) and missing explicit validation/retry workflows for transaction and batch operations, which are deferred to reference files. The code examples are excellent and the error handling table is particularly useful.
Suggestions
Trim the 'Why NOT ORMs' section and best practices summary to reduce redundancy — the library choice table already communicates the preference clearly
Add an inline transaction retry loop example for serialization failures (error code 40001) rather than just listing it in a table, since this is a critical workflow with a feedback loop
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient but includes some unnecessary explanations Claude already knows (e.g., 'Go's database/sql provides a solid foundation', the extended ORM rationale, explaining what SQL injection is). The best practices summary repeats information that appears in later sections. However, most content earns its place with concrete patterns and tables. | 2 / 3 |
Actionability | The skill provides fully executable Go code examples for parameterized queries, error handling, row closing, connection pool configuration, and dynamic IN clauses. Code is copy-paste ready with both good and bad patterns clearly marked. The error handling table maps specific errors to detection methods and actions. | 3 / 3 |
Workflow Clarity | The persona/modes section at the top provides a clear workflow for write vs review/debug modes including sub-agent usage. However, multi-step processes like transaction workflows and batch operations are deferred to reference files without inline validation checkpoints. The error handling patterns lack explicit retry/recovery loops for serialization failures beyond a table entry saying 'retry the entire transaction'. | 2 / 3 |
Progressive Disclosure | Excellent progressive disclosure with a clear overview containing essential patterns inline, then well-signaled one-level-deep references to transactions, testing, performance, and scanning reference files. Cross-references to related skills are clearly listed. The Deep Dives section provides a clean navigation index with descriptions of what each reference covers. | 3 / 3 |
Total | 10 / 12 Passed |
Validation
81%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
metadata_field | 'metadata' should map string keys to string values | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
b88f91d
Table of Contents
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.