311-frameworks-spring-jdbc
Use when you need to write or review programmatic JDBC with Spring — including JdbcClient (Spring Framework 7+) as the default API, JdbcTemplate only where batch/streaming APIs require JdbcOperations, NamedParameterJdbcTemplate for legacy named-param code, parameterized SQL, RowMapper mapping to records, batch operations, transactions, safe handling of generated keys, DataAccessException handling, read-only transactions, streaming large result sets, and @JdbcTest slice testing. This should trigger for requests such as Review Java code for Spring JDBC (JdbcTemplate, JdbcClient, NamedParameterJdbcTemplate); Apply best practices for Spring JDBC data access in Java code; Detect and fix SQL injection risks in JDBC code; Improve transaction boundaries or exception handling for JDBC operations. Part of cursor-rules-java project
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 ./skills/311-frameworks-spring-jdbc/SKILL.mdQuality
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 a strong skill description that excels across all dimensions. It provides comprehensive specificity with numerous concrete actions, includes excellent trigger terms that developers would naturally use, clearly answers both what and when with explicit trigger guidance, and occupies a distinct niche focused on Spring JDBC that is unlikely to conflict with other skills. The only minor concern is that the description is quite dense and could benefit from slightly better formatting for readability, but content-wise it is thorough and well-crafted.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description lists numerous specific concrete actions: JdbcClient as default API, JdbcTemplate for batch/streaming, NamedParameterJdbcTemplate for legacy code, parameterized SQL, RowMapper mapping to records, batch operations, transactions, generated keys handling, DataAccessException handling, read-only transactions, streaming large result sets, and @JdbcTest slice testing. | 3 / 3 |
Completeness | Clearly answers both 'what' (write/review programmatic JDBC with Spring, including a comprehensive list of capabilities) and 'when' (explicit 'Use when' clause at the start, plus 'This should trigger for requests such as...' with concrete example scenarios like reviewing Java code, applying best practices, detecting SQL injection, improving transaction boundaries). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms users would say: 'Spring JDBC', 'JdbcTemplate', 'JdbcClient', 'NamedParameterJdbcTemplate', 'SQL injection', 'transaction boundaries', 'exception handling', 'JDBC operations', 'Java code', 'batch operations'. These are terms developers would naturally use when seeking help with Spring JDBC. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — narrowly scoped to Spring JDBC specifically (JdbcClient, JdbcTemplate, NamedParameterJdbcTemplate), clearly distinguishable from general Java skills, Spring Data JPA skills, or generic database skills. The specific API names and framework version (Spring Framework 7+) create a clear niche. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
35%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill functions primarily as a thin wrapper around an external reference file, providing almost no concrete, executable guidance in the body itself. While the constraints and workflow structure show some care for safety (compile-before, verify-after), the complete absence of code examples, patterns, or specific instructions means Claude would need to read the entire reference file before being able to act. The bullet-point coverage list adds verbosity without actionability.
Suggestions
Add at least 2-3 concrete, executable code examples directly in the skill body showing the most common patterns (e.g., JdbcClient query, parameterized update, RowMapper with record) so Claude can act without reading the full reference.
Include a brief good/bad pattern comparison inline (e.g., SQL injection anti-pattern vs. bind parameters) to make the skill immediately actionable for the most critical safety concern.
Replace the 'What is covered' bullet list with a concise one-liner scope statement, and use the saved space for actual code examples and concrete guidance.
Make the workflow steps more specific — e.g., step 3 should list the key transformations to look for (replace string concatenation with bind params, migrate JdbcTemplate to JdbcClient, add @Transactional) rather than just saying 'follow the reference patterns'.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The 'What is covered in this Skill?' bullet list is essentially a table of contents that restates the description and adds little actionable value — it's a verbose summary of what the reference file covers. However, the constraints and workflow sections are reasonably tight. | 2 / 3 |
Actionability | The skill contains zero executable code examples, no concrete commands beyond generic Maven invocations, and delegates all actual guidance to an external reference file. Claude is told to 'follow the reference patterns' but the skill body itself provides no concrete code, SQL patterns, or copy-paste-ready examples. | 1 / 3 |
Workflow Clarity | The workflow has a clear 4-step sequence with compilation checks before and verification after, which is good. However, the validation steps are somewhat generic ('run verification and report results') and the actual decision logic for what to change is entirely deferred to the reference file, leaving gaps in the workflow itself. | 2 / 3 |
Progressive Disclosure | The skill references a single external file (references/311-frameworks-spring-jdbc.md) which is appropriate one-level-deep disclosure, but since no bundle files were provided, we cannot verify the reference exists. The skill body itself is too thin — it's almost entirely a pointer to the reference with very little standalone value, making the split feel like the skill is just a wrapper rather than a useful overview. | 2 / 3 |
Total | 7 / 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
- jabrena/cursor-rules-java
- Commit
26e9744
- 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.