Introducing Aerospike agent skills: From AI-assisted coding to better database design

Getting productive with a new database usually means following a familiar sequence: read the documentation, learn the API, understand the data model, work through examples, and only then start building. That sequence looks different in 2026. With AI coding agents, developers can go from an idea to a working prototype in minutes, dramatically lowering the initial friction of adopting and learning a technology. Agents can now reliably do all the heavy lifting of writing client code, explaining unfamiliar APIs, generating tests, troubleshooting errors, and iterating on an application alongside the developer.

That said, an AI agent can be very good at writing code without necessarily knowing what good database code looks like for a particular database. A generic coding agent may know how to write a get, put, query, or update operation, and even produce syntactically valid Aerospike code. But Aerospike has its own policies, collections, expressions, indexing capabilities, access-pattern-driven modeling practices, and client idioms. Knowing how to invoke an API is different from knowing when that API is the right choice.

We’re addressing this knowledge gap with agent skills, resources that give AI coding agents the product-specific knowledge to build well with Aerospike: client idioms, policies, collections, expressions, indexing, and data modeling. Rather than simply helping an AI agent generate better Aerospike code, they help both developers and agents make better decisions earlier in the development process. For design-time work, when an application's data model doesn't exist yet, agent skills draw on the data modeling guide, which walks through deriving a model from an application's requirements and access patterns before any implementation code gets written.

The impact of product-specific expertise

Because data modeling happens early in the application lifecycle, the consequences of a poor data model may not surface until much later, when increasing data volume, traffic, concurrency, or feature requirements expose weaknesses that were invisible when the application was small. This makes product-specific guidance especially valuable when foundational architectural decisions are being made. For example, storing 1,000 related events as separate records may work, but if they are always accessed together, a bounded collection could be far more efficient. The wrong choice can lead to unnecessary operations, network traffic, and storage overhead at scale.

With the new Aerospike agent skills, an AI agent can develop a deeper understanding of Aerospike's data modeling patterns, ask better questions before implementation, recognize appropriate approaches, and avoid assumptions carried over from other databases. The result is a more useful form of AI assistance: not simply generating more code per minute, but helping make better decisions about what code needs to be written in the first place.

And the results speak for themselves. In an evaluation using a realistic corpus of development and data modeling tasks, the agent achieved a 99.0% score with the Aerospike skills, compared with 92.9% without them.

Agent skills: Build with Aerospike

Aerospike's agent-skills repository gives AI agents practical, product-specific knowledge for working with Aerospike throughout the development lifecycle. It covers everything from local setup and application development to data modeling, with guidance on client development, policies, collections, expressions, indexes, batch operations, and modeling patterns.

Developers with limited Aerospike experience can ask an agent to create a local instance, connect a client, write a record, read it back, and start experimenting without first becoming an expert in the database. The agent relies on the agent skills to provide Aerospike-specific context as it is needed, while the developer stays focused on the application they are building. This knowledge is instrumental when working with collection data types, expressions, indexing, policies, and client-specific APIs. Aerospike's client libraries span multiple programming languages, while its newer Developer SDKs emphasize intuitive, language-native interfaces and readable Aerospike Expression Language (AEL) queries.

By putting this product-specific knowledge directly into the development environment, the skills reduce the gap between an agent that can generate code and one that can build effectively with Aerospike.

Data modeling guide: Design with Aerospike

For greenfield applications or redesigns that require data modeling decisions, agent skills draw on the data modeling guide that walks the agent through the design process. This gives agents the Aerospike-specific knowledge to implement applications and the guidance to make sound architectural decisions before implementation begins.

Valid code isn't necessarily good database code. An agent can generate an operation that compiles and executes correctly while still producing a poor data model. It can answer "How do I write this Aerospike operation?" without answering the more important question: "Is this the right way to represent my application's data in the first place?"

This is where the data-modeling-guide comes in. Designed for both humans and AI coding agents, the guide allows users to determine what the application actually needs from its database before generating implementation code. It focuses on record granularity, key design, bin structure, relationships, indexing, server-side filtering, and modeling decisions that follow from an application's requirements and access patterns.

Crucially, the guide produces two artifacts. The first is a schema guide: the detailed design document containing the entity and relationship map, access-pattern matrix, key and bin schemas, example records, relationship decisions, sizing considerations, index rationale, growth and hot-key plans, validation plans, assumptions, and rejected alternatives.

