kotlin-exposed-patterns
by affaan-mkotlin-exposed-patterns is a practical guide for Kotlin database engineering with JetBrains Exposed. It covers DSL queries, DAO pattern, newSuspendedTransaction, HikariCP, Flyway migrations, and repository boundaries for maintainable data access.
This skill scores 78/100, which means it is a solid listing candidate for Agent Skills Finder. The repository gives users a credible install decision: it clearly targets JetBrains Exposed patterns, shows when to use it, and includes concrete database workflow examples, so agents should be able to trigger and apply it with less guesswork than a generic prompt.
- Well-scoped to real Exposed workflows: DSL queries, DAO, transactions, HikariCP, Flyway, and repository pattern are all explicitly covered.
- Good operational clarity: the SKILL.md explains how Exposed, HikariCP, Flyway, and `newSuspendedTransaction` fit together.
- Substantial content depth with examples and many headings, which improves progressive disclosure for agents browsing the skill.
- No install command or companion scripts/resources, so adoption depends entirely on the prose skill file.
- Repository evidence shows no supporting tests, references, or assets, which limits external trust signals and validation depth.
Overview of kotlin-exposed-patterns skill
kotlin-exposed-patterns is a practical guide for building database access in Kotlin with JetBrains Exposed. It is most useful if you are deciding how to structure queries, transactions, migrations, and repository boundaries for a real application, not just trying to write one-off SQL in Kotlin.
What this skill is for
Use the kotlin-exposed-patterns skill when you need a clearer implementation path for Exposed DSL queries, DAO-style entity access, HikariCP setup, Flyway migrations, or repository abstraction. It is especially relevant for Database Engineering work where coroutine-safe transaction flow and maintainable data access matter.
What makes it useful
The value here is not “what Exposed is,” but how the pieces fit together in production: when to use DSL vs DAO, how newSuspendedTransaction changes your service boundaries, and how to keep schema migrations and connection pooling aligned. That makes kotlin-exposed-patterns install decisions easier for teams that want fewer hidden assumptions in their data layer.
Best fit and misfit
This skill fits Kotlin backend services, API layers, and data-heavy applications that already use or plan to use Exposed. It is a weaker fit if you need a general SQL tutorial, a framework-agnostic ORM comparison, or a full production architecture guide outside the database layer.
How to Use kotlin-exposed-patterns skill
Install and inspect the right files first
Install with npx skills add affaan-m/everything-claude-code --skill kotlin-exposed-patterns. After install, read skills/kotlin-exposed-patterns/SKILL.md first, then trace any linked examples or file references in the repo. Because this skill does not rely on extra rules/, resources/, or scripts, the main learning path is the skill body itself plus the example sections it points to.
Turn your goal into a usable prompt
For best kotlin-exposed-patterns usage, give the skill a concrete target such as: “Implement a repository for users and orders with Exposed DSL, HikariCP, Flyway, and coroutine transactions.” Include the database, whether you want DSL or DAO, whether the app is coroutine-based, and any constraints like H2 for tests or PostgreSQL in production. Vague asks like “set up Exposed” usually produce generic advice; specific asks produce an actionable pattern.
What to ask for in practice
A strong kotlin-exposed-patterns guide request should name the tables, query style, transaction model, and integration points. For example: “Show how to fetch a user by UUID, write a migration for the table, and wrap it behind a repository interface using newSuspendedTransaction.” That gives the skill enough context to recommend the right pattern instead of mixing DSL, DAO, and infrastructure concerns.
Read the workflow in this order
Start with “When to Use” and “How It Works” to decide whether the repository pattern or direct Exposed access fits your codebase. Then inspect the DSL and DAO examples to match your preferred style. If you are adopting kotlin-exposed-patterns for Database Engineering, pay special attention to how connection pooling, migrations, and test database choices are separated from business logic.
kotlin-exposed-patterns skill FAQ
Is kotlin-exposed-patterns only for Exposed beginners?
No. Beginners can use it to avoid mixing up DSL, DAO, and transactions, but the stronger audience is engineers who want a repeatable pattern for real services. If you already know Exposed, the skill still helps by tightening structure and reducing ad hoc database code.
How is this different from a normal prompt?
A normal prompt may give you a single answer, but kotlin-exposed-patterns is meant to guide a repeatable workflow around Exposed usage, transaction safety, migrations, and repository boundaries. That matters when you want the output to fit an existing codebase rather than a generic example.
When should I not use it?
Skip it if you need raw SQL only, a non-Kotlin persistence stack, or an architecture decision that is unrelated to data access. It is also not the best choice if your main problem is domain modeling rather than database implementation.
Does it fit production work?
Yes, if your goal is to make Exposed code more maintainable and predictable. The main production-relevant pieces are coroutine-safe transactions, HikariCP-backed connections, versioned migrations, and a repository layer that keeps SQL details out of your services.
How to Improve kotlin-exposed-patterns skill
Give the skill your exact database shape
The best kotlin-exposed-patterns install outcome comes from describing tables, relationships, and query needs up front. Include primary keys, foreign keys, JSON columns, and whether you need pagination, joins, or soft deletes. The more concrete your schema, the less the output drifts into generic Exposed examples.
State the operational constraints
If you care about PostgreSQL, H2 test parity, coroutine support, or startup migrations, say so explicitly. Those details change how the skill should frame HikariCP, newSuspendedTransaction, and Flyway usage, and they often determine whether a pattern is safe to adopt.
Ask for one layer at a time
For better kotlin-exposed-patterns usage, request the schema, then the query layer, then the repository layer, then tests. This reduces accidental coupling and makes it easier to spot where the output is too abstract or where it assumes a setup you do not have.
Iterate against real code, not just examples
After the first answer, compare the pattern to your current module structure and adjust the request with the missing details: package names, service methods, migration naming, or test database choice. If something feels overcomplicated, ask for a narrower version focused on one Exposed path, such as DSL-only reads or DAO-only writes.