Provides TypeScript patterns for DynamoDB-Toolbox v2 including schema/table/entity modeling, .build() command workflow, query/scan access patterns, batch and transaction operations, and single-table design with computed keys.
SkillScore100Maintained
Automatic
◆Coding pack
Last verified 8/21/2026
What it changes
Passed 22 of 22 test cases with the skill, and 13 of 22 without it.
Without skill59%
With skill100%
Checks it passed that the model alone missed
Imports Table from dynamodb-toolbox/table
Imports item from dynamodb-toolbox/schema
Uses computeKey property in Entity definition
and 12 more in the full report
9 fixed13 passed either way0 still failing0 broke
Pass-rate lift
+41 pp
Tokens
+62%
Agent turns
0%
Response time
-34%
Model gemini-3.6-flashMeasured 8/21/2026v122 of 22 cases passed with skill
Tokens, turns and time describe resource use, not a dollar price.
See it in action
One of 9 test cases the skill fixed. Same model, same prompt, with and without the skill.
1 of 9
Prompt
Provide a TypeScript import snippet for the primitive schema helper functions (such as string, number, list, map) in DynamoDB-Toolbox v2.
What was checked, without and with the skill
Checked
Without skill
With skill
Imports schema helpers from dynamodb-toolbox/schema
Missed
Passed
case-09 · gemini-3.6-flash · 8/21/2026 · answers are capped and redacted
What's inside
The instructions your model reads when the skill loads.
SKILL.md185 lines2 files
DynamoDB-Toolbox v2 Patterns (TypeScript)
Overview
This skill provides practical TypeScript patterns for using DynamoDB-Toolbox v2 with AWS SDK v3 DocumentClient. It focuses on type-safe schema modeling, .build() command usage, and production-ready single-table design.
When to Use
Defining DynamoDB tables and entities with strict TypeScript inference
Modeling schemas with item, string, number, list, set, map, and record
Implementing GetItem, PutItem, UpdateItem, DeleteItem via .build()
Building query and scan access paths with primary keys and GSIs
Handling batch and transactional operations
Designing single-table systems with computed keys and entity patterns
Instructions
Start from access patterns: identify read/write queries first, then design keys.
Create table + entity boundaries: one table, multiple entities if using single-table design.
Define schemas with constraints: apply .key(), .required(), .default(), .transform(), .link().
Use .build() commands everywhere: avoid ad-hoc command construction for consistency and type safety.
Add query/index coverage: validate GSI/LSI paths for each required access pattern.
Use batch/transactions intentionally: batch for throughput, transactions for atomicity.
Keep items evolvable: use optional fields, defaults, and derived attributes for schema evolution.
Manage persistent Knowledge Graph for specifications. Provides read, query, update, and validation capabilities for codebase analysis caching. Use when: spec-to-tasks needs to cache/reuse codebase analysis, task-implementation needs to validate task dependencies or contracts, spec-quality needs to synchronize provides, or any command needs to query existing patterns/components/APIs. Reduces redundant codebase exploration by caching agent discoveries.