The second is a schema summary: a condensed reference for developers implementing the model, containing the operational contract without all of the design reasoning.

From code generation to development decisions

Aerospike’s agent skills point to a broader shift in AI-assisted software development. As code generation becomes increasingly cheap, the value of sound architectural judgment only grows.

Consider a developer asking an AI agent to implement a user profile store in Aerospike. The implementation question may be straightforward (e.g., How should I write and update a specific record?), but preceded by more consequential questions:

• What should the record actually contain?

• Should related data be consolidated?

• Should a relationship be represented inside a collection or as separate records?

• What should the primary key look like?

• Which access patterns need to be supported?

• What should be indexed?

• How frequently will the record change?

• Could a seemingly convenient design create a hot-key problem later?

The answers and decisions made during data modeling can shape an application's behavior long after the original code has been deployed to production. The data modeling guide brings that reasoning into the AI-assisted workflow, giving the agent a structured way to translate application requirements into a concrete data model before implementing the code that depends on it. This separates the work of deciding how the application’s data should be represented from the subsequent work of implementing that design.

Aerospike is making database development more agent-friendly

Aerospike's developer experience is increasingly AI-aware, with predictable, language-native SDKs and readable expressions that reduce ambiguity for both developers and AI agents. Tools such as Aerospike Voyager and its MCP server, AEL, and AI-readable documentation create a more consistent path from experimentation to implementation. Together with Aerospike agent skills, these capabilities support a broader AI-assisted development loop: 

understand → model → build → inspect → iterate

And while good APIs help agents get the implementation right, understanding the application’s data model enables them to make better architectural decisions rather than simply choosing the right commands.

Designed to grow with the development workflow

The initial release focuses on the core development and modeling capabilities needed to get developers productive with Aerospike and to guide the design process. This leaves room for the skills to expand as both Aerospike and AI-assisted development evolve. Future skills could cover additional Aerospike capabilities, development workflows, testing patterns, code migration scenarios, and other tasks where product-specific expertise can improve an agent's output.

The repositories are released under the Apache 2.0 license, making them available for developers and teams to inspect, use, adapt, and contribute to. The result is not intended to replace developers who understand databases. If anything, it makes that expertise more useful by giving developers a way to encode it into the tools they already use.

What this means for developers

For someone evaluating Aerospike, the practical benefit is a shorter path to experimentation. Instead of spending days learning enough of the platform to determine whether it fits an application, a developer can use an AI coding agent to get a local environment running, work through the basics, and begin testing an actual application. For developers prototyping a new product, the skills can help move from requirements to working code more quickly while keeping Aerospike-specific practices in the loop.

The skills provide a consistent source of product-specific guidance for the AI agents already being introduced into development workflows. This can reduce another emerging problem for teams: every developer maintaining their own collection of prompts, snippets, rules, and tribal knowledge about how an AI agent should work with the database. And for architects, the data-modeling workflow offers a particularly useful way to make database design decisions explicit. The resulting schema guide captures assumptions and rejected alternatives rather than reducing architecture to the final schema alone. This gives teams something to review, challenge, and revisit as requirements change.

Perhaps most importantly, none of this requires developers to hand control to an autonomous agent. Agent skills are equally useful in a collaborative workflow in which the developer actively directs the agent, reviews its suggestions, challenges its assumptions, and decides what ultimately goes into production. The developer remains in the loop. The agent simply has better tools and better context.

Start building

The easiest way to understand the value of Aerospike agent skills is to put them against a real application. Install the Aerospike agent skills, point your coding agent at an application, and see how much of the Aerospike-specific groundwork it can handle.

For a new application, use the agent skills with the Aerospike data modeling guide before committing to a schema. Start with the application's requirements and access patterns, work through the modeling decisions, and preserve the reasoning behind the resulting design.

The published skills can be installed through the open agent skills CLI with a single npx skills add command, and the repository provides guidance for using them with supported AI coding environments. And if the model or the skills themselves can be improved, please contribute to the project.

AI coding agents are changing how developers interact with software platforms. The next step is to make sure those agents understand not only how to call an API but also how to use the technology effectively. For Aerospike, agent skills are a step in that direction, going from AI that can write Aerospike code to AI that can help developers make better Aerospike decisions